js.documents 14.4.56 → 14.4.57

package/dist/evaluate-CEzsBx3w.cjs

@@ -0,0 +1,564 @@
+const require_odb_values = require("./odb/values.cjs");
+const require_odb_sql_errors = require("./odb/sql/errors.cjs");
+const require_odb_sql_evaluate_columns = require("./odb/sql/evaluate-columns.cjs");
+//#region src/odb/sql/evaluate-predicates.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";
+	}
+	return assertNeverOperator(operator);
+}
+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;
+	}
+	return assertNeverLiteralKind(literal);
+}
+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 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, tables, 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 "inSubquery": {
+			const truth = evaluateInSubquery(operandValue(predicate.operand, row, resolver), predicate.query, tables, resolver, row, 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 "exists": return evaluateExists(predicate.query, tables, resolver, row);
+		case "not": return notTruth(evaluatePredicate(predicate.predicate, row, resolver, tables, sql));
+		case "and": return andTruth(evaluatePredicate(predicate.left, row, resolver, tables, sql), evaluatePredicate(predicate.right, row, resolver, tables, sql));
+		case "or": return orTruth(evaluatePredicate(predicate.left, row, resolver, tables, sql), evaluatePredicate(predicate.right, row, resolver, tables, sql));
+	}
+	return assertNeverPredicateKind(predicate);
+}
+function evaluateInSubquery(value, query, tables, outerResolver, outerRow, sql) {
+	if (value.kind === "empty") return "unknown";
+	const result = evaluateSelectInScope(query, tables, {
+		resolver: outerResolver,
+		row: outerRow
+	});
+	if (result.columns.length !== 1) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`IN (SELECT ...) requires the subquery to produce exactly one column, but it produced ${String(result.columns.length)} (${result.columns.length === 0 ? "none" : result.columns.join(", ")})`, sql);
+	let sawNull = false;
+	for (const candidateRow of result.rows) {
+		const candidate = candidateRow[0];
+		if (candidate === void 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError("malformed subquery row: it declares one column but carries none", sql);
+		if (candidate.kind === "empty") {
+			sawNull = true;
+			continue;
+		}
+		if (compareValues(value, candidate, sql) === 0) return "true";
+	}
+	return sawNull ? "unknown" : "false";
+}
+function evaluateExists(query, tables, outerResolver, outerRow) {
+	return evaluateSelectInScope(query, tables, {
+		resolver: outerResolver,
+		row: outerRow
+	}).rows.length > 0 ? "true" : "false";
+}
+//#endregion
+//#region src/odb/sql/evaluate.ts
+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}`;
+		}
+		return assertNeverValueKind(value);
+	}).join("\0");
+}
+function planSelectList(statement, resolver) {
+	const plan = [];
+	for (const item of statement.items) switch (item.kind) {
+		case "star":
+			for (let index = 0; index < resolver.columnCount; index += 1) 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 tableColumns(qualifier, table) {
+	return table.columns.map((column) => ({
+		qualifiers: [qualifier],
+		columnName: column.name
+	}));
+}
+function nullRow(count) {
+	return new Array(count).fill(require_odb_values.CELL_NULL);
+}
+function computeNaturalSharedPairs(leftColumns, rightColumns, sql) {
+	const rightIndexByName = /* @__PURE__ */ new Map();
+	const ambiguousRightNames = /* @__PURE__ */ new Set();
+	rightColumns.forEach((column, index) => {
+		if (rightIndexByName.has(column.columnName)) ambiguousRightNames.add(column.columnName);
+		else rightIndexByName.set(column.columnName, index);
+	});
+	const pairs = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	leftColumns.forEach((leftColumn, leftIndex) => {
+		const rightIndex = rightIndexByName.get(leftColumn.columnName);
+		if (rightIndex === void 0) return;
+		if (ambiguousRightNames.has(leftColumn.columnName) || seenNames.has(leftColumn.columnName)) throw new require_odb_sql_errors.HsqldbSqlEvaluationError(`NATURAL JOIN cannot determine a unique match for column "${leftColumn.columnName}"—more than one column shares that name on one side of the join`, sql);
+		seenNames.add(leftColumn.columnName);
+		pairs.push({
+			leftIndex,
+			rightIndex,
+			columnName: leftColumn.columnName
+		});
+	});
+	return pairs;
+}
+function evaluateSharedColumnMatch(combined, pairs, leftColumnCount, sql) {
+	return pairs.every((pair) => {
+		const left = require_odb_sql_evaluate_columns.valueAtIndex(combined, pair.leftIndex, sql);
+		const right = require_odb_sql_evaluate_columns.valueAtIndex(combined, leftColumnCount + pair.rightIndex, sql);
+		return left.kind !== "empty" && right.kind !== "empty" && compareValues(left, right, sql) === 0;
+	});
+}
+function mergeSharedColumns(rawColumns, rows, sharedPairs, leftColumnCount, sql) {
+	const sharedLeftIndices = new Set(sharedPairs.map((pair) => pair.leftIndex));
+	const sharedRightIndices = new Set(sharedPairs.map((pair) => leftColumnCount + pair.rightIndex));
+	const remainingIndices = rawColumns.map((_column, index) => index).filter((index) => !sharedLeftIndices.has(index) && !sharedRightIndices.has(index));
+	return {
+		columns: [...sharedPairs.map((pair) => {
+			const leftColumn = require_odb_sql_evaluate_columns.columnAt(rawColumns, pair.leftIndex, sql);
+			const rightColumn = require_odb_sql_evaluate_columns.columnAt(rawColumns, leftColumnCount + pair.rightIndex, sql);
+			return {
+				qualifiers: [.../* @__PURE__ */ new Set([...leftColumn.qualifiers, ...rightColumn.qualifiers])],
+				columnName: leftColumn.columnName
+			};
+		}), ...remainingIndices.map((index) => require_odb_sql_evaluate_columns.columnAt(rawColumns, index, sql))],
+		rows: rows.map((row) => {
+			const mergedValues = sharedPairs.map((pair) => {
+				const leftValue = require_odb_sql_evaluate_columns.valueAtIndex(row, pair.leftIndex, sql);
+				const rightValue = require_odb_sql_evaluate_columns.valueAtIndex(row, leftColumnCount + pair.rightIndex, sql);
+				return leftValue.kind !== "empty" ? leftValue : rightValue;
+			});
+			const remainingValues = remainingIndices.map((index) => require_odb_sql_evaluate_columns.valueAtIndex(row, index, sql));
+			return [...mergedValues, ...remainingValues];
+		})
+	};
+}
+function applyJoinClause(left, join, tables, sql, outer) {
+	const rightTable = require_odb_sql_evaluate_columns.resolveTable(tables, join.table, sql);
+	const rightColumns = tableColumns(join.alias !== void 0 ? join.alias.name : rightTable.tableName, rightTable);
+	const leftColumnCount = left.columns.length;
+	const rawColumns = [...left.columns, ...rightColumns];
+	let onPredicate;
+	let sharedPairs = [];
+	if (join.condition.kind === "on") onPredicate = join.condition.predicate;
+	else if (join.condition.kind === "using") {
+		const allLeftIndices = left.columns.map((_column, index) => index);
+		const allRightIndices = rightColumns.map((_column, index) => index);
+		sharedPairs = join.condition.columns.map((ref) => {
+			const leftIndex = require_odb_sql_evaluate_columns.resolveColumnIndex(left.columns, allLeftIndices, ref, sql);
+			return {
+				leftIndex,
+				rightIndex: require_odb_sql_evaluate_columns.resolveColumnIndex(rightColumns, allRightIndices, ref, sql),
+				columnName: require_odb_sql_evaluate_columns.columnAt(left.columns, leftIndex, sql).columnName
+			};
+		});
+	} else if (join.condition.kind === "natural") {
+		sharedPairs = computeNaturalSharedPairs(left.columns, rightColumns, sql);
+		if (sharedPairs.length === 0) throw new require_odb_sql_errors.HsqldbSqlEvaluationError("NATURAL JOIN found no columns shared between the joined tables", sql);
+	}
+	const rawResolver = new require_odb_sql_evaluate_columns.ColumnResolver(rawColumns, sql, outer);
+	const matchedLeft = /* @__PURE__ */ new Set();
+	const matchedRight = /* @__PURE__ */ new Set();
+	const paired = [];
+	left.rows.forEach((leftRow, leftIndex) => {
+		rightTable.rows.forEach((rightRow, rightIndex) => {
+			const combined = [...leftRow, ...rightRow];
+			if (onPredicate !== void 0 ? evaluatePredicate(onPredicate, combined, rawResolver, tables, sql) === "true" : sharedPairs.length > 0 ? evaluateSharedColumnMatch(combined, sharedPairs, leftColumnCount, sql) : true) {
+				paired.push(combined);
+				matchedLeft.add(leftIndex);
+				matchedRight.add(rightIndex);
+			}
+		});
+	});
+	if (join.joinKind === "left" || join.joinKind === "full") left.rows.forEach((leftRow, leftIndex) => {
+		if (!matchedLeft.has(leftIndex)) paired.push([...leftRow, ...nullRow(rightColumns.length)]);
+	});
+	if (join.joinKind === "right" || join.joinKind === "full") rightTable.rows.forEach((rightRow, rightIndex) => {
+		if (!matchedRight.has(rightIndex)) paired.push([...nullRow(leftColumnCount), ...rightRow]);
+	});
+	if (join.condition.kind === "using" || join.condition.kind === "natural") return mergeSharedColumns(rawColumns, paired, sharedPairs, leftColumnCount, sql);
+	return {
+		columns: rawColumns,
+		rows: paired
+	};
+}
+function resolveFromSource(source, tables, sql) {
+	if (source.kind === "table") {
+		const table = require_odb_sql_evaluate_columns.resolveTable(tables, source.table, sql);
+		return {
+			columns: tableColumns(source.alias !== void 0 ? source.alias.name : table.tableName, table),
+			rows: table.rows
+		};
+	}
+	const result = evaluateSelectInScope(source.query, tables, void 0);
+	return {
+		columns: result.columns.map((name) => ({
+			qualifiers: [source.alias.name],
+			columnName: name
+		})),
+		rows: result.rows
+	};
+}
+function joinTables(from, tables, sql, outer) {
+	let result = resolveFromSource(from.source, tables, sql);
+	for (const join of from.joins) result = applyJoinClause(result, join, tables, sql, outer);
+	return result;
+}
+function evaluateSelect(statement, tables) {
+	return evaluateSelectInScope(statement, tables, void 0);
+}
+function evaluateSelectInScope(statement, tables, outer) {
+	const { columns, rows } = joinTables(statement.from, tables, statement.sql, outer);
+	const resolver = new require_odb_sql_evaluate_columns.ColumnResolver(columns, statement.sql, outer);
+	const plan = planSelectList(statement, resolver);
+	const where = statement.where;
+	const matching = where === void 0 ? rows : rows.filter((row) => evaluatePredicate(where, row, resolver, tables, 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);
+}
+function assertNeverOperator(value) {
+	throw new Error(`documents.js: unhandled operator ${JSON.stringify(value)}`);
+}
+function assertNeverLiteralKind(value) {
+	throw new Error(`documents.js: unhandled literal ${JSON.stringify(value)}`);
+}
+function assertNeverPredicateKind(value) {
+	throw new Error(`documents.js: unhandled predicate ${JSON.stringify(value)}`);
+}
+function assertNeverValueKind(value) {
+	throw new Error(`documents.js: unhandled value ${JSON.stringify(value)}`);
+}
+//#endregion
+Object.defineProperty(exports, "andTruth", {
+	enumerable: true,
+	get: function() {
+		return andTruth;
+	}
+});
+Object.defineProperty(exports, "assertNeverLiteralKind", {
+	enumerable: true,
+	get: function() {
+		return assertNeverLiteralKind;
+	}
+});
+Object.defineProperty(exports, "assertNeverOperator", {
+	enumerable: true,
+	get: function() {
+		return assertNeverOperator;
+	}
+});
+Object.defineProperty(exports, "assertNeverPredicateKind", {
+	enumerable: true,
+	get: function() {
+		return assertNeverPredicateKind;
+	}
+});
+Object.defineProperty(exports, "assertNeverValueKind", {
+	enumerable: true,
+	get: function() {
+		return assertNeverValueKind;
+	}
+});
+Object.defineProperty(exports, "compareValues", {
+	enumerable: true,
+	get: function() {
+		return compareValues;
+	}
+});
+Object.defineProperty(exports, "evaluateExists", {
+	enumerable: true,
+	get: function() {
+		return evaluateExists;
+	}
+});
+Object.defineProperty(exports, "evaluateIn", {
+	enumerable: true,
+	get: function() {
+		return evaluateIn;
+	}
+});
+Object.defineProperty(exports, "evaluateInSubquery", {
+	enumerable: true,
+	get: function() {
+		return evaluateInSubquery;
+	}
+});
+Object.defineProperty(exports, "evaluateLike", {
+	enumerable: true,
+	get: function() {
+		return evaluateLike;
+	}
+});
+Object.defineProperty(exports, "evaluatePredicate", {
+	enumerable: true,
+	get: function() {
+		return evaluatePredicate;
+	}
+});
+Object.defineProperty(exports, "evaluateSelect", {
+	enumerable: true,
+	get: function() {
+		return evaluateSelect;
+	}
+});
+Object.defineProperty(exports, "evaluateSelectInScope", {
+	enumerable: true,
+	get: function() {
+		return evaluateSelectInScope;
+	}
+});
+Object.defineProperty(exports, "likePatternToRegExp", {
+	enumerable: true,
+	get: function() {
+		return likePatternToRegExp;
+	}
+});
+Object.defineProperty(exports, "literalToValue", {
+	enumerable: true,
+	get: function() {
+		return literalToValue;
+	}
+});
+Object.defineProperty(exports, "notTruth", {
+	enumerable: true,
+	get: function() {
+		return notTruth;
+	}
+});
+Object.defineProperty(exports, "operandValue", {
+	enumerable: true,
+	get: function() {
+		return operandValue;
+	}
+});
+Object.defineProperty(exports, "orTruth", {
+	enumerable: true,
+	get: function() {
+		return orTruth;
+	}
+});
+Object.defineProperty(exports, "sqlFailure", {
+	enumerable: true,
+	get: function() {
+		return sqlFailure;
+	}
+});
+Object.defineProperty(exports, "truthOfComparison", {
+	enumerable: true,
+	get: function() {
+		return truthOfComparison;
+	}
+});

package/dist/{evaluate-C7fmk69X.d.ts → evaluate-D8fG2ZeB.d.ts}

@@ -1,5 +1,6 @@
 import { r as HsqldbTable } from "./script-pkZ2Kor4.js";
 import { h as SqlSelectStatement } from "./parser-CoIi0l9I.js";
+import { n as OuterScope } from "./evaluate-columns-cOo8fOfT.js";
 import { ContentCellValue } from "document-schema.js";
 //#region src/odb/sql/evaluate.d.ts
 interface SqlResultSet {
@@ -7,9 +8,10 @@ interface SqlResultSet {
   readonly rows: readonly (readonly ContentCellValue[])[];
 }
 declare function evaluateSelect(statement: SqlSelectStatement, tables: readonly HsqldbTable[]): SqlResultSet;
+declare function evaluateSelectInScope(statement: SqlSelectStatement, tables: readonly HsqldbTable[], outer: OuterScope | undefined): SqlResultSet;
 declare function assertNeverOperator(value: never): never;
 declare function assertNeverLiteralKind(value: never): never;
 declare function assertNeverPredicateKind(value: never): never;
 declare function assertNeverValueKind(value: never): never;
 //#endregion
-export { assertNeverValueKind as a, assertNeverPredicateKind as i, assertNeverLiteralKind as n, evaluateSelect as o, assertNeverOperator as r, SqlResultSet as t };
+export { assertNeverValueKind as a, assertNeverPredicateKind as i, assertNeverLiteralKind as n, evaluateSelect as o, assertNeverOperator as r, evaluateSelectInScope as s, SqlResultSet as t };