js.documents 14.4.56 → 14.4.57

package/dist/odb/sql/evaluate.js

@@ -1,552 +1,2 @@
-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";
-	}
-	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 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 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);
-	}
-};
-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, 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 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 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";
-}
-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}`;
-		}
-		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 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 tableColumns(qualifier, table) {
-	return table.columns.map((column) => ({
-		qualifiers: [qualifier],
-		columnName: column.name
-	}));
-}
-function nullRow(count) {
-	return new Array(count).fill(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 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 = valueAtIndex(combined, pair.leftIndex, sql);
-		const right = 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 = columnAt(rawColumns, pair.leftIndex, sql);
-			const rightColumn = columnAt(rawColumns, leftColumnCount + pair.rightIndex, sql);
-			return {
-				qualifiers: [.../* @__PURE__ */ new Set([...leftColumn.qualifiers, ...rightColumn.qualifiers])],
-				columnName: leftColumn.columnName
-			};
-		}), ...remainingIndices.map((index) => columnAt(rawColumns, index, sql))],
-		rows: rows.map((row) => {
-			const mergedValues = sharedPairs.map((pair) => {
-				const leftValue = valueAtIndex(row, pair.leftIndex, sql);
-				const rightValue = valueAtIndex(row, leftColumnCount + pair.rightIndex, sql);
-				return leftValue.kind !== "empty" ? leftValue : rightValue;
-			});
-			const remainingValues = remainingIndices.map((index) => valueAtIndex(row, index, sql));
-			return [...mergedValues, ...remainingValues];
-		})
-	};
-}
-function applyJoinClause(left, join, tables, sql, outer) {
-	const rightTable = 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 = resolveColumnIndex(left.columns, allLeftIndices, ref, sql);
-			return {
-				leftIndex,
-				rightIndex: resolveColumnIndex(rightColumns, allRightIndices, ref, sql),
-				columnName: columnAt(left.columns, leftIndex, sql).columnName
-			};
-		});
-	} else if (join.condition.kind === "natural") {
-		sharedPairs = computeNaturalSharedPairs(left.columns, rightColumns, sql);
-		if (sharedPairs.length === 0) throw new HsqldbSqlEvaluationError("NATURAL JOIN found no columns shared between the joined tables", sql);
-	}
-	const rawResolver = new 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 = 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 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 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
-export { assertNeverLiteralKind, assertNeverOperator, assertNeverPredicateKind, assertNeverValueKind, evaluateSelect };
+import { a as evaluateSelect, i as assertNeverValueKind, n as assertNeverOperator, o as evaluateSelectInScope, r as assertNeverPredicateKind, t as assertNeverLiteralKind } from "../../evaluate-IK-3aMv5.js";
+export { assertNeverLiteralKind, assertNeverOperator, assertNeverPredicateKind, assertNeverValueKind, evaluateSelect, evaluateSelectInScope };