js.documents 14.4.56 → 14.4.58

package/dist/odb/sql/evaluate-columns.cjs

@@ -0,0 +1,122 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_sql_errors = require("./errors.cjs");
+//#region src/odb/sql/evaluate-columns.ts
+function tryResolveName(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);
+		return folded[0];
+	}
+}
+function resolveName(candidates, ref, what, sql) {
+	const found = tryResolveName(candidates, ref, what, sql);
+	if (found !== void 0) return found;
+	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;
+}
+function columnAt(columns, index, sql) {
+	const column = columns[index];
+	if (column === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column index ${String(index)} is outside the joined column list`, sql);
+	return column;
+}
+function valueAtIndex(row, index, sql) {
+	const value = row[index];
+	if (value === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`malformed joined row: it carries ${String(row.length)} values but index ${String(index)} was expected`, sql);
+	return value;
+}
+function tryResolveColumnIndex(columns, candidateIndices, ref, sql) {
+	let firstExact;
+	let exactCount = 0;
+	for (const index of candidateIndices) if (columns[index]?.columnName === ref.name) {
+		exactCount += 1;
+		firstExact ??= index;
+	}
+	if (exactCount > 1) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column "${ref.name}" is ambiguous—it matches more than one joined column named "${ref.name}"`, sql);
+	if (firstExact !== void 0) return firstExact;
+	if (!ref.quoted) {
+		let firstFolded;
+		const foldedNames = [];
+		for (const index of candidateIndices) {
+			const name = columns[index]?.columnName;
+			if (name?.toUpperCase() !== ref.name) continue;
+			foldedNames.push(name);
+			firstFolded ??= index;
+		}
+		if (foldedNames.length > 1) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column "${ref.name}" is ambiguous—it matches ${foldedNames.join(", ")} case-insensitively`, sql);
+		return firstFolded;
+	}
+}
+function resolveColumnIndex(columns, candidateIndices, ref, sql) {
+	const index = tryResolveColumnIndex(columns, candidateIndices, ref, sql);
+	if (index !== void 0) return index;
+	throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`column "${ref.name}" not found—available: ${candidateIndices.length === 0 ? "(none)" : candidateIndices.map((candidate) => columns[candidate]?.columnName ?? "?").join(", ")}`, sql);
+}
+var ColumnResolver = class {
+	sql;
+	outer;
+	cache = /* @__PURE__ */ new Map();
+	columns;
+	qualifierNames;
+	constructor(columns, sql, outer) {
+		this.sql = sql;
+		this.outer = outer;
+		this.columns = columns;
+		this.qualifierNames = [...new Set(columns.flatMap((column) => column.qualifiers))];
+	}
+	get columnCount() {
+		return this.columns.length;
+	}
+	nameAt(index) {
+		return columnAt(this.columns, index, this.sql).columnName;
+	}
+	indexOf(ref) {
+		const cached = this.cache.get(ref);
+		if (cached !== void 0) return cached;
+		const qualifierName = ref.qualifier === void 0 ? void 0 : resolveName(this.qualifierNames, ref.qualifier, "table qualifier", this.sql);
+		const index = resolveColumnIndex(this.columns, this.candidateIndicesFor(qualifierName), ref.column, this.sql);
+		this.cache.set(ref, index);
+		return index;
+	}
+	tryLocalIndexOf(ref) {
+		const cached = this.cache.get(ref);
+		if (cached !== void 0) return cached;
+		let qualifierName;
+		if (ref.qualifier !== void 0) {
+			qualifierName = tryResolveName(this.qualifierNames, ref.qualifier, "table qualifier", this.sql);
+			if (qualifierName === void 0) return;
+		}
+		const index = tryResolveColumnIndex(this.columns, this.candidateIndicesFor(qualifierName), ref.column, this.sql);
+		if (index === void 0) return;
+		this.cache.set(ref, index);
+		return index;
+	}
+	candidateIndicesFor(qualifierName) {
+		if (qualifierName === void 0) return this.columns.map((_column, index) => index);
+		return this.columns.map((column, index) => column.qualifiers.includes(qualifierName) ? index : -1).filter((index) => index >= 0);
+	}
+	valueAt(index, row) {
+		return valueAtIndex(row, index, this.sql);
+	}
+	valueOf(ref, row) {
+		const localIndex = this.tryLocalIndexOf(ref);
+		if (localIndex !== void 0) return this.valueAt(localIndex, row);
+		if (this.outer !== void 0) return this.outer.resolver.valueOf(ref, this.outer.row);
+		return this.valueAt(this.indexOf(ref), row);
+	}
+};
+//#endregion
+exports.ColumnResolver = ColumnResolver;
+exports.columnAt = columnAt;
+exports.resolveColumnIndex = resolveColumnIndex;
+exports.resolveName = resolveName;
+exports.resolveTable = resolveTable;
+exports.tryResolveColumnIndex = tryResolveColumnIndex;
+exports.tryResolveName = tryResolveName;
+exports.valueAtIndex = valueAtIndex;

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

@@ -0,0 +1,2 @@
+import { a as columnAt, c as resolveTable, d as valueAtIndex, i as SharedColumnPair, l as tryResolveColumnIndex, n as OuterScope, o as resolveColumnIndex, r as ResolvedColumn, s as resolveName, t as ColumnResolver, u as tryResolveName } from "../../evaluate-columns-CyqKHkIW.cjs";
+export { ColumnResolver, OuterScope, ResolvedColumn, SharedColumnPair, columnAt, resolveColumnIndex, resolveName, resolveTable, tryResolveColumnIndex, tryResolveName, valueAtIndex };

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

@@ -0,0 +1,2 @@
+import { a as columnAt, c as resolveTable, d as valueAtIndex, i as SharedColumnPair, l as tryResolveColumnIndex, n as OuterScope, o as resolveColumnIndex, r as ResolvedColumn, s as resolveName, t as ColumnResolver, u as tryResolveName } from "../../evaluate-columns-cOo8fOfT.js";
+export { ColumnResolver, OuterScope, ResolvedColumn, SharedColumnPair, columnAt, resolveColumnIndex, resolveName, resolveTable, tryResolveColumnIndex, tryResolveName, valueAtIndex };

package/dist/odb/sql/evaluate-columns.js

@@ -0,0 +1,114 @@
+import { HsqldbSqlEvaluationError } from "./errors.js";
+//#region src/odb/sql/evaluate-columns.ts
+function tryResolveName(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);
+		return folded[0];
+	}
+}
+function resolveName(candidates, ref, what, sql) {
+	const found = tryResolveName(candidates, ref, what, sql);
+	if (found !== void 0) return found;
+	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;
+}
+function columnAt(columns, index, sql) {
+	const column = columns[index];
+	if (column === void 0) throw new HsqldbSqlEvaluationError(`column index ${String(index)} is outside the joined column list`, sql);
+	return column;
+}
+function valueAtIndex(row, index, sql) {
+	const value = row[index];
+	if (value === void 0) throw new HsqldbSqlEvaluationError(`malformed joined row: it carries ${String(row.length)} values but index ${String(index)} was expected`, sql);
+	return value;
+}
+function tryResolveColumnIndex(columns, candidateIndices, ref, sql) {
+	let firstExact;
+	let exactCount = 0;
+	for (const index of candidateIndices) if (columns[index]?.columnName === ref.name) {
+		exactCount += 1;
+		firstExact ??= index;
+	}
+	if (exactCount > 1) throw new HsqldbSqlEvaluationError(`column "${ref.name}" is ambiguous—it matches more than one joined column named "${ref.name}"`, sql);
+	if (firstExact !== void 0) return firstExact;
+	if (!ref.quoted) {
+		let firstFolded;
+		const foldedNames = [];
+		for (const index of candidateIndices) {
+			const name = columns[index]?.columnName;
+			if (name?.toUpperCase() !== ref.name) continue;
+			foldedNames.push(name);
+			firstFolded ??= index;
+		}
+		if (foldedNames.length > 1) throw new HsqldbSqlEvaluationError(`column "${ref.name}" is ambiguous—it matches ${foldedNames.join(", ")} case-insensitively`, sql);
+		return firstFolded;
+	}
+}
+function resolveColumnIndex(columns, candidateIndices, ref, sql) {
+	const index = tryResolveColumnIndex(columns, candidateIndices, ref, sql);
+	if (index !== void 0) return index;
+	throw new HsqldbSqlEvaluationError(`column "${ref.name}" not found—available: ${candidateIndices.length === 0 ? "(none)" : candidateIndices.map((candidate) => columns[candidate]?.columnName ?? "?").join(", ")}`, sql);
+}
+var ColumnResolver = class {
+	sql;
+	outer;
+	cache = /* @__PURE__ */ new Map();
+	columns;
+	qualifierNames;
+	constructor(columns, sql, outer) {
+		this.sql = sql;
+		this.outer = outer;
+		this.columns = columns;
+		this.qualifierNames = [...new Set(columns.flatMap((column) => column.qualifiers))];
+	}
+	get columnCount() {
+		return this.columns.length;
+	}
+	nameAt(index) {
+		return columnAt(this.columns, index, this.sql).columnName;
+	}
+	indexOf(ref) {
+		const cached = this.cache.get(ref);
+		if (cached !== void 0) return cached;
+		const qualifierName = ref.qualifier === void 0 ? void 0 : resolveName(this.qualifierNames, ref.qualifier, "table qualifier", this.sql);
+		const index = resolveColumnIndex(this.columns, this.candidateIndicesFor(qualifierName), ref.column, this.sql);
+		this.cache.set(ref, index);
+		return index;
+	}
+	tryLocalIndexOf(ref) {
+		const cached = this.cache.get(ref);
+		if (cached !== void 0) return cached;
+		let qualifierName;
+		if (ref.qualifier !== void 0) {
+			qualifierName = tryResolveName(this.qualifierNames, ref.qualifier, "table qualifier", this.sql);
+			if (qualifierName === void 0) return;
+		}
+		const index = tryResolveColumnIndex(this.columns, this.candidateIndicesFor(qualifierName), ref.column, this.sql);
+		if (index === void 0) return;
+		this.cache.set(ref, index);
+		return index;
+	}
+	candidateIndicesFor(qualifierName) {
+		if (qualifierName === void 0) return this.columns.map((_column, index) => index);
+		return this.columns.map((column, index) => column.qualifiers.includes(qualifierName) ? index : -1).filter((index) => index >= 0);
+	}
+	valueAt(index, row) {
+		return valueAtIndex(row, index, this.sql);
+	}
+	valueOf(ref, row) {
+		const localIndex = this.tryLocalIndexOf(ref);
+		if (localIndex !== void 0) return this.valueAt(localIndex, row);
+		if (this.outer !== void 0) return this.outer.resolver.valueOf(ref, this.outer.row);
+		return this.valueAt(this.indexOf(ref), row);
+	}
+};
+//#endregion
+export { ColumnResolver, columnAt, resolveColumnIndex, resolveName, resolveTable, tryResolveColumnIndex, tryResolveName, valueAtIndex };

package/dist/odb/sql/evaluate-predicates.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_evaluate = require("../../evaluate-CEzsBx3w.cjs");
+exports.andTruth = require_evaluate.andTruth;
+exports.compareValues = require_evaluate.compareValues;
+exports.evaluateExists = require_evaluate.evaluateExists;
+exports.evaluateIn = require_evaluate.evaluateIn;
+exports.evaluateInSubquery = require_evaluate.evaluateInSubquery;
+exports.evaluateLike = require_evaluate.evaluateLike;
+exports.evaluatePredicate = require_evaluate.evaluatePredicate;
+exports.likePatternToRegExp = require_evaluate.likePatternToRegExp;
+exports.literalToValue = require_evaluate.literalToValue;
+exports.notTruth = require_evaluate.notTruth;
+exports.operandValue = require_evaluate.operandValue;
+exports.orTruth = require_evaluate.orTruth;
+exports.sqlFailure = require_evaluate.sqlFailure;
+exports.truthOfComparison = require_evaluate.truthOfComparison;

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

@@ -0,0 +1,23 @@
+import { r as HsqldbTable } from "../../script-pkZ2Kor4.cjs";
+import { t as SqlComparisonOperator } from "../../lexer-DgsW7jMA.cjs";
+import { d as SqlOperand, h as SqlSelectStatement, l as SqlLiteral, p as SqlPredicate } from "../../parser-BTA1wXPd.cjs";
+import { t as ColumnResolver } from "../../evaluate-columns-CyqKHkIW.cjs";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/sql/evaluate-predicates.d.ts
+type Truth = "true" | "false" | "unknown";
+declare function sqlFailure(sql: string): (message: string) => Error;
+declare function compareValues(left: ContentCellValue, right: ContentCellValue, sql: string): number;
+declare function truthOfComparison(ordering: number, operator: SqlComparisonOperator): Truth;
+declare function notTruth(truth: Truth): Truth;
+declare function andTruth(left: Truth, right: Truth): Truth;
+declare function orTruth(left: Truth, right: Truth): Truth;
+declare function literalToValue(literal: SqlLiteral): ContentCellValue;
+declare function likePatternToRegExp(pattern: string): RegExp;
+declare function operandValue(operand: SqlOperand, row: readonly ContentCellValue[], resolver: ColumnResolver): ContentCellValue;
+declare function evaluateLike(value: ContentCellValue, pattern: string, sql: string): Truth;
+declare function evaluateIn(value: ContentCellValue, values: readonly SqlLiteral[], sql: string): Truth;
+declare function evaluatePredicate(predicate: SqlPredicate, row: readonly ContentCellValue[], resolver: ColumnResolver, tables: readonly HsqldbTable[], sql: string): Truth;
+declare function evaluateInSubquery(value: ContentCellValue, query: SqlSelectStatement, tables: readonly HsqldbTable[], outerResolver: ColumnResolver, outerRow: readonly ContentCellValue[], sql: string): Truth;
+declare function evaluateExists(query: SqlSelectStatement, tables: readonly HsqldbTable[], outerResolver: ColumnResolver, outerRow: readonly ContentCellValue[]): Truth;
+//#endregion
+export { Truth, andTruth, compareValues, evaluateExists, evaluateIn, evaluateInSubquery, evaluateLike, evaluatePredicate, likePatternToRegExp, literalToValue, notTruth, operandValue, orTruth, sqlFailure, truthOfComparison };

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

@@ -0,0 +1,23 @@
+import { r as HsqldbTable } from "../../script-pkZ2Kor4.js";
+import { t as SqlComparisonOperator } from "../../lexer-DgsW7jMA.js";
+import { d as SqlOperand, h as SqlSelectStatement, l as SqlLiteral, p as SqlPredicate } from "../../parser-CoIi0l9I.js";
+import { t as ColumnResolver } from "../../evaluate-columns-cOo8fOfT.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/sql/evaluate-predicates.d.ts
+type Truth = "true" | "false" | "unknown";
+declare function sqlFailure(sql: string): (message: string) => Error;
+declare function compareValues(left: ContentCellValue, right: ContentCellValue, sql: string): number;
+declare function truthOfComparison(ordering: number, operator: SqlComparisonOperator): Truth;
+declare function notTruth(truth: Truth): Truth;
+declare function andTruth(left: Truth, right: Truth): Truth;
+declare function orTruth(left: Truth, right: Truth): Truth;
+declare function literalToValue(literal: SqlLiteral): ContentCellValue;
+declare function likePatternToRegExp(pattern: string): RegExp;
+declare function operandValue(operand: SqlOperand, row: readonly ContentCellValue[], resolver: ColumnResolver): ContentCellValue;
+declare function evaluateLike(value: ContentCellValue, pattern: string, sql: string): Truth;
+declare function evaluateIn(value: ContentCellValue, values: readonly SqlLiteral[], sql: string): Truth;
+declare function evaluatePredicate(predicate: SqlPredicate, row: readonly ContentCellValue[], resolver: ColumnResolver, tables: readonly HsqldbTable[], sql: string): Truth;
+declare function evaluateInSubquery(value: ContentCellValue, query: SqlSelectStatement, tables: readonly HsqldbTable[], outerResolver: ColumnResolver, outerRow: readonly ContentCellValue[], sql: string): Truth;
+declare function evaluateExists(query: SqlSelectStatement, tables: readonly HsqldbTable[], outerResolver: ColumnResolver, outerRow: readonly ContentCellValue[]): Truth;
+//#endregion
+export { Truth, andTruth, compareValues, evaluateExists, evaluateIn, evaluateInSubquery, evaluateLike, evaluatePredicate, likePatternToRegExp, literalToValue, notTruth, operandValue, orTruth, sqlFailure, truthOfComparison };

package/dist/odb/sql/evaluate-predicates.js

@@ -0,0 +1,2 @@
+import { _ as operandValue, b as truthOfComparison, c as compareValues, d as evaluateInSubquery, f as evaluateLike, g as notTruth, h as literalToValue, l as evaluateExists, m as likePatternToRegExp, p as evaluatePredicate, s as andTruth, u as evaluateIn, v as orTruth, y as sqlFailure } from "../../evaluate-IK-3aMv5.js";
+export { andTruth, compareValues, evaluateExists, evaluateIn, evaluateInSubquery, evaluateLike, evaluatePredicate, likePatternToRegExp, literalToValue, notTruth, operandValue, orTruth, sqlFailure, truthOfComparison };