js.documents 14.4.56 → 14.4.57

package/dist/evaluate-IK-3aMv5.js

@@ -0,0 +1,445 @@
+import { CELL_NULL, aggregateCellValues, cellComparisonKey, compareCellValues } from "./odb/values.js";
+import { HsqldbSqlEvaluationError } from "./odb/sql/errors.js";
+import { ColumnResolver, columnAt, resolveColumnIndex, resolveTable, valueAtIndex } from "./odb/sql/evaluate-columns.js";
+//#region src/odb/sql/evaluate-predicates.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 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";
+}
+//#endregion
+//#region src/odb/sql/evaluate.ts
+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 { operandValue as _, evaluateSelect as a, truthOfComparison as b, compareValues as c, evaluateInSubquery as d, evaluateLike as f, notTruth as g, literalToValue as h, assertNeverValueKind as i, evaluateExists as l, likePatternToRegExp as m, assertNeverOperator as n, evaluateSelectInScope as o, evaluatePredicate as p, assertNeverPredicateKind as r, andTruth as s, assertNeverLiteralKind as t, evaluateIn as u, orTruth as v, sqlFailure as y };

package/dist/evaluate-columns-CyqKHkIW.d.cts

@@ -0,0 +1,41 @@
+import { r as HsqldbTable } from "./script-pkZ2Kor4.cjs";
+import { r as SqlColumnRef, u as SqlNameRef } from "./parser-BTA1wXPd.cjs";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/sql/evaluate-columns.d.ts
+declare function tryResolveName(candidates: readonly string[], ref: SqlNameRef, what: string, sql: string): string | undefined;
+declare function resolveName(candidates: readonly string[], ref: SqlNameRef, what: string, sql: string): string;
+declare function resolveTable(tables: readonly HsqldbTable[], ref: SqlNameRef, sql: string): HsqldbTable;
+interface ResolvedColumn {
+  readonly qualifiers: readonly string[];
+  readonly columnName: string;
+}
+interface SharedColumnPair {
+  readonly leftIndex: number;
+  readonly rightIndex: number;
+  readonly columnName: string;
+}
+declare function columnAt(columns: readonly ResolvedColumn[], index: number, sql: string): ResolvedColumn;
+declare function valueAtIndex(row: readonly ContentCellValue[], index: number, sql: string): ContentCellValue;
+declare function tryResolveColumnIndex(columns: readonly ResolvedColumn[], candidateIndices: readonly number[], ref: SqlNameRef, sql: string): number | undefined;
+declare function resolveColumnIndex(columns: readonly ResolvedColumn[], candidateIndices: readonly number[], ref: SqlNameRef, sql: string): number;
+interface OuterScope {
+  readonly resolver: ColumnResolver;
+  readonly row: readonly ContentCellValue[];
+}
+declare class ColumnResolver {
+  private readonly sql;
+  private readonly outer?;
+  private readonly cache;
+  private readonly columns;
+  private readonly qualifierNames;
+  constructor(columns: readonly ResolvedColumn[], sql: string, outer?: OuterScope | undefined);
+  get columnCount(): number;
+  nameAt(index: number): string;
+  indexOf(ref: SqlColumnRef): number;
+  private tryLocalIndexOf;
+  private candidateIndicesFor;
+  valueAt(index: number, row: readonly ContentCellValue[]): ContentCellValue;
+  valueOf(ref: SqlColumnRef, row: readonly ContentCellValue[]): ContentCellValue;
+}
+//#endregion
+export { columnAt as a, resolveTable as c, valueAtIndex as d, SharedColumnPair as i, tryResolveColumnIndex as l, OuterScope as n, resolveColumnIndex as o, ResolvedColumn as r, resolveName as s, ColumnResolver as t, tryResolveName as u };

package/dist/evaluate-columns-cOo8fOfT.d.ts

@@ -0,0 +1,41 @@
+import { r as HsqldbTable } from "./script-pkZ2Kor4.js";
+import { r as SqlColumnRef, u as SqlNameRef } from "./parser-CoIi0l9I.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/sql/evaluate-columns.d.ts
+declare function tryResolveName(candidates: readonly string[], ref: SqlNameRef, what: string, sql: string): string | undefined;
+declare function resolveName(candidates: readonly string[], ref: SqlNameRef, what: string, sql: string): string;
+declare function resolveTable(tables: readonly HsqldbTable[], ref: SqlNameRef, sql: string): HsqldbTable;
+interface ResolvedColumn {
+  readonly qualifiers: readonly string[];
+  readonly columnName: string;
+}
+interface SharedColumnPair {
+  readonly leftIndex: number;
+  readonly rightIndex: number;
+  readonly columnName: string;
+}
+declare function columnAt(columns: readonly ResolvedColumn[], index: number, sql: string): ResolvedColumn;
+declare function valueAtIndex(row: readonly ContentCellValue[], index: number, sql: string): ContentCellValue;
+declare function tryResolveColumnIndex(columns: readonly ResolvedColumn[], candidateIndices: readonly number[], ref: SqlNameRef, sql: string): number | undefined;
+declare function resolveColumnIndex(columns: readonly ResolvedColumn[], candidateIndices: readonly number[], ref: SqlNameRef, sql: string): number;
+interface OuterScope {
+  readonly resolver: ColumnResolver;
+  readonly row: readonly ContentCellValue[];
+}
+declare class ColumnResolver {
+  private readonly sql;
+  private readonly outer?;
+  private readonly cache;
+  private readonly columns;
+  private readonly qualifierNames;
+  constructor(columns: readonly ResolvedColumn[], sql: string, outer?: OuterScope | undefined);
+  get columnCount(): number;
+  nameAt(index: number): string;
+  indexOf(ref: SqlColumnRef): number;
+  private tryLocalIndexOf;
+  private candidateIndicesFor;
+  valueAt(index: number, row: readonly ContentCellValue[]): ContentCellValue;
+  valueOf(ref: SqlColumnRef, row: readonly ContentCellValue[]): ContentCellValue;
+}
+//#endregion
+export { columnAt as a, resolveTable as c, valueAtIndex as d, SharedColumnPair as i, tryResolveColumnIndex as l, OuterScope as n, resolveColumnIndex as o, ResolvedColumn as r, resolveName as s, ColumnResolver as t, tryResolveName as u };