kern-orm 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -1,3092 +1,10 @@
-import { B as trueNode, C as toNode, D as isType, E as defineType, F as createNode, I as createSelectNode, L as falseNode, M as valuesQueryNode, N as defineGenericOperator, O as Column, P as createList, R as noFilters, S as toFunctionOperandNode, T as getBooleanType, _ as isOperandSource, a as stringifyJson, b as toCastValueNode, c as textOperators, d as orderingOperators, f as compare, g as isExpression, h as getType, j as isEqualityCompatible, k as equalityOperators, m as createIsNullNode, n as text, p as compareNodes, s as encodeBytea, v as operandNode, w as toValueNode, x as toExpression, y as toBooleanExpression, z as oneNode } from "./text-BTFErHIi.mjs";
-import { AsyncLocalStorage } from "node:async_hooks";
-// src/ast/boolean.ts
-/** Combines predicate nodes with `AND` or `OR`, flattening nested groups of the same kind. */
-function combineNodes(kind, operands) {
-	const neutral = kind === "and";
-	const flat = [];
-	for (const operand of operands) if (operand.kind === "boolean") {
-		if (operand.value !== neutral) return operand;
-	} else if (operand.kind === kind) flat.push(...operand.operands);
-	else flat.push(operand);
-	if (flat.length === 0) return neutral ? trueNode : falseNode;
-	return flat.length === 1 ? flat[0] : createNode({
-		kind,
-		operands: flat
-	});
-}
-/** Negates a predicate node, simplifying constants and double negation. */
-function negateNode(operand) {
-	if (operand.kind === "boolean") return operand.value ? falseNode : trueNode;
-	if (operand.kind === "not") return operand.operand;
-	return createNode({
-		kind: "not",
-		operand
-	});
-}
-/** Combines the filters of a query into its effective predicate, `relation AND scope AND user`, which is `TRUE` when they restrict no row. */
-function combineFilters(filters) {
-	const operands = [];
-	if (filters.relation !== void 0) operands.push(filters.relation);
-	if (filters.scope !== void 0) operands.push(filters.scope);
-	if (filters.user !== void 0) operands.push(filters.user);
-	return combineNodes("and", operands);
-}
-// src/expression/predicates.ts
-/** Converts a condition operand into a node: a query nests in it, and an object of column values stays unresolved until `where`; it rejects any other value. */
-function toConditionNode(operand) {
-	if (isOperandSource(operand)) return operand[operandNode]();
-	if (!isColumnValues(operand)) throw new TypeError("A condition must be an expression, such as TRUE or FALSE, a query of one Boolean value, or an object of column values");
-	return createNode({
-		kind: "values",
-		values: operand
-	});
-}
-/** Tells whether `value` can be an object of column values: a plain object, of this or another realm, or an object that has keys. */
-function isColumnValues(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || Object.getPrototypeOf(prototype) === null || Object.keys(value).length > 0;
-}
-function and(...operands) {
-	return combineConditions("and", operands);
-}
-function or(...operands) {
-	return combineConditions("or", operands);
-}
-function not(operand) {
-	return toBooleanExpression(negateNode(toConditionNode(operand)));
-}
-function combineConditions(kind, operands) {
-	const nodes = [];
-	for (const operand of operands) nodes.push(toConditionNode(operand));
-	return toBooleanExpression(combineNodes(kind, nodes));
-}
+import { B as trueNode, C as toNode, D as isType, E as defineType, F as createNode, L as falseNode, N as defineGenericOperator, P as createList, S as toFunctionOperandNode, T as getBooleanType, _ as isOperandSource, b as toCastValueNode, c as textOperators, d as orderingOperators, f as compare, g as isExpression, h as getType, k as equalityOperators, v as operandNode, x as toExpression, y as toBooleanExpression } from "./text-BTFErHIi.mjs";
+import { C as not, S as isColumnValues, T as combineNodes, _ as NotFoundError, a as defineSchema, b as literal, c as requireDerived, d as orderBy, f as many, g as defineTable, h as matchColumn, i as sql, l as asc, m as createStatement, n as identifier, o as SelectQuery, p as one, r as param, s as from, t as createDatabase, u as desc, v as RequiredRelationError, w as or, x as and, y as ResultDecodeError } from "./database-BJ0hNYrF.mjs";
 // src/expression/constants.ts
 /** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
 const TRUE = /* @__PURE__ */ toExpression(trueNode, /* @__PURE__ */ getBooleanType());
 /** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
 const FALSE = /* @__PURE__ */ toExpression(falseNode, /* @__PURE__ */ getBooleanType());
-// src/query/literal.ts
-/**
-* Field of a selection whose value is `T`, made by `literal`.
-*
-* It is not an expression: it has no SQL, so only a selection takes it.
-*/
-var Literal = class {
-	literal;
-	constructor(literal) {
-		this.literal = literal;
-		Object.freeze(this);
-	}
-	/** Rejects the literal as an operand of an expression: a statement has no SQL of it. */
-	[operandNode]() {
-		throw new TypeError("A literal is only a selected field and has no SQL; pass a value to an expression through param");
-	}
-};
-/**
-* Creates a field of a selection with `value` in every record, without selecting anything in SQL: the query returns the value itself, not a copy of it, whatever it is.
-*
-* It lets a branch of a selection skip a column or a nested query, such as `withHint ? field.hint : literal(null)`.
-* To use a value in SQL, such as in a condition, pass it through `param` instead.
-*/
-function literal(value) {
-	return new Literal(value);
-}
-// src/query/exists.ts
-let existsProjection;
-/** Returns the projection of whether a query has a row, the only projection of a query made by `exists`. */
-function getExistsProjection() {
-	existsProjection ??= Object.freeze({
-		key: "exists",
-		expression: trueNode,
-		type: getBooleanType()
-	});
-	return existsProjection;
-}
-/** Tells whether `node` is a query of `exists`, whose value is whether the rows that its filters, limit, and offset choose exist. */
-function isExistsQuery(node) {
-	return node.value && isExistsProjection(node.projections[0]);
-}
-/** Tells whether a selected field is the projection of `exists`, which only `exists` selects. */
-function isExistsProjection(field) {
-	return field === existsProjection;
-}
-// src/query/aggregate.ts
-/** Type of a count: a `bigint` of PostgreSQL decoded as a number, rejecting a count that a number cannot hold exactly. */
-const countType = /* @__PURE__ */ defineType({ sqlType: "bigint" }).transform({
-	decode: (text) => decodeSafeInteger(text, "Count"),
-	encode: (value) => String(value)
-}).withOperators(orderingOperators);
-/** Types of the sums of the values of `smallint` and `integer` types, by the type of the values, created once for each. */
-const sumTypes = /* @__PURE__ */ new WeakMap();
-const noFallbacks = /* @__PURE__ */ Object.freeze([]);
-/** Definitions of the aggregate methods that take a column or an expression. */
-const aggregateDefinitions = /* @__PURE__ */ Object.freeze({
-	count: {
-		name: "count",
-		distinct: false,
-		ordered: false,
-		type: toCountType
-	},
-	countDistinct: {
-		name: "count",
-		distinct: true,
-		ordered: false,
-		type: toCountType
-	},
-	min: {
-		name: "min",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	max: {
-		name: "max",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	sum: {
-		name: "sum",
-		distinct: false,
-		ordered: false,
-		type: toSumType
-	},
-	avg: {
-		name: "avg",
-		distinct: false,
-		ordered: false,
-		type: toAverageType
-	},
-	every: {
-		name: "bool_and",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	some: {
-		name: "bool_or",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	stringAgg: {
-		name: "string_agg",
-		distinct: false,
-		ordered: true,
-		type: toArgumentType
-	}
-});
-/** Projection of `count(*)`, which `count` without an argument selects; its value does not depend on the values or the order of the rows. */
-const countProjection = /* @__PURE__ */ Object.freeze({
-	key: "count",
-	expression: /* @__PURE__ */ createNode({
-		kind: "aggregate",
-		name: "count",
-		distinct: false,
-		arguments: [/* @__PURE__ */ createNode({
-			kind: "raw",
-			fragments: ["*"],
-			values: []
-		})],
-		orderBy: []
-	}),
-	type: countType,
-	ordered: false,
-	fallbacks: noFallbacks
-});
-/**
-* Creates the projection of the aggregate of `method` over the values of `argument`, the projection of a column or an expression of each row.
-*
-* `delimiter` is the delimiter of `stringAgg`, sent as a parameter.
-*/
-function projectAggregate(method, argument, delimiter) {
-	const definition = aggregateDefinitions[method];
-	const args = [argument.expression];
-	if (delimiter !== void 0) args.push(createNode({
-		kind: "param",
-		value: delimiter,
-		type: void 0
-	}));
-	return Object.freeze({
-		key: method,
-		expression: createNode({
-			kind: "aggregate",
-			name: definition.name,
-			distinct: definition.distinct,
-			arguments: args,
-			orderBy: []
-		}),
-		type: definition.type(argument.type),
-		ordered: definition.ordered,
-		fallbacks: noFallbacks
-	});
-}
-/** Creates the projection of the aggregate of `field` whose `NULL` `fallback` replaces after its earlier fallbacks. */
-function addFallback(field, fallback) {
-	const fallbacks = field.fallbacks.slice();
-	fallbacks.push(fallback);
-	return Object.freeze({
-		key: field.key,
-		expression: field.expression,
-		type: field.type,
-		ordered: field.ordered,
-		fallbacks
-	});
-}
-/** Tells whether `node` is an aggregate query, whose value is the aggregate over the rows that its filters, limit, and offset choose. */
-function isAggregateQuery(node) {
-	return node.value && isAggregateProjection(node.projections[0]);
-}
-/** Tells whether `node`, a nested query, is selected as its value rather than as packed rows: an aggregate query as a scalar subquery of its statement, and a query of `exists` as `EXISTS` of its rows. */
-function isSelectedAsValue(node) {
-	return isAggregateQuery(node) || isExistsQuery(node);
-}
-/** Tells whether a selected field is the projection of an aggregate, which only the aggregate methods select. */
-function isAggregateProjection(field) {
-	return "ordered" in field;
-}
-function toCountType() {
-	return countType;
-}
-function toArgumentType(argument) {
-	return argument;
-}
-/** Returns the type of the sum of the values of type `argument`: for `smallint` and `integer` values, a `bigint` with the operators of `argument` that rejects a sum that a number cannot hold exactly, and `argument` for others. */
-function toSumType(argument) {
-	if (argument.castType !== "smallint" && argument.castType !== "integer") return argument;
-	let type = sumTypes.get(argument);
-	if (type === void 0) {
-		type = defineType({ sqlType: "bigint" }).transform({
-			decode: (text) => {
-				decodeSafeInteger(text, "Sum");
-				return argument.decode(text);
-			},
-			encode: (value) => argument.encode(value)
-		}).withOperators(argument.operators);
-		sumTypes.set(argument, type);
-	}
-	return type;
-}
-/** Returns the type of the average of the values of type `argument`, which decodes a fractional value where PostgreSQL gives one, such as `Number` of `integer`; rejects a type of the SQL type `bigint`. */
-function toAverageType(argument) {
-	if (argument.castType === "bigint") throw new TypeError("avg of bigint values requires a type that can represent fractional values; average a sql fragment of the column with t.doublePrecision or t.numeric");
-	return argument;
-}
-/** Decodes `text` of a `bigint` as a number, rejecting one that a number cannot hold exactly; `subject` names it in the error. */
-function decodeSafeInteger(text, subject) {
-	const number = Number(text);
-	if (!Number.isSafeInteger(number)) throw new RangeError(`${subject} ${text} is outside the safe integer range of numbers`);
-	return number;
-}
-// src/query/column-refs.ts
-/** Context of a query whose table has no relations, such as one of `from(table)`. */
-const noContext = /* @__PURE__ */ Object.freeze({ relations: /* @__PURE__ */ Object.freeze({}) });
-/** Creates expressions of the columns of `source`, each with the type of its column. */
-function createColumnRefs(source) {
-	return addColumns({}, source);
-}
-/** Creates the references of the callbacks of `select`, `where`, and `orderBy` over `source`: its columns, and the relations of `context`. */
-function createSelectionRefs(source, context) {
-	return Object.defineProperties(addColumns({}, source), context.relations);
-}
-function addColumns(refs, source) {
-	const { columns } = source.table;
-	for (const key of Object.keys(columns)) refs[key] = toExpression(createNode({
-		kind: "column",
-		source,
-		key
-	}), columns[key].type);
-	return refs;
-}
-// src/result/result.ts
-/** Error thrown when a query of one row finds no row, executed or nested, unless a required relation guarantees the row. */
-var NotFoundError = class extends Error {
-	name = "NotFoundError";
-	/** Path of the missing nested rows from the result field that holds them, such as `user` or `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`; `undefined` when the executed query itself finds no row. */
-	path;
-	constructor(message, path) {
-		super(message);
-		this.path = path;
-	}
-};
-/**
-* Error thrown when a required relation, such as `field.form`, has no record for a row.
-*
-* A required relation promises the record, so its absence means that the database breaks the promise, such as without a foreign key, or that the relation should not be required.
-*/
-var RequiredRelationError = class extends Error {
-	relation;
-	path;
-	name = "RequiredRelationError";
-	constructor(relation, path) {
-		super(`Required relation "${relation}" has no record for result field "${path}"`);
-		this.relation = relation;
-		this.path = path;
-	}
-};
-/** Error thrown when a row does not match the result fields or a value fails to decode; the failure of the value is its cause. */
-var ResultDecodeError = class extends Error {
-	path;
-	name = "ResultDecodeError";
-	constructor(message, path, options) {
-		super(message, options);
-		this.path = path;
-	}
-};
-/** Tells whether `key` can be a key of a decoded record, such as a column key: assigning `__proto__` would change the prototype of the record instead. */
-function isRecordKey(key) {
-	return key !== "__proto__";
-}
-/**
-* Decodes the result of a statement by its plan: its rows, as `decodeResult` does, or the number of the rows of its command tag, such as of the rows that a mutation changes.
-*
-* A statement of one row that returns its number or a record without fields rejects as a query of one row does: with `NotFoundError` without a row, unless it is optional or nullable, and with several rows.
-*/
-function decodeStatement(plan, result) {
-	const { counted } = plan;
-	if (counted === void 0) return decodeResult(plan, plan.named ? selectColumns(plan, result) : result.rows);
-	const { count } = result;
-	if (plan.rows !== "many") {
-		if (count > 1) throw new Error(plan.named ? `Query of one row reported ${count} rows` : `Query of one row changed ${count} rows`);
-		if (count === 0) {
-			if (plan.rows === "one") throw new NotFoundError(plan.named ? "Query reported no rows" : "Query found no row to change");
-			if (counted === "records") return decodeMissing(plan);
-		}
-	}
-	if (counted === "number") return count;
-	if (plan.rows !== "many") return createRecord(plan);
-	const records = [];
-	for (let index = 0; index < count; index++) records.push(createRecord(plan));
-	return records;
-}
-/**
-* Returns the rows of `result` with the values of the fields of `plan` in their order, read from the result columns of their keys: a value from the only column.
-*
-* It rejects a missing column or one that the result has twice, and other columns than one for a value; it ignores the other columns of records.
-*/
-function selectColumns(plan, result) {
-	const { columns, rows } = result;
-	if (plan.value) {
-		if (columns.length !== 1) throw new ResultDecodeError(`Statement returned ${columns.length} columns for one value`, void 0);
-		return rows;
-	}
-	const { fields } = plan;
-	const indexes = [];
-	let ordered = fields.length === columns.length;
-	for (let index = 0; index < fields.length; index++) {
-		const { key } = fields[index];
-		const column = columns.indexOf(key);
-		if (column === -1) throw new ResultDecodeError(`Statement returned no column "${key}"`, void 0);
-		if (columns.indexOf(key, column + 1) !== -1) throw new ResultDecodeError(`Statement returned column "${key}" more than once`, void 0);
-		indexes.push(column);
-		ordered &&= column === index;
-	}
-	if (ordered) return rows;
-	const selected = [];
-	for (let row = 0; row < rows.length; row++) {
-		const values = [];
-		for (let index = 0; index < indexes.length; index++) values.push(rows[row][indexes[index]]);
-		selected.push(values);
-	}
-	return selected;
-}
-/**
-* Decodes driver rows into the result of a query by its result plan.
-*
-* It rejects a row whose values do not match the result fields, and names the path of the value that fails to decode from its result field, such as `fields[2].label`, after the index of the row of rows `many`, such as `[2].fields[2].label`.
-*/
-function decodeResult(plan, rows) {
-	if (plan.rows === "many") {
-		const results = [];
-		let index = 0;
-		try {
-			for (; index < rows.length; index++) results.push(decodeRow(plan, rows[index], false));
-		} catch (error) {
-			throw createRowError(`[${index}].`, error);
-		}
-		return results;
-	}
-	if (rows.length > 1) throw new Error(`Query of one row returned ${rows.length} rows`);
-	const row = rows[0];
-	if (row === void 0) {
-		if (plan.rows === "one") throw new NotFoundError("Query returned no rows");
-		return decodeMissing(plan);
-	}
-	try {
-		return decodeRow(plan, row, false);
-	} catch (error) {
-		throw createRowError("", error);
-	}
-}
-/** Returns the result of a query of rows `nullable` or `optional` without a row: `null` or `undefined`. */
-function decodeMissing(plan) {
-	return plan.rows === "nullable" ? null : void 0;
-}
-/** Missing row of nested rows `one`, which the query turns into its error once the path is known. */
-var MissingRow = class extends Error {
-	guaranteedBy;
-	constructor(guaranteedBy) {
-		super();
-		this.guaranteedBy = guaranteedBy;
-	}
-};
-/**
-* Failure inside a row, with the path to it, such as `[2].label` from the field of nested rows or `fields[2].label` from a row of the driver: a missing row or a value that fails to decode.
-*
-* Every enclosing level adds its own part of the path, and the query turns it into its error.
-*/
-var NestedFailure = class extends Error {
-	path;
-	cause;
-	constructor(path, cause) {
-		super();
-		this.path = path;
-		this.cause = cause;
-	}
-};
-/** Adds `segment` before the path of a failure inside a row. */
-function prefixPath(segment, error) {
-	return error instanceof NestedFailure ? new NestedFailure(segment + error.path, error.cause) : new NestedFailure(segment, error);
-}
-/**
-* Creates the error of a query from the failure of a row of the driver, adding `prefix`, such as the index of the row, before its path: `NotFoundError` or `RequiredRelationError` for a missing row of nested rows, and `ResultDecodeError` for a value that fails to decode.
-*
-* A missing row keeps its class wherever it is nested, so it is never reported as a decoding failure.
-* A row of another width than the result fields is already the error of the query.
-*/
-function createRowError(prefix, error) {
-	if (!(error instanceof NestedFailure)) return error;
-	const path = prefix + error.path;
-	const { cause } = error;
-	if (cause instanceof MissingRow) return cause.guaranteedBy === void 0 ? new NotFoundError(`Nested query of result field "${path}" returned no rows`, path) : new RequiredRelationError(cause.guaranteedBy, path);
-	return new ResultDecodeError(`Cannot decode result field "${path}"${cause instanceof Error ? `: ${cause.message}` : ""}`, path, { cause });
-}
-/**
-* Decodes a row into a record keyed by the result fields, or into the value of its only field.
-*
-* A row of the driver holds text and `null`; a packed row of nested rows holds parsed JSON.
-*/
-function decodeRow(plan, row, packed) {
-	const { fields } = plan;
-	if (row.length !== fields.length) {
-		if (packed) throw new Error(`Nested row of ${row.length} values for ${fields.length} result fields`);
-		throw new ResultDecodeError(`Driver returned a row of ${row.length} values for ${fields.length} result fields`, void 0);
-	}
-	let index = 0;
-	try {
-		if (plan.value) return packed ? decodePackedValue(fields[0], row[0]) : decodeDriverValue(fields[0], row[0]);
-		const record = createRecord(plan);
-		for (; index < fields.length; index++) {
-			const field = fields[index];
-			record[field.key] = packed ? decodePackedValue(field, row[index]) : decodeDriverValue(field, row[index]);
-		}
-		return record;
-	} catch (error) {
-		const { key } = fields[index];
-		throw prefixPath(packed ? `.${key}` : key, error);
-	}
-}
-/** Creates a record of `plan` before the values of a row are assigned: empty, or with the fields of its template. */
-function createRecord(plan) {
-	const record = {};
-	const { recordTemplate } = plan;
-	if (recordTemplate !== void 0) for (let index = 0; index < recordTemplate.length; index++) {
-		const { key, value } = recordTemplate[index];
-		record[key] = value;
-	}
-	return record;
-}
-/** Decodes the value of a field in a row of the driver: a scalar from its text, keeping `NULL` as `null`, or nested rows from JSON text. */
-function decodeDriverValue(field, value) {
-	if (value === void 0) throw new Error("Driver returned no value");
-	if (field.nested !== void 0) return decodeNested(field.nested, value === null ? null : JSON.parse(value));
-	return value === null ? null : field.type.decode(value);
-}
-/** Decodes the value of a field in a packed row: a scalar from its text, keeping JSON `null` as `null`, or nested rows from parsed JSON. */
-function decodePackedValue(field, value) {
-	if (field.nested !== void 0) return decodeNested(field.nested, value);
-	if (value === null) return null;
-	if (typeof value !== "string") throw new TypeError(`Nested value must be text, not ${describeJson(value)}`);
-	return field.type.decode(value);
-}
-/** Decodes the rows of a nested query from JSON: an array of packed rows for rows `many`, and a packed row or `null` otherwise. */
-function decodeNested(plan, json) {
-	if (plan.rows === "many") {
-		if (!Array.isArray(json)) throw new TypeError(`Nested rows must be an array, not ${describeJson(json)}`);
-		const results = [];
-		let index = 0;
-		try {
-			for (; index < json.length; index++) results.push(decodePackedRow(plan, json[index]));
-		} catch (error) {
-			throw prefixPath(`[${index}]`, error);
-		}
-		return results;
-	}
-	if (json === null) {
-		if (plan.rows === "one") throw new MissingRow(plan.guaranteedBy);
-		return decodeMissing(plan);
-	}
-	return decodePackedRow(plan, json);
-}
-/** Decodes a packed row, which must be an array. */
-function decodePackedRow(plan, json) {
-	if (!Array.isArray(json)) throw new TypeError(`Nested row must be an array, not ${describeJson(json)}`);
-	return decodeRow(plan, json, true);
-}
-/** Describes the kind of a parsed JSON value for an error message. */
-function describeJson(value) {
-	if (value === null) return "null";
-	if (typeof value === "object") return Array.isArray(value) ? "an array" : "an object";
-	return `a ${typeof value}`;
-}
-// src/table/table.ts
-function defineTable(name, definitions, options) {
-	const columns = {};
-	for (const [key, definition] of Object.entries(definitions)) {
-		if (key.startsWith("$")) throw new Error(`Column key "${key}" of table "${name}" must not start with "$"`);
-		if (!isRecordKey(key)) throw new Error(`Column key "__proto__" of table "${name}" is not allowed; use columnName("__proto__")`);
-		const column = toColumn(definition);
-		if (!column) throw new TypeError(`Column "${key}" of table "${name}" must be a type or a column`);
-		columns[key] = column;
-	}
-	return Object.freeze({
-		kind: "table",
-		name,
-		columns: Object.freeze(columns),
-		keys: defineKeys(name, columns, options)
-	});
-}
-/**
-* Defines the keys of table `name` of `columns` from the keys marked on the columns and those of `options`.
-*
-* The unique keys are those of the columns in their order, followed by those of the options.
-* It rejects a primary key declared twice, a key of the options with fewer than two columns, an unknown column or a column listed twice in such a key, a nullable column of the primary key, and two keys of the same columns.
-*/
-function defineKeys(name, columns, options) {
-	let primaryKey;
-	const unique = [];
-	for (const key of Object.keys(columns)) {
-		const keyKind = columns[key].attributes.keyKind;
-		if (keyKind === "primaryKey") {
-			if (primaryKey !== void 0) throw new Error(`Table "${name}" marks columns "${primaryKey[0]}" and "${key}" with primaryKey(); list the columns of a primary key of several columns in the options`);
-			primaryKey = Object.freeze([key]);
-		} else if (keyKind === "unique") unique.push(Object.freeze([key]));
-	}
-	if (options?.primaryKey !== void 0) {
-		if (primaryKey !== void 0) throw new Error(`Table "${name}" declares its primary key both on column "${primaryKey[0]}" and in the options`);
-		primaryKey = toKeyColumns(name, columns, options.primaryKey);
-	}
-	if (options?.unique !== void 0) {
-		if (!Array.isArray(options.unique)) throw new TypeError(`Unique keys in the options of table "${name}" must be an array`);
-		for (const key of options.unique) unique.push(toKeyColumns(name, columns, key));
-	}
-	for (const key of primaryKey ?? []) if (columns[key].type.isNullable) throw new Error(`Primary key column "${key}" of table "${name}" must not be nullable`);
-	const keys = primaryKey === void 0 ? unique : [primaryKey, ...unique];
-	for (let index = 1; index < keys.length; index++) for (let other = 0; other < index; other++) if (hasSameColumns(keys[index], keys[other])) throw new Error(`Table "${name}" declares the key of columns ${keys[index].map((key) => `"${key}"`).join(", ")} twice`);
-	return Object.freeze({
-		primaryKey,
-		unique: Object.freeze(unique)
-	});
-}
-/** Returns the column keys of a key of several columns from the options of table `name`, frozen, rejecting what `defineKeys` rejects in such a key. */
-function toKeyColumns(name, columns, key) {
-	if (!Array.isArray(key) || key.length < 2) throw new Error(`A key in the options of table "${name}" must list at least two columns; mark a key of one column with primaryKey() or unique()`);
-	for (let index = 0; index < key.length; index++) {
-		const column = key[index];
-		if (typeof column !== "string" || !Object.hasOwn(columns, column)) throw new Error(`A key in the options of table "${name}" lists unknown column "${column}"`);
-		if (key.indexOf(column) !== index) throw new Error(`A key in the options of table "${name}" lists column "${column}" twice`);
-	}
-	return Object.freeze(key.slice());
-}
-/** Tells whether keys `key` and `other` have the same columns, in any order; neither lists a column twice. */
-function hasSameColumns(key, other) {
-	return key.length === other.length && key.every((column) => other.includes(column));
-}
-/** Finds the column of `table` under `key`, ignoring properties inherited from the object prototype, such as `toString`. */
-function findColumn(table, key) {
-	return Object.hasOwn(table.columns, key) ? table.columns[key] : void 0;
-}
-/** Tells whether the columns of `table` under `columns` are exactly a key of it, primary or unique, in any order, as `IsKey` does in types. */
-function isKey(table, columns) {
-	const listed = new Set(columns);
-	return someKey(table, (key) => key.length === listed.size && isKeyAmong(key, listed));
-}
-/** Tells whether the columns of `table` under `columns` include a key of it, primary or unique, as `ContainsKey` does in types. */
-function containsKey(table, columns) {
-	const listed = new Set(columns);
-	return someKey(table, (key) => isKeyAmong(key, listed));
-}
-/** Tells whether `predicate` holds for a key of `table`, primary or unique. */
-function someKey(table, predicate) {
-	const { primaryKey, unique } = table.keys;
-	return primaryKey !== void 0 && predicate(primaryKey) || unique.some(predicate);
-}
-/** Tells whether every column of `key` is in `columns`. */
-function isKeyAmong(key, columns) {
-	return key.every((column) => columns.has(column));
-}
-/** Returns the column of `table` under `key` as `findColumn` finds it, rejecting a key that is not a column. */
-function requireColumn(table, key) {
-	const column = findColumn(table, key);
-	if (!column) throw new Error(`Unknown column "${key}" of table "${table.name}"`);
-	return column;
-}
-/** Creates a column from a column definition, or returns `undefined` for a value that is neither a type nor a column. */
-function toColumn(definition) {
-	if (definition instanceof Column) return definition;
-	return isType(definition) ? new Column(definition, {
-		name: void 0,
-		keyKind: void 0,
-		hasDefault: false
-	}) : void 0;
-}
-// src/query/resolve-values.ts
-/**
-* Replaces objects of column values in a predicate with conditions on the columns of `source`.
-*
-* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
-*/
-function resolveValues(node, source) {
-	switch (node.kind) {
-		case "values": {
-			const conditions = [];
-			for (const key of Object.keys(node.values)) {
-				const value = node.values[key];
-				const type = findColumn(source.table, key)?.type;
-				const column = createNode({
-					kind: "column",
-					source,
-					key
-				});
-				if (value === null) conditions.push(createIsNullNode(column));
-				else if (type) conditions.push(matchValue(source, column, type, value));
-				else conditions.push(compareNodes("=", column, value, void 0));
-			}
-			return combineNodes("and", conditions);
-		}
-		case "and":
-		case "or": {
-			const operands = [];
-			for (const operand of node.operands) operands.push(resolveValues(operand, source));
-			return combineNodes(node.kind, operands);
-		}
-		case "not": return negateNode(resolveValues(node.operand, source));
-		case "raw": return createNode({
-			...node,
-			values: node.values.map((value) => resolveValues(value, source))
-		});
-		default: return node;
-	}
-}
-/** Matches a column with a value of an object condition by calling the `eq` operator of its type, whichever operator it is. */
-function matchValue(source, column, type, value) {
-	const expression = toExpression(column, type);
-	if (typeof expression.eq !== "function") throw new TypeError(`Column "${column.key}" of table "${source.table.name}" has no eq operator; an object condition can only match it with null`);
-	const predicate = expression.eq(value);
-	if (!isExpression(predicate)) throw new TypeError(`The eq operator of column "${column.key}" of table "${source.table.name}" must return an expression`);
-	return toNode(predicate);
-}
-// src/query/filters.ts
-/** Creates query filters with the filter of `where` over `source` with the relations of `context` combined with `AND` with the user filters of `filters`. */
-function addUserFilter(filters, filter, source, context) {
-	const predicate = resolveValues(toConditionNode(typeof filter === "function" ? filter(createSelectionRefs(source, context)) : filter), source);
-	const { user } = filters;
-	return Object.freeze({
-		...filters,
-		user: user ? combineNodes("and", [user, predicate]) : predicate
-	});
-}
-function defineFilter(_table, filter) {
-	return filter;
-}
-// src/query/find.ts
-/**
-* Returns the object of column values that `find` filters a query of `table` by: `values` of the columns of its primary key, in their order.
-*
-* It rejects a table without a primary key, a number of values other than the number of its columns, and `null` and `undefined`.
-*/
-function toPrimaryKeyValues(table, values) {
-	const { primaryKey } = table.keys;
-	if (primaryKey === void 0) throw new Error(`find takes the values of a primary key, which table "${table.name}" does not have; use findBy with a unique key`);
-	if (values.length !== primaryKey.length) throw new Error(`find takes one value for each column of the primary key of table "${table.name}", ${quoteColumns(primaryKey)}, not ${values.length}`);
-	const filter = {};
-	for (let index = 0; index < primaryKey.length; index++) {
-		const column = primaryKey[index];
-		filter[column] = requireKeyValue(table, column, values[index], "find");
-	}
-	return filter;
-}
-/**
-* Returns the object of column values that `findBy` filters a query of `table` by: a copy of `values`, read once.
-*
-* It rejects columns that are not exactly a key of `table`, primary or unique, as `isKey` tells, and `null` and `undefined`.
-*/
-function toKeyValues(table, values) {
-	if (typeof values !== "object" || values === null) throw new TypeError(`findBy takes an object of the columns of a key of table "${table.name}"`);
-	const columns = Object.keys(values);
-	if (!isKey(table, columns)) {
-		const listed = columns.length === 0 ? "an object without columns" : `columns ${quoteColumns(columns)}`;
-		throw new Error(`findBy takes the columns of one key of table "${table.name}", primary or unique, not ${listed}`);
-	}
-	const filter = {};
-	for (const column of columns) {
-		const value = values[column];
-		filter[column] = requireKeyValue(table, column, value, "findBy");
-	}
-	return filter;
-}
-/** Returns `value` of column `column` of a key of `table` that `method` takes, rejecting `null` and `undefined`. */
-function requireKeyValue(table, column, value, method) {
-	if (value === null || value === void 0) throw new TypeError(`${method} got ${value} for column "${column}" of table "${table.name}"; a value of a key is never null or undefined`);
-	return value;
-}
-/** Lists `columns` in quotes, separated by commas. */
-function quoteColumns(columns) {
-	return columns.map((column) => `"${column}"`).join(", ");
-}
-// src/type/untyped.ts
-/** Encodes a parameter without a type, such as a value interpolated into `sql`, by its JavaScript type. */
-function encodeUntyped(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "bigint") return String(value);
-	if (typeof value === "boolean") return value ? "t" : "f";
-	if (value instanceof Date) return value.toISOString();
-	if (value instanceof Uint8Array) return encodeBytea(value);
-	if (Array.isArray(value)) throw new TypeError("Pass an array with param(type, value), so that its elements are encoded by type");
-	return stringifyJson(value);
-}
-// src/compiler/postgres/identifier.ts
-/** Most bytes a character other than ASCII takes in a server encoding, such as UTF-8 and EUC_TW ([PostgreSQL](https://www.postgresql.org/docs/current/multibyte.html)). */
-const maxCharacterBytes = 4;
-function quoteIdentifier(name) {
-	return `"${name.replaceAll("\"", "\"\"")}"`;
-}
-/**
-* Returns the longest prefix of `name` that takes at most `maxBytes` bytes in any server encoding.
-*
-* Every server encoding takes one byte for an ASCII character, and a character other than ASCII counts as the most bytes it can take.
-*/
-function cutIdentifier(name, maxBytes) {
-	if (name.length * maxCharacterBytes <= maxBytes) return name;
-	let bytes = 0;
-	for (let index = 0; index < name.length;) {
-		const code = name.codePointAt(index);
-		bytes += code < 128 ? 1 : maxCharacterBytes;
-		if (bytes > maxBytes) return name.slice(0, index);
-		index += code < 65536 ? 1 : 2;
-	}
-	return name;
-}
-/**
-* Returns the SQL name of the projection with `key` at `index` of its query.
-*
-* A key of up to 50 bytes is the name itself.
-* A longer key is named by its prefix of at most 54 bytes, which takes more than 50 since a character takes at most 4, and by its position, so the name differs from the names of the other projections.
-*/
-function nameProjection(key, index) {
-	if (cutIdentifier(key, 50).length === key.length) return key;
-	return `${cutIdentifier(key, 54)}_${index + 1}`;
-}
-// src/compiler/postgres/context.ts
-/** Most parameters that PostgreSQL takes in a statement. */
-const maxParameters = 65535;
-/** State of one compilation shared by all queries of the statement, never by reusable nodes: parameters and the aliases of all sources. */
-var CompileContext = class {
-	schemaName;
-	tables;
-	db;
-	parameters = [];
-	#aliases = /* @__PURE__ */ new Set();
-	constructor(schemaName, tables = void 0, db = void 0) {
-		this.schemaName = schemaName;
-		this.tables = tables;
-		this.db = db;
-	}
-	/**
-	* Creates an alias based on `name` that is unique in the statement, so that no source shadows another one in SQL.
-	*
-	* The name is cut to 50 bytes and numbered when the statement already has it, so an alias fits an identifier and PostgreSQL compares aliases as created rather than truncated.
-	*/
-	createAlias(name) {
-		const base = cutIdentifier(name.toWellFormed(), 50);
-		let alias = base;
-		for (let index = 2; this.#aliases.has(alias); index++) alias = `${base}_${index}`;
-		this.#aliases.add(alias);
-		return alias;
-	}
-	/** Adds a parameter of the statement and returns its placeholder, rejecting more parameters than PostgreSQL takes. */
-	bind(value) {
-		if (this.parameters.length === 65535) throw new Error(`Statement has more than ${maxParameters} parameters, which PostgreSQL does not take; split it into several statements, such as in a transaction`);
-		this.parameters.push(value);
-		return `$${this.parameters.length}`;
-	}
-};
-// src/compiler/postgres/parentheses.ts
-/** Tells whether an operand of `kind` needs parentheses at `position`, so that the SQL keeps the structure of the tree. */
-function needsParentheses(kind, position) {
-	switch (kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "values":
-		case "nestedQuery":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery":
-		case "aggregate": return false;
-		case "cast": return position === "interpolation";
-		case "raw": return position !== "interpolation";
-		case "and":
-		case "or": return true;
-		case "not":
-		case "comparison":
-		case "in":
-		case "inQuery":
-		case "isNull": return position !== "condition";
-		default: return kind;
-	}
-}
-// src/compiler/postgres/scope.ts
-/**
-* Declares a source of `FROM` on top of `outer` with a new alias.
-*
-* It rejects a source already visible there, such as a query nested in itself: a column reference could not tell its occurrences apart.
-*/
-function declareSource(context, outer, source) {
-	if (findSource(outer, source) !== void 0 || source.kind === "derived" && source.replaces !== void 0 && findSource(outer, source.replaces) !== void 0) throw new Error(`An occurrence of ${describeSource(source)} appears where it is already visible, so its column references would be ambiguous`);
-	const name = source.kind === "table" ? source.table.name : source.replaces?.table.name ?? "subquery";
-	return {
-		source,
-		alias: context.createAlias(name),
-		outer
-	};
-}
-/**
-* Returns the declared source that a column reference reads in `scope`: its source, or a derived source that replaces it; rejects a source that is not visible there.
-*/
-function resolveSource(scope, column) {
-	const declared = findSource(scope, column.source);
-	if (declared === void 0) throw new Error(`Column "${column.key}" of ${describeSource(column.source)} refers to a source that is not visible where it is used`);
-	return declared;
-}
-/** Returns the declared source of `scope` that is `source` or replaces it, or `undefined` when the source is not visible there. */
-function findSource(scope, source) {
-	for (let current = scope; current; current = current.outer) {
-		const declared = current.source;
-		if (declared === source || declared.kind === "derived" && declared.replaces === source) return current;
-	}
-}
-function describeSource(source) {
-	return source.kind === "table" ? `table "${source.table.name}"` : "a subquery";
-}
-// src/compiler/postgres/compile.ts
-const noFields = /* @__PURE__ */ Object.freeze([]);
-/**
-* Compiles a statement for PostgreSQL: a select statement, a mutation, or a statement of SQL text.
-*
-* With `tables`, such as the tables of the schema of a `Db`, an occurrence or an interpolated name of any other table at any depth of the statement is rejected.
-* `db` is the `Db` that runs the statement: a table interpolated from a query bound to another `Db`, or to any `Db` without it, is rejected.
-*/
-function compileStatement(node, options = {}, tables, db) {
-	const context = new CompileContext(options.schemaName, tables, db);
-	switch (node.kind) {
-		case "select": return {
-			text: compileQuery(context, void 0, node),
-			parameters: context.parameters,
-			fields: node.projections,
-			recordTemplate: node.recordTemplate,
-			rows: node.rows,
-			value: node.value,
-			counted: void 0,
-			named: false
-		};
-		case "text": {
-			const { fields } = node;
-			return {
-				text: compileExpression(context, void 0, node.sql),
-				parameters: context.parameters,
-				fields: fields ?? noFields,
-				rows: node.rows,
-				value: node.value,
-				counted: fields === void 0 ? "number" : void 0,
-				named: true
-			};
-		}
-		default: {
-			const { returning } = node;
-			return {
-				text: compileMutation(context, node),
-				parameters: context.parameters,
-				fields: returning ?? noFields,
-				recordTemplate: node.recordTemplate,
-				rows: node.rows,
-				value: node.value,
-				counted: returning === void 0 ? "number" : returning.length === 0 ? "records" : void 0,
-				named: false
-			};
-		}
-	}
-}
-/** Compiles a mutation, whose expressions see only the occurrence of its table, apart from the values of an insert, which see no source. */
-function compileMutation(context, node) {
-	const scope = declareSource(context, void 0, node.target);
-	const target = compileSource(context, void 0, scope);
-	let text;
-	switch (node.kind) {
-		case "insert":
-			text = `INSERT INTO ${target}${compileValues(context, node)}`;
-			break;
-		case "update": {
-			text = `UPDATE ${target} SET`;
-			const { set } = node;
-			for (let index = 0; index < set.length; index++) {
-				const { key, value } = set[index];
-				text += `${index === 0 ? " " : ", "}${compileColumnName(node.target, key)} = ${compileExpression(context, scope, value)}`;
-			}
-			text += compileWhere(context, scope, node.filters);
-			break;
-		}
-		case "delete":
-			text = `DELETE FROM ${target}${compileWhere(context, scope, node.filters)}`;
-			break;
-		default: return node;
-	}
-	const { returning } = node;
-	if (returning !== void 0 && returning.length > 0) text += ` RETURNING${compileProjections(context, scope, returning)}`;
-	return text;
-}
-/** Compiles the columns and the rows of `VALUES` of an insert, or `DEFAULT VALUES` for one row of the defaults of every column. */
-function compileValues(context, node) {
-	const { columns, values } = node;
-	if (columns.length === 0) {
-		if (values.length !== 1) throw new Error("An insert of several rows must list a column");
-		return " DEFAULT VALUES";
-	}
-	let text = " (";
-	for (let index = 0; index < columns.length; index++) text += `${index === 0 ? "" : ", "}${compileColumnName(node.target, columns[index])}`;
-	text += ") VALUES";
-	for (let row = 0; row < values.length; row++) {
-		const items = values[row];
-		text += row === 0 ? " (" : ", (";
-		for (let index = 0; index < items.length; index++) {
-			const item = items[index];
-			text += `${index === 0 ? "" : ", "}${item === void 0 ? "DEFAULT" : compileExpression(context, void 0, item)}`;
-		}
-		text += ")";
-	}
-	return text;
-}
-/** Compiles the physical name of the column of the table of `target` under `key`, as `SET` and the column list of an insert name it, without an alias. */
-function compileColumnName(target, key) {
-	return quoteIdentifier(requireColumn(target.table, key).attributes.name ?? key);
-}
-/** Compiles a query at a position of the statement where the sources of `outer` are visible. */
-function compileQuery(context, outer, node) {
-	const { from } = node;
-	if (from === void 0 && node.joins.length > 0) throw new Error("A query without FROM cannot join sources");
-	const fromScope = from === void 0 ? void 0 : declareSource(context, outer, from);
-	let scope = fromScope ?? outer;
-	const joinScopes = [];
-	for (const join of node.joins) {
-		scope = declareSource(context, scope, join.source);
-		joinScopes.push(scope);
-	}
-	let text = `SELECT${compileProjections(context, scope, node.projections)}`;
-	if (fromScope !== void 0) {
-		text += ` FROM ${compileSource(context, outer, fromScope)}`;
-		for (let index = 0; index < node.joins.length; index++) {
-			const joinScope = joinScopes[index];
-			text += ` LEFT JOIN ${compileSource(context, outer, joinScope)} ON ${compileExpression(context, joinScope, node.joins[index].on)}`;
-		}
-	}
-	text += compileWhere(context, scope, node.filters);
-	if (node.orderBy.length > 0) text += ` ${compileOrderBy(context, scope, node.orderBy)}`;
-	if (node.limit) text += ` LIMIT ${compileExpression(context, outer, node.limit)}`;
-	if (node.offset) text += ` OFFSET ${compileExpression(context, outer, node.offset)}`;
-	return text;
-}
-/** Compiles the projections of a select list or of `RETURNING`, each after a space or a comma. */
-function compileProjections(context, scope, projections) {
-	let text = "";
-	for (let index = 0; index < projections.length; index++) {
-		const projection = projections[index];
-		text += `${index === 0 ? " " : ", "}${compileExpression(context, scope, projection.expression)} AS ${quoteIdentifier(nameProjection(projection.key, index))}`;
-	}
-	return text;
-}
-/** Compiles the `WHERE` clause of the effective predicate of `filters` after a space, or nothing when they restrict no row. */
-function compileWhere(context, scope, filters) {
-	const where = combineFilters(filters);
-	return where.kind === "boolean" && where.value ? "" : ` WHERE ${compileExpression(context, scope, where)}`;
-}
-/** Compiles the `ORDER BY` clause of a query or an aggregate, which has at least one sort key. */
-function compileOrderBy(context, scope, orderBy) {
-	let text = "ORDER BY";
-	for (let index = 0; index < orderBy.length; index++) {
-		const order = orderBy[index];
-		text += `${index === 0 ? " " : ", "}${compileExpression(context, scope, order.expression)}`;
-		if (order.direction === "desc") text += " DESC";
-		if (order.nulls !== void 0) text += order.nulls === "first" ? " NULLS FIRST" : " NULLS LAST";
-	}
-	return text;
-}
-/** Compiles a declared source of a query at a position of the statement where the sources of `outer` are visible. */
-function compileSource(context, outer, declared) {
-	const { source, alias } = declared;
-	if (source.kind === "table") return `${compileTableName(context, source.table)} AS ${quoteIdentifier(alias)}`;
-	const query = compileQuery(context, source.lateral ? declared.outer : outer, source.query);
-	return `${source.lateral ? "LATERAL " : ""}(${query}) AS ${quoteIdentifier(alias)}`;
-}
-/** Compiles the name of `table`, qualified by the PostgreSQL schema of the statement, rejecting a table outside the tables of the statement. */
-function compileTableName(context, table) {
-	if (context.tables !== void 0 && !context.tables.has(table)) throw new Error(`Table "${table.name}" is not part of the schema`);
-	return context.schemaName === void 0 ? quoteIdentifier(table.name) : `${quoteIdentifier(context.schemaName)}.${quoteIdentifier(table.name)}`;
-}
-/** Compiles the name of a table interpolated into a SQL fragment, rejecting a table of a query bound to a `Db` other than the one that runs the statement. */
-function compileInterpolatedTable(context, node) {
-	const { db, table } = node;
-	if (db !== void 0 && db !== context.db) throw new Error(context.db === void 0 ? `Table "${table.name}" interpolated into SQL is bound to a Db, so only that Db can compile the query` : `Table "${table.name}" interpolated into SQL is bound to another Db`);
-	return compileTableName(context, table);
-}
-function compileColumn(scope, node) {
-	const { key } = node;
-	const declared = resolveSource(scope, node);
-	const { source } = declared;
-	let name;
-	if (source.kind === "table") name = requireColumn(source.table, key).attributes.name ?? key;
-	else {
-		const index = source.query.projections.findIndex((projection) => projection.key === key);
-		if (index === -1) throw new Error(`Unknown field "${key}" of a subquery`);
-		name = nameProjection(key, index);
-	}
-	return `${quoteIdentifier(declared.alias)}.${quoteIdentifier(name)}`;
-}
-function compileExpression(context, scope, node) {
-	switch (node.kind) {
-		case "column": return compileColumn(scope, node);
-		case "param": return context.bind(encodeParameter(node));
-		case "cast": return `${compileOperand(context, scope, node.operand, "value")}::${node.type.castType}`;
-		case "boolean": return node.value ? "TRUE" : "FALSE";
-		case "and":
-		case "or": return node.operands.map((operand) => compileOperand(context, scope, operand, "condition")).join(node.kind === "and" ? " AND " : " OR ");
-		case "not": return `NOT ${compileOperand(context, scope, node.operand, "condition")}`;
-		case "values": throw new Error("An object condition can only be used in `where`");
-		case "nestedQuery": throw new Error("A query in an expression must be lowered before compilation");
-		case "comparison": return `${compileOperand(context, scope, node.left, "value")} ${node.operator} ${compileOperand(context, scope, node.right, "value")}`;
-		case "in": {
-			let text = `${compileOperand(context, scope, node.operand, "value")} IN (${compileOperand(context, scope, node.list[0], "value")}`;
-			for (let index = 1; index < node.list.length; index++) text += `, ${compileOperand(context, scope, node.list[index], "value")}`;
-			return `${text})`;
-		}
-		case "inQuery": {
-			const { query } = node;
-			if (query.kind === "nestedQuery") throw new Error("A query in an expression must be lowered before compilation");
-			return `${compileOperand(context, scope, node.operand, "value")} IN ${compileSubquery(context, scope, query, "A subquery of IN")}`;
-		}
-		case "isNull": return `${compileOperand(context, scope, node.operand, "value")} IS NULL`;
-		case "raw": {
-			let text = node.fragments[0];
-			for (let index = 0; index < node.values.length; index++) text += compileOperand(context, scope, node.values[index], "interpolation") + node.fragments[index + 1];
-			return text;
-		}
-		case "tableName": return compileInterpolatedTable(context, node);
-		case "subquery": return compileSubquery(context, scope, node.query, "A scalar subquery");
-		case "exists": return `EXISTS (${compileQuery(context, scope, node.query)})`;
-		case "textSubquery": return `(${compileQuery(context, scope, node.query)})`;
-		case "aggregate": {
-			let text = `${node.name}(${node.distinct ? "DISTINCT " : ""}`;
-			for (let index = 0; index < node.arguments.length; index++) text += `${index === 0 ? "" : ", "}${compileExpression(context, scope, node.arguments[index])}`;
-			if (node.orderBy.length > 0) text += ` ${compileOrderBy(context, scope, node.orderBy)}`;
-			return `${text})`;
-		}
-		default: return node;
-	}
-}
-/** Compiles `query` in parentheses as a subquery of one field, and rejects a query of another number of fields, naming the subquery as `subject`. */
-function compileSubquery(context, scope, query, subject) {
-	const { length } = query.projections;
-	if (length !== 1) throw new Error(`${subject} must select one field, not ${length}`);
-	return `(${compileQuery(context, scope, query)})`;
-}
-/** Encodes the value of a parameter node with its type, or by its JavaScript type without one. */
-function encodeParameter(node) {
-	if (node.value === void 0) throw new TypeError("Query parameter is undefined; use null for NULL");
-	if (node.value === null) return null;
-	return node.type ? node.type.encode(node.value) : encodeUntyped(node.value);
-}
-/** Compiles an operand at `position` of its parent, parenthesizing it where its own operators could regroup with the parent. */
-function compileOperand(context, scope, node, position) {
-	const sql = compileExpression(context, scope, node);
-	return needsParentheses(node.kind, position) ? `(${sql})` : sql;
-}
-// src/execution/driver.ts
-/** Creates a statement from SQL text and the text representations of its parameters, such as `createStatement("BEGIN")`. */
-function createStatement(text, parameters = []) {
-	return {
-		text,
-		parameters
-	};
-}
-// src/ast/references.ts
-/** Adds to `keys` the key of each column reference to `source` in `node` at any depth, including the queries nested in it. */
-function collectColumnKeys(node, source, keys) {
-	visitNodes(node, true, (child) => {
-		if (child.kind === "column" && child.source === source) keys.add(child.key);
-	});
-}
-/**
-* Tells whether `node` holds, at any depth, a SQL fragment that refers to a column of `source` outside the queries nested in the fragment.
-*
-* PostgreSQL assigns an aggregate whose arguments refer only to the sources of an enclosing query to that query ([PostgreSQL](https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-AGGREGATES)).
-* Lowering does not parse SQL fragments to identify their aggregates, so such a fragment in a nested query, such as `sum` of a column of the parent row, may aggregate the rows of the query of `source`.
-*/
-function holdsFragmentOfSource(node, source) {
-	let found = false;
-	visitNodes(node, true, (child) => {
-		if (found || child.kind !== "raw") return;
-		visitNodes(child, false, (value) => {
-			if (value.kind === "column" && value.source === source) found = true;
-		});
-	});
-	return found;
-}
-/** Calls `visit` for `node` and each expression node in it, also in the queries nested in it when `deep` is set. */
-function visitNodes(node, deep, visit) {
-	visit(node);
-	switch (node.kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "tableName":
-		case "values":
-		case "nestedQuery": return;
-		case "cast":
-		case "not":
-		case "isNull":
-			visitNodes(node.operand, deep, visit);
-			return;
-		case "and":
-		case "or":
-			for (const operand of node.operands) visitNodes(operand, deep, visit);
-			return;
-		case "comparison":
-			visitNodes(node.left, deep, visit);
-			visitNodes(node.right, deep, visit);
-			return;
-		case "in":
-			visitNodes(node.operand, deep, visit);
-			for (const item of node.list) visitNodes(item, deep, visit);
-			return;
-		case "inQuery":
-			visitNodes(node.operand, deep, visit);
-			if (deep && node.query.kind === "select") visitQuery(node.query, visit);
-			return;
-		case "raw":
-			for (const value of node.values) visitNodes(value, deep, visit);
-			return;
-		case "subquery":
-		case "exists":
-		case "textSubquery":
-			if (deep) visitQuery(node.query, visit);
-			return;
-		case "aggregate":
-			for (const argument of node.arguments) visitNodes(argument, deep, visit);
-			for (const order of node.orderBy) visitNodes(order.expression, deep, visit);
-			return;
-	}
-}
-/** Calls `visit` for each expression node in the clauses and the derived sources of `query` at any depth. */
-function visitQuery(query, visit) {
-	const { from, filters } = query;
-	if (from?.kind === "derived") visitQuery(from.query, visit);
-	for (const join of query.joins) {
-		if (join.source.kind === "derived") visitQuery(join.source.query, visit);
-		visitNodes(join.on, true, visit);
-	}
-	for (const projection of query.projections) visitNodes(projection.expression, true, visit);
-	if (filters.relation !== void 0) visitNodes(filters.relation, true, visit);
-	if (filters.scope !== void 0) visitNodes(filters.scope, true, visit);
-	if (filters.user !== void 0) visitNodes(filters.user, true, visit);
-	for (const order of query.orderBy) visitNodes(order.expression, true, visit);
-	if (query.limit !== void 0) visitNodes(query.limit, true, visit);
-	if (query.offset !== void 0) visitNodes(query.offset, true, visit);
-}
-// src/query/rows.ts
-/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
-function getRelationRows(relation) {
-	if (relation.kind === "many") return "many";
-	return relation.required ? "one" : "nullable";
-}
-/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
-function toFilteredRows(rows, value, guaranteed) {
-	if (!guaranteed || rows !== "one") return rows;
-	return value ? "optional" : "nullable";
-}
-/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
-function limitToOne(limit) {
-	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
-}
-/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
-function toValueRows(rows) {
-	return rows === "nullable" ? "optional" : rows;
-}
-// src/query/node.ts
-/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
-function createQueryNode(from, relation, filters = noFilters) {
-	return Object.freeze({
-		kind: "query",
-		from,
-		relation,
-		projections: [],
-		filters,
-		orderBy: [],
-		limit: void 0,
-		offset: void 0,
-		rows: relation === void 0 ? "many" : getRelationRows(relation),
-		value: false,
-		guaranteed: relation?.required ?? false,
-		all: false
-	});
-}
-/** Tells whether `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, order, limit, offset, rows other than `many`, or `all`. */
-function isTableQuery(node) {
-	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && node.rows === "many" && !node.all;
-}
-/** Tells whether a selected field is the rows of a nested query. */
-function isNestedSelection(node) {
-	return "query" in node;
-}
-/** Tells whether a selected field is a literal. */
-function isLiteralSelection(node) {
-	return "literal" in node;
-}
-// src/schema/relation.ts
-/** Runtime mark of the declarations of `many` and `one`. */
-const declarationBrand = Symbol("kern-orm.relation");
-/** Returns the name of relation `name` of the table under key `key` in messages and errors, such as `field.form`. */
-function formatRelationName(key, name) {
-	return `${key}.${name}`;
-}
-/**
-* Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
-*
-* A composite key lists its columns in arrays of the same length.
-*/
-function many(target, keys) {
-	return declareRelation("many", target, keys, false);
-}
-/**
-* Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
-*
-* A composite key lists its columns in arrays of the same length.
-* The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
-* Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
-* Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
-*/
-function one(target, keys) {
-	return declareRelation("one", target, keys, keys.required === true);
-}
-function declareRelation(kind, target, keys, required) {
-	return Object.freeze({
-		[declarationBrand]: true,
-		kind,
-		target,
-		from: toKeyList(keys.from),
-		to: toKeyList(keys.to),
-		required
-	});
-}
-function toKeyList(key) {
-	return Object.freeze(Array.isArray(key) ? key.slice() : [key]);
-}
-/**
-* Defines relation `name` of table `source`, declared under its key `key` in a schema, checking its target and its keys.
-*
-* `findKey` returns the key of a table in the schema, or `undefined` for a table outside it.
-* Each pair of columns of the keys must satisfy `isEqualityCompatible`, the columns `to` of a relation `one` must include a key of the target, and the columns `from` of a required relation must not be nullable by `isNullable` of their types.
-*/
-function defineRelation(source, key, name, declaration, findKey) {
-	const subject = `Relation "${formatRelationName(key, name)}"`;
-	if (!isRelationDeclaration(declaration)) throw new TypeError(`${subject} must be declared with many or one`);
-	if (name.startsWith("$")) throw new Error(`${subject}: a relation name must not start with "$"`);
-	if (findColumn(source, name)) throw new Error(`${subject}: a relation name must differ from the column keys of table "${source.name}"`);
-	const { kind, target, from, to, required } = declaration;
-	const targetKey = findKey(target);
-	if (targetKey === void 0) throw new Error(`${subject} refers to table "${target.name}", which is not part of the schema`);
-	if (from.length === 0 || from.length !== to.length) throw new Error(`${subject} must list as many columns in "to" as in "from", at least one`);
-	for (let index = 0; index < from.length; index++) {
-		const fromColumn = findColumn(source, from[index]);
-		if (!fromColumn) throw new Error(`${subject}: unknown column "${from[index]}" of table "${source.name}"`);
-		if (required && fromColumn.type.isNullable) throw new Error(`${subject} cannot be required: column "${from[index]}" of table "${source.name}" is nullable`);
-		const toColumn = findColumn(target, to[index]);
-		if (!toColumn) throw new Error(`${subject}: unknown column "${to[index]}" of table "${target.name}"`);
-		if (!isEqualityCompatible(fromColumn.type, toColumn.type)) throw new Error(`${subject} cannot compare column "${from[index]}" (${fromColumn.type.sqlType}) with column "${to[index]}" (${toColumn.type.sqlType}) of table "${target.name}" by SQL =`);
-	}
-	if (kind === "one" && !containsKey(target, to)) throw new Error(`${subject}: columns "to" must include a key of table "${target.name}", primary or unique`);
-	return Object.freeze({
-		kind,
-		name,
-		key,
-		source,
-		target,
-		targetKey,
-		from,
-		to,
-		required
-	});
-}
-/** Adds `definition` of relation `name` of the table under `key` to `relations`, rejecting another definition of the relation there. */
-function addRelation(relations, key, name, definition) {
-	let named = relations.get(key);
-	if (named === void 0) {
-		named = /* @__PURE__ */ new Map();
-		relations.set(key, named);
-	}
-	const existing = named.get(name);
-	if (existing !== void 0 && existing !== definition) throw new Error(`Relation "${formatRelationName(key, name)}" has two different definitions`);
-	named.set(name, definition);
-}
-/** Adds the relation definitions of a schema to `relations`, rejecting another definition of a relation there. */
-function addRelations(relations, added) {
-	for (const key of Object.keys(added)) {
-		const named = added[key];
-		for (const name of Object.keys(named)) addRelation(relations, key, name, named[name]);
-	}
-}
-/** Collects the relation definitions of a schema, which a `Db` of the schema accepts in its queries. */
-function collectDefinitions(relations) {
-	const definitions = /* @__PURE__ */ new Set();
-	for (const key of Object.keys(relations)) {
-		const named = relations[key];
-		for (const name of Object.keys(named)) definitions.add(named[name]);
-	}
-	return definitions;
-}
-/** Creates frozen relations of a schema from `relations`; objects without a prototype keep any key, such as `__proto__`, an own property. */
-function freezeRelations(relations) {
-	const result = Object.create(null);
-	for (const [key, named] of relations) {
-		const table = Object.create(null);
-		for (const [name, definition] of named) table[name] = definition;
-		result[key] = Object.freeze(table);
-	}
-	return Object.freeze(result);
-}
-function isRelationDeclaration(value) {
-	return typeof value === "object" && value !== null && declarationBrand in value;
-}
-// src/lowering/order.ts
-/**
-* Returns the position of the projection that has the value of the sort expression `expression`: a projection of the same column or of the same expression node, or `-1`.
-*
-* Only the same node or column guarantees one value: PostgreSQL may or may not evaluate equal expressions built apart once, and gives each its own parameters.
-*/
-function findSortProjection(projections, expression) {
-	return projections.findIndex((projection) => {
-		const selected = projection.expression;
-		return expression.kind === "column" && selected.kind === "column" ? selected.source === expression.source && selected.key === expression.key : selected === expression;
-	});
-}
-/** Creates the number of the projection at `position`, by which `ORDER BY` sorts by its value instead of evaluating an expression again. */
-function createPositionNode(position) {
-	return createNode({
-		kind: "raw",
-		fragments: [String(position + 1)],
-		values: []
-	});
-}
-/** Creates the order of a statement that sorts by the positions of the projections among `projections` that have the values of its sort expressions, and by the other expressions as they are. */
-function sortByPositions(orderBy, projections) {
-	const result = [];
-	for (const order of orderBy) {
-		const position = findSortProjection(projections, order.expression);
-		result.push(position === -1 ? order : Object.freeze({
-			expression: createPositionNode(position),
-			direction: order.direction,
-			nulls: order.nulls
-		}));
-	}
-	return result;
-}
-/**
-* Creates the derived source of the rows of `query`, and, when `ordered`, the order of the query over the projections of the source, in which its reader takes the rows, such as an aggregate.
-*
-* The order of a derived source does not carry into the query that reads it, so the reader sorts by sort keys: the projections that have the values of the sort expressions, as for an executed query, or projections of the sort expressions added to the source.
-* With a limit or an offset, the source sorts by the positions of the sort keys, so that the rows it chooses, their values, and their order in the reader come from one evaluation; without them, it has no order.
-* `offset` replaces the offset of `query` in the source, such as `OFFSET 0` that keeps PostgreSQL from merging it, and the source replaces the occurrence of a table `replaces` for its reader.
-*/
-function deriveOrderedSource(query, ordered, offset = query.offset, replaces) {
-	const { orderBy } = query;
-	const projections = query.projections.slice();
-	const paginated = query.limit !== void 0 || query.offset !== void 0;
-	const sortKeys = [];
-	const positions = [];
-	if (orderBy.length > 0 && (ordered || paginated)) for (let index = 0; index < orderBy.length; index++) {
-		const { expression, direction, nulls } = orderBy[index];
-		const position = projectSortKey(projections, expression, index);
-		if (ordered) sortKeys.push({
-			key: projections[position].key,
-			direction,
-			nulls
-		});
-		if (paginated) positions.push(Object.freeze({
-			expression: createPositionNode(position),
-			direction,
-			nulls
-		}));
-	}
-	const derivedQuery = Object.freeze({
-		...query,
-		projections,
-		orderBy: positions,
-		offset
-	});
-	const source = Object.freeze(replaces === void 0 ? {
-		kind: "derived",
-		query: derivedQuery,
-		lateral: false
-	} : {
-		kind: "derived",
-		query: derivedQuery,
-		lateral: false,
-		replaces
-	});
-	const order = [];
-	for (const { key, direction, nulls } of sortKeys) order.push(Object.freeze({
-		expression: createNode({
-			kind: "column",
-			source,
-			key
-		}),
-		direction,
-		nulls
-	}));
-	return {
-		source,
-		order
-	};
-}
-/**
-* Returns the position of the projection that sorts by `expression`: the projection of `findSortProjection`, or one added to `projections`.
-*
-* `index` is the position of the expression in the order.
-*/
-function projectSortKey(projections, expression, index) {
-	const position = findSortProjection(projections, expression);
-	if (position !== -1) return position;
-	projections.push(Object.freeze({
-		key: createSortProjectionKey(projections, index),
-		expression,
-		type: text
-	}));
-	return projections.length - 1;
-}
-/** Creates the key of the sort key projection at `index` of the sort keys, which no other projection has. */
-function createSortProjectionKey(projections, index) {
-	const base = `$order${index + 1}`;
-	let key = base;
-	for (let number = 2; projections.some((projection) => projection.key === key); number++) key = `${base}_${number}`;
-	return key;
-}
-// src/lowering/nested.ts
-/** Maximum number of arguments of a PostgreSQL function, `FUNC_MAX_ARGS` of its default build. */
-const maxFunctionArguments = 100;
-/** Number `0`, the offset that keeps PostgreSQL from merging a derived source into its query. */
-const zeroNode = /* @__PURE__ */ createNode({
-	kind: "raw",
-	fragments: ["0"],
-	values: []
-});
-/**
-* Creates the projection of the rows of `query` packed as JSON under `key`, selected as a scalar subquery and decoded by the result plan of `query`.
-*
-* Rows `many` are one array, and the other rows modes are one packed row or `NULL` without a row; a scalar subquery fails with several rows.
-*/
-function projectRows(key, query) {
-	const packed = packRows(query);
-	const { nested } = packed.projections[0];
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "subquery",
-			query: packed
-		}),
-		nested
-	});
-}
-/**
-* Creates a query whose only projection is the rows of `query` packed as JSON, a field decoded by the result plan of `query`.
-*
-* Rows `many` are packed as an array in the order of `query`, and the created query returns one row.
-* Otherwise the created query returns a packed row for each row of `query`, so a scalar subquery of it gives the packed row, `NULL` without a row, and fails with several rows.
-*/
-function packRows(query) {
-	const { projections } = query;
-	const many = query.rows === "many";
-	const { source, order } = deriveOrderedSource(query, many, query.limit === void 0 && query.offset === void 0 && projections.some((projection) => projection.nested === void 0 && !isTableColumn(projection.expression)) ? zeroNode : query.offset);
-	const wide = projections.length > maxFunctionArguments;
-	const values = [];
-	for (const projection of projections) {
-		const value = createRef(source, projection.key);
-		if (projection.nested !== void 0) values.push(value);
-		else values.push(wide ? createList("to_json(", [packScalar(value)], ")") : packScalar(value));
-	}
-	const row = wide ? createList("array_to_json(ARRAY[", values, "])") : createList("json_build_array(", values, ")");
-	let packed = row;
-	if (many) packed = createNode({
-		kind: "raw",
-		fragments: ["coalesce(", ", '[]'::json)"],
-		values: [createNode({
-			kind: "aggregate",
-			name: "json_agg",
-			distinct: false,
-			arguments: [row],
-			orderBy: order
-		})]
-	});
-	const plan = Object.freeze({
-		fields: projections,
-		rows: query.rows,
-		value: query.value,
-		guaranteedBy: query.guaranteedBy,
-		recordTemplate: query.recordTemplate
-	});
-	const projection = Object.freeze({
-		key: "rows",
-		expression: packed,
-		nested: plan
-	});
-	return createSelectNode(source, [projection]);
-}
-/** Tells whether `node` is a column of a table, which PostgreSQL reads rather than evaluates, so it can be repeated. */
-function isTableColumn(node) {
-	return node.kind === "column" && node.source.kind === "table";
-}
-/**
-* Packs a scalar as its PostgreSQL text representation, or `NULL`.
-*
-* `format` uses the output function of the type, as the driver receives the values of a row; a cast to `text` differs from it for types such as `boolean`, `inet`, and `char`.
-*/
-function packScalar(value) {
-	return createNode({
-		kind: "raw",
-		fragments: [
-			"CASE WHEN ",
-			" IS NOT DISTINCT FROM NULL THEN NULL ELSE format('%s', ",
-			") END"
-		],
-		values: [value, value]
-	});
-}
-function createRef(source, key) {
-	return createNode({
-		kind: "column",
-		source,
-		key
-	});
-}
-// src/lowering/lower.ts
-const noJoins = /* @__PURE__ */ Object.freeze([]);
-const noOrder = /* @__PURE__ */ Object.freeze([]);
-const noProjections = /* @__PURE__ */ Object.freeze([]);
-function lowerStatement(node, definitions, db) {
-	const context = {
-		definitions,
-		db
-	};
-	switch (node.kind) {
-		case "query": return lowerSelect(node, context, true);
-		case "record": return lowerRecord(node, context);
-		case "text": return lowerText(node, context);
-		default: return lowerMutation(node, context);
-	}
-}
-/** Lowers a statement of SQL text, replacing the queries in the expressions interpolated into it. */
-function lowerText(node, context) {
-	const sql = lowerExpression(node.sql, context);
-	if (sql === node.sql) return node;
-	return Object.freeze({
-		kind: "text",
-		sql,
-		fields: node.fields,
-		rows: node.rows,
-		value: node.value
-	});
-}
-/** Lowers a mutation to its statement, replacing the queries in its expressions, and packing the rows of each nested query of `RETURNING` into the value of its field, or selecting the value of a nested aggregate query, as a select list does. */
-function lowerMutation(node, context) {
-	const { target, returning, rows, value } = node;
-	const recordTemplate = returning === void 0 ? void 0 : createRecordTemplate(returning);
-	const lowered = returning === void 0 ? void 0 : lowerProjections(dropLiterals(returning), context);
-	switch (node.kind) {
-		case "insert": {
-			const values = lowerEach(node.values, context, lowerRow);
-			if (lowered === returning && values === node.values) return node;
-			return Object.freeze({
-				kind: "insert",
-				target,
-				columns: node.columns,
-				values,
-				returning: lowered,
-				recordTemplate,
-				rows,
-				value
-			});
-		}
-		case "update": {
-			const set = lowerEach(node.set, context, lowerAssignment);
-			const filters = lowerFilters(node.filters, context);
-			if (lowered === returning && set === node.set && filters === node.filters) return node;
-			return Object.freeze({
-				kind: "update",
-				target,
-				set,
-				filters,
-				returning: lowered,
-				recordTemplate,
-				rows,
-				value
-			});
-		}
-		case "delete": {
-			const filters = lowerFilters(node.filters, context);
-			if (lowered === returning && filters === node.filters) return node;
-			return Object.freeze({
-				kind: "delete",
-				target,
-				filters,
-				returning: lowered,
-				recordTemplate,
-				rows,
-				value
-			});
-		}
-		default: return node;
-	}
-}
-/** Lowers a row of `VALUES` of an insert, whose `undefined` stands for `DEFAULT`. */
-function lowerRow(row, context) {
-	return lowerEach(row, context, lowerValue);
-}
-function lowerValue(node, context) {
-	return node === void 0 ? void 0 : lowerExpression(node, context);
-}
-function lowerAssignment(assignment, context) {
-	const value = lowerExpression(assignment.value, context);
-	return value === assignment.value ? assignment : Object.freeze({
-		key: assignment.key,
-		value
-	});
-}
-/** Lowers a query as `lowerQuery` does, or as `lowerStatement` does when `positions` is set. */
-function lowerSelect(node, context, positions) {
-	if (isExistsQuery(node)) return selectExists(node, context);
-	checkRelation(node, context);
-	if (isAggregateQuery(node)) return lowerAggregate(node, context);
-	const recordTemplate = createRecordTemplate(node.projections);
-	const selected = dropLiterals(node.projections);
-	const projections = lowerProjections(selected, context);
-	const filters = lowerFilters(node.filters, context);
-	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
-	const { relation } = node;
-	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
-	const page = node.offset !== void 0 && selected.some((field, index) => isPagedField(field, projections[index], orderBy)) ? lowerPage(node, selected, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) : void 0;
-	if (page !== void 0) return page;
-	return Object.freeze({
-		kind: "select",
-		from: node.from,
-		joins: noJoins,
-		projections,
-		filters,
-		orderBy: positions && orderBy.length > 0 ? sortByPositions(orderBy, projections) : orderBy,
-		limit: node.limit,
-		offset: node.offset,
-		rows: node.rows,
-		value: node.value,
-		guaranteedBy,
-		recordTemplate
-	});
-}
-/** Returns the fields of `selected` that a statement selects, or `selected` itself without literals. */
-function dropLiterals(selected) {
-	if (!selected.some(isLiteralSelection)) return selected;
-	const fields = [];
-	for (const field of selected) if (!isLiteralSelection(field)) fields.push(field);
-	return fields;
-}
-/** Creates the template of the records of `selected`: every field in its order with the value of a literal, or `undefined` without literals. */
-function createRecordTemplate(selected) {
-	if (!selected.some(isLiteralSelection)) return;
-	const template = [];
-	for (const field of selected) template.push(Object.freeze({
-		key: field.key,
-		value: isLiteralSelection(field) ? field.literal : void 0
-	}));
-	return template;
-}
-/**
-* Tells whether `field`, a field of a query lowered to `projection`, is a nested query that a page after an offset evaluates only over its rows: one that no sort key of `orderBy`, the lowered order, sorts by.
-*
-* The query evaluates a field that it sorts by, of an aggregate or of `exists`, for every row anyway.
-*/
-function isPagedField(field, projection, orderBy) {
-	if (!isNestedSelection(field)) return false;
-	const { expression } = projection;
-	return !orderBy.some((order) => order.expression === expression);
-}
-/** Rejects a query of a relation outside the definitions of `context`. */
-function checkRelation(node, context) {
-	const { relation } = node;
-	const { definitions } = context;
-	if (relation !== void 0 && definitions !== void 0 && !definitions.has(relation)) throw new Error(`Relation "${formatRelationName(relation.key, relation.name)}" is not part of the schema`);
-}
-/** Rejects a nested query bound to `db`, which the error names as `subject`, unless `db` is the `Db` of `context` or `undefined`. */
-function checkDb(db, context, subject) {
-	if (db !== void 0 && db !== context.db) throw new Error(context.db === void 0 ? `${subject} is bound to a Db, so only that Db can compile the query` : `${subject} is bound to another Db`);
-}
-/**
-* Lowers `node` with `projections`, `filters`, and `orderBy`, the lowered parts of the node, to a statement that evaluates its nested queries, apart from those that it sorts by, over the rows of a derived page.
-* `queryFields` are the fields of the query without literals, and `projections` their lowered projections in the same order.
-* The derived source applies the filters, the order, the limit, and the offset, and replaces the occurrence of the table.
-*
-* It returns `undefined` when a nested query that it evaluates over the rows of the page holds a SQL fragment that refers to a column of the table outside the queries nested in the fragment.
-* Such a fragment may hold an aggregate of the query, which the limit and the offset apply after.
-*
-* The source selects the columns of the table that the fields and the nested queries of the query read, under their keys, and the other scalar fields of the query, which it evaluates before the limit and the offset as the query would, such as a window function over all its rows.
-* A field of an aggregate or of `exists` that the query sorts by is such a scalar field: the order needs its value for every row.
-* A column that no field reads stays out of the source, which could not select it beside an aggregate of a SQL fragment, such as `count(*)`.
-* The order of a derived source does not carry into the query that reads it, so the statement sorts the rows of the page again by the sort keys of the source, by positions when `positions` is set.
-*/
-function lowerPage(node, queryFields, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) {
-	const { from } = node;
-	const columnKeys = /* @__PURE__ */ new Set();
-	const fields = [];
-	const fieldKeys = [];
-	for (let index = 0; index < projections.length; index++) {
-		const { expression } = projections[index];
-		let key;
-		if (isPagedField(queryFields[index], projections[index], orderBy)) {
-			if (holdsFragmentOfSource(expression, from)) return;
-			collectColumnKeys(expression, from, columnKeys);
-		} else if (expression.kind === "column" && expression.source === from) columnKeys.add(expression.key);
-		else {
-			key = `$field${index + 1}`;
-			fields.push(Object.freeze({
-				key,
-				expression,
-				type: text
-			}));
-		}
-		fieldKeys.push(key);
-	}
-	const sourced = [];
-	for (const key of columnKeys) sourced.push(Object.freeze({
-		key,
-		expression: createNode({
-			kind: "column",
-			source: from,
-			key
-		}),
-		type: text
-	}));
-	for (const field of fields) sourced.push(field);
-	const page = deriveOrderedSource({
-		kind: "select",
-		from,
-		joins: noJoins,
-		projections: sourced,
-		filters,
-		orderBy,
-		limit: node.limit,
-		offset: node.offset,
-		rows: "many",
-		value: false,
-		guaranteedBy: void 0
-	}, true, node.offset, from);
-	const selected = [];
-	for (let index = 0; index < projections.length; index++) {
-		const projection = projections[index];
-		const key = fieldKeys[index];
-		selected.push(key === void 0 ? projection : Object.freeze({
-			key: projection.key,
-			expression: createNode({
-				kind: "column",
-				source: page.source,
-				key
-			}),
-			type: projection.type
-		}));
-	}
-	return Object.freeze({
-		kind: "select",
-		from: page.source,
-		joins: noJoins,
-		projections: selected,
-		filters: noFilters,
-		orderBy: positions ? sortByPositions(page.order, selected) : page.order,
-		limit: void 0,
-		offset: void 0,
-		rows: node.rows,
-		value: node.value,
-		guaranteedBy,
-		recordTemplate
-	});
-}
-/** Lowers an aggregate query to a statement of the value of its aggregate over the rows that its filters, limit, and offset choose. */
-function lowerAggregate(node, context) {
-	const field = node.projections[0];
-	const aggregate = field.expression;
-	const orderBy = lowerOrder(node.orderBy, context);
-	let from = node.from;
-	let filters = lowerFilters(node.filters, context);
-	let args = lowerEach(aggregate.arguments, context, lowerExpression);
-	let order = field.ordered ? orderBy : noOrder;
-	const counted = aggregate === countProjection.expression;
-	if (node.limit !== void 0 || node.offset !== void 0 || !counted && !refersToSource(args[0], node.from)) {
-		const projections = [];
-		if (!counted) projections.push(Object.freeze({
-			key: "value",
-			expression: args[0],
-			type: field.type
-		}));
-		const rows = deriveOrderedSource({
-			kind: "select",
-			from: node.from,
-			joins: noJoins,
-			projections,
-			filters,
-			orderBy: counted ? noOrder : orderBy,
-			limit: node.limit,
-			offset: node.offset,
-			rows: "many",
-			value: false,
-			guaranteedBy: void 0
-		}, field.ordered);
-		from = rows.source;
-		filters = noFilters;
-		if (!counted) {
-			const sourceArgs = [createNode({
-				kind: "column",
-				source: from,
-				key: "value"
-			})];
-			for (let index = 1; index < args.length; index++) sourceArgs.push(args[index]);
-			args = sourceArgs;
-		}
-		order = rows.order;
-	}
-	const call = args === aggregate.arguments && order.length === 0 ? aggregate : createNode({
-		kind: "aggregate",
-		name: aggregate.name,
-		distinct: aggregate.distinct,
-		arguments: args,
-		orderBy: order
-	});
-	const fallbacks = lowerEach(field.fallbacks, context, lowerExpression);
-	let value = call;
-	if (fallbacks.length > 0) {
-		const values = [call];
-		for (const fallback of fallbacks) values.push(fallback);
-		value = createList("coalesce(", values, ")");
-	}
-	return Object.freeze({
-		kind: "select",
-		from,
-		joins: noJoins,
-		projections: [value === aggregate ? field : Object.freeze({
-			key: field.key,
-			expression: value,
-			type: field.type
-		})],
-		filters,
-		orderBy: noOrder,
-		limit: void 0,
-		offset: void 0,
-		rows: node.rows,
-		value: true,
-		guaranteedBy: void 0
-	});
-}
-/**
-* Tells whether `node` refers to `source` outside the queries nested in it.
-*
-* A reference inside a nested query is not counted, so an argument that refers to the source only there is read from a derived source, which is correct either way.
-*/
-function refersToSource(node, source) {
-	switch (node.kind) {
-		case "column": return node.source === source;
-		case "param":
-		case "boolean":
-		case "values":
-		case "nestedQuery":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery": return false;
-		case "cast":
-		case "not":
-		case "isNull":
-		case "inQuery": return refersToSource(node.operand, source);
-		case "and":
-		case "or": return node.operands.some((operand) => refersToSource(operand, source));
-		case "comparison": return refersToSource(node.left, source) || refersToSource(node.right, source);
-		case "in": return refersToSource(node.operand, source) || node.list.some((item) => refersToSource(item, source));
-		case "raw": return node.values.some((value) => refersToSource(value, source));
-		case "aggregate": return node.arguments.some((argument) => refersToSource(argument, source));
-		default: return node;
-	}
-}
-/** Lowers a query of `exists` to `EXISTS` of the rows that its filters, limit, and offset choose. */
-function lowerExists(node, context) {
-	checkRelation(node, context);
-	return createNode({
-		kind: "exists",
-		query: Object.freeze({
-			kind: "select",
-			from: node.from,
-			joins: noJoins,
-			projections: noProjections,
-			filters: lowerFilters(node.filters, context),
-			orderBy: noOrder,
-			limit: node.limit,
-			offset: node.offset,
-			rows: "many",
-			value: false,
-			guaranteedBy: void 0
-		})
-	});
-}
-/** Lowers a query of `exists` to a statement without a source of one row of `EXISTS` of its rows. */
-function selectExists(node, context) {
-	return Object.freeze({
-		kind: "select",
-		from: void 0,
-		joins: noJoins,
-		projections: [projectExists(node.projections[0].key, node, context)],
-		filters: noFilters,
-		orderBy: noOrder,
-		limit: void 0,
-		offset: void 0,
-		rows: node.rows,
-		value: true,
-		guaranteedBy: void 0
-	});
-}
-/** Creates the projection of `EXISTS` of the rows of `node`, a query of `exists`, under `key`, decoded by the type of the projection of `exists`. */
-function projectExists(key, node, context) {
-	return Object.freeze({
-		key,
-		expression: lowerExists(node, context),
-		type: node.projections[0].type
-	});
-}
-/** Lowers a query of `$select` to a statement without a source, which returns one row of its fields. */
-function lowerRecord(node, context) {
-	return Object.freeze({
-		kind: "select",
-		from: void 0,
-		joins: noJoins,
-		projections: lowerProjections(dropLiterals(node.projections), context),
-		filters: noFilters,
-		orderBy: noOrder,
-		limit: void 0,
-		offset: void 0,
-		rows: "one",
-		value: false,
-		guaranteedBy: void 0,
-		recordTemplate: createRecordTemplate(node.projections)
-	});
-}
-/**
-* Lowers the fields of a query to projections, packing the rows of each nested query into the value of its field, or selecting the value of an aggregate query or `EXISTS` of a query of `exists`, and replacing the queries in the expressions of the other fields; checks them as `lowerQuery` does.
-*
-* Without queries, it returns `selected` itself.
-*/
-function lowerProjections(selected, context) {
-	let lowered;
-	for (let index = 0; index < selected.length; index++) {
-		const field = selected[index];
-		let projection;
-		if (isNestedSelection(field)) {
-			checkDb(field.db, context, `Selected field "${field.key}"`);
-			projection = projectQuery(field.key, field.query, context);
-		} else {
-			const expression = lowerExpression(field.expression, context);
-			projection = expression === field.expression ? field : Object.freeze({
-				key: field.key,
-				expression,
-				type: field.type
-			});
-		}
-		if (lowered !== void 0) lowered.push(projection);
-		else if (projection !== field) {
-			lowered = selected.slice(0, index);
-			lowered.push(projection);
-		}
-	}
-	return lowered ?? selected;
-}
-/** Creates the projection of the value of `node`, a nested query, under `key`: `EXISTS` of a query of `exists`, the value of an aggregate query, or the packed rows of another query. */
-function projectQuery(key, node, context) {
-	if (isExistsQuery(node)) return projectExists(key, node, context);
-	const query = lowerSelect(node, context, false);
-	return isAggregateQuery(node) ? projectAggregateValue(key, query) : projectRows(key, query);
-}
-/** Creates the projection of the value of `query`, the statement of an aggregate query, under `key`, selected as a scalar subquery and decoded by the type of the aggregate. */
-function projectAggregateValue(key, query) {
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "subquery",
-			query
-		}),
-		type: query.projections[0].type
-	});
-}
-/** Lowers the filters of a query, replacing the queries in their expressions; without queries, it returns `filters` itself. */
-function lowerFilters(filters, context) {
-	const { relation, scope, user } = filters;
-	const loweredRelation = relation === void 0 ? void 0 : lowerExpression(relation, context);
-	const loweredScope = scope === void 0 ? void 0 : lowerExpression(scope, context);
-	const loweredUser = user === void 0 ? void 0 : lowerExpression(user, context);
-	if (loweredRelation === relation && loweredScope === scope && loweredUser === user) return filters;
-	const lowered = {};
-	if (loweredRelation !== void 0) lowered.relation = loweredRelation;
-	if (loweredScope !== void 0) lowered.scope = loweredScope;
-	if (loweredUser !== void 0) lowered.user = loweredUser;
-	return Object.freeze(lowered);
-}
-/**
-* Lowers the sort keys of a query, replacing the queries in their expressions; without queries, it returns `orderBy` itself.
-*
-* A sort key of a field of `selected`, the fields of the query, takes the expression of its projection among `projections`, the lowered fields, so that the statement still finds the projection that has its value.
-* A field of an aggregate or of `exists` is identified by the node of its reference, which holds the field.
-*/
-function lowerOrder(orderBy, context, selected, projections) {
-	let lowered;
-	for (let index = 0; index < orderBy.length; index++) {
-		const order = orderBy[index];
-		const { expression } = order;
-		const position = selected === void 0 || projections === void 0 || projections === selected ? -1 : selected.findIndex((field) => isFieldValue(field, expression));
-		const sorted = position === -1 ? lowerExpression(expression, context) : projections[position].expression;
-		if (lowered === void 0 && sorted === expression) continue;
-		lowered ??= orderBy.slice(0, index);
-		lowered.push(sorted === expression ? order : Object.freeze({
-			expression: sorted,
-			direction: order.direction,
-			nulls: order.nulls
-		}));
-	}
-	return lowered ?? orderBy;
-}
-/** Tells whether the sort expression `expression` is the value of `field`: its expression, or for a field of an aggregate or of `exists`, the node of its reference in the callback of `orderBy`. */
-function isFieldValue(field, expression) {
-	return isNestedSelection(field) ? expression.kind === "nestedQuery" && expression.field === field : field.expression === expression;
-}
-/**
-* Lowers an expression, replacing each query in it and checking the query as a nested query.
-* A query of `exists`, such as in a condition, becomes `EXISTS` of its rows, another query of one value a scalar subquery of its value, the query of the values of `IN` its statement, and another query in SQL text its statement in parentheses.
-*
-* It returns `node` itself when it holds no query, and creates only the nodes that hold one.
-*/
-function lowerExpression(node, context) {
-	switch (node.kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "values":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery": return node;
-		case "nestedQuery": return lowerNestedQuery(node, context);
-		case "cast": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "cast",
-				operand,
-				type: node.type
-			});
-		}
-		case "not": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "not",
-				operand
-			});
-		}
-		case "isNull": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "isNull",
-				operand
-			});
-		}
-		case "and":
-		case "or": {
-			const operands = lowerEach(node.operands, context, lowerExpression);
-			return operands === node.operands ? node : createNode({
-				kind: node.kind,
-				operands
-			});
-		}
-		case "comparison": {
-			const left = lowerExpression(node.left, context);
-			const right = lowerExpression(node.right, context);
-			return left === node.left && right === node.right ? node : createNode({
-				kind: "comparison",
-				operator: node.operator,
-				left,
-				right
-			});
-		}
-		case "in": {
-			const operand = lowerExpression(node.operand, context);
-			const list = lowerEach(node.list, context, lowerExpression);
-			return operand === node.operand && list === node.list ? node : createNode({
-				kind: "in",
-				operand,
-				list
-			});
-		}
-		case "inQuery": {
-			const operand = lowerExpression(node.operand, context);
-			const query = node.query.kind === "nestedQuery" ? lowerQueryOfValues(node.query, context) : node.query;
-			return operand === node.operand && query === node.query ? node : createNode({
-				kind: "inQuery",
-				operand,
-				query
-			});
-		}
-		case "raw": {
-			const values = lowerEach(node.values, context, lowerExpression);
-			return values === node.values ? node : createNode({
-				kind: "raw",
-				fragments: node.fragments,
-				values
-			});
-		}
-		case "aggregate": {
-			const args = lowerEach(node.arguments, context, lowerExpression);
-			const orderBy = lowerOrder(node.orderBy, context);
-			return args === node.arguments && orderBy === node.orderBy ? node : createNode({
-				kind: "aggregate",
-				name: node.name,
-				distinct: node.distinct,
-				arguments: args,
-				orderBy
-			});
-		}
-		default: return node;
-	}
-}
-/**
-* Lowers a query in an expression to `EXISTS` of the rows of a query of `exists`, to a scalar subquery of the value of another query of one value, or to its statement in parentheses for a query of records or of rows `many`, which only SQL text holds.
-*
-* In SQL text, a query of `exists` stays `EXISTS` rather than a subquery of its value, so that PostgreSQL can join its rows in a condition, as a semi-join.
-*/
-function lowerNestedQuery(node, context) {
-	checkDb(node.db, context, "A query in an expression");
-	const { query } = node;
-	if (isExistsQuery(query)) return lowerExists(query, context);
-	return createNode({
-		kind: query.value && query.rows !== "many" ? "subquery" : "textSubquery",
-		query: lowerSelect(query, context, false)
-	});
-}
-/** Lowers the query of the values of `IN` to its statement, whatever its rows. */
-function lowerQueryOfValues(node, context) {
-	checkDb(node.db, context, "A query in an expression");
-	return lowerSelect(node.query, context, false);
-}
-/** Lowers each of `items` with `lower`; when none changes, it returns `items` itself. */
-function lowerEach(items, context, lower) {
-	let lowered;
-	for (let index = 0; index < items.length; index++) {
-		const item = items[index];
-		const result = lower(item, context);
-		if (lowered !== void 0) lowered.push(result);
-		else if (result !== item) {
-			lowered = items.slice(0, index);
-			lowered.push(result);
-		}
-	}
-	return lowered ?? items;
-}
-// src/query/kind.ts
-/** `then` of every bound query, which executes the query on its `Db`. */
-function executeOnAwait(onFulfilled, onRejected) {
-	return this.db.$execute(this).then(onFulfilled, onRejected);
-}
-/** Compiles `query` as its `toSQL` does: an unbound query with `options`, and a bound query as its `Db` executes it, which takes no options. */
-function compileToSQL(query, options) {
-	const { db } = query;
-	if (db === void 0) {
-		const { text, parameters } = compileStatement(lowerStatement(query.node), options);
-		return createStatement(text, parameters);
-	}
-	if (options !== void 0) throw new Error("A query bound to a Db compiles with the options of its Db");
-	return db.$compile(query);
-}
-// src/query/record.ts
-/**
-* Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and of literals and the results of independent queries, selected in one statement.
-*
-* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
-* A bound query executes on its `Db` when awaited.
-*/
-var RecordQuery = class {
-	node;
-	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-	db;
-	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-	then;
-	constructor(node, db) {
-		this.node = node;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-	[operandNode]() {
-		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of $select");
-	}
-};
-/**
-* Starts the query of `$select` of `selection`, an object of expressions, queries, and literals by key, bound to `db` when given.
-*
-* It reads the keys and values of `selection` when it is called.
-*/
-function startRecordQuery(selection, db) {
-	const projections = [];
-	addSelection(projections, selection);
-	return new RecordQuery(Object.freeze({
-		kind: "record",
-		projections
-	}), db);
-}
-// src/query/sql-query.ts
-/**
-* Immutable query of a statement of SQL text, bound to the `Db` that executes it when awaited.
-*
-* Without a selection, it resolves to the number of the rows of the command tag of its statement, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of the rows of the statement instead, decoded by types.
-*/
-var SqlQuery = class SqlQuery {
-	node;
-	db;
-	/** Executes the query on its `Db`. */
-	then;
-	constructor(node, db) {
-		this.node = node;
-		this.db = db;
-		this.then = executeOnAwait;
-		Object.freeze(this);
-	}
-	select(fields) {
-		const { node } = this;
-		if (node.fields !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
-		if (typeof fields !== "object" || fields === null) throw new TypeError("select takes an object of the types of the fields by their columns");
-		const added = Reflect.ownKeys(fields);
-		const selected = [];
-		for (const field of node.fields ?? []) if (!added.includes(field.key)) selected.push(field);
-		for (const key of added) {
-			if (typeof key === "symbol") throw new TypeError("A selected field must have a string key");
-			if (!isRecordKey(key)) throw new Error(`Field "${key}" cannot be a key of a record`);
-			selected.push(Object.freeze({
-				key,
-				type: requireType(fields[key], `field "${key}"`)
-			}));
-		}
-		return this.derive({
-			fields: selected,
-			value: false
-		});
-	}
-	get(type) {
-		const { rows } = this.node;
-		return this.deriveValue(type, "get", rows === "many" ? "one" : toValueRows(rows));
-	}
-	pluck(type) {
-		return this.deriveValue(type, "pluck", toValueRows(this.node.rows));
-	}
-	take() {
-		const { rows } = this.node;
-		return this.derive({ rows: rows === "many" ? "one" : rows });
-	}
-	optional() {
-		return this.changeOneRow("optional");
-	}
-	nullable() {
-		const { node } = this;
-		if (node.fields !== void 0 && node.value) throw new Error("nullable applies only to a query of records; use optional after get or pluck");
-		return this.changeOneRow("nullable");
-	}
-	/** Compiles the query into SQL text and parameters, as its `Db` executes it. */
-	toSQL() {
-		return this.db.$compile(this);
-	}
-	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-	[operandNode]() {
-		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of $query");
-	}
-	/** Creates a query of the same `Db` with the node changes applied. */
-	derive(changes) {
-		return new SqlQuery(Object.freeze({
-			...this.node,
-			...changes
-		}), this.db);
-	}
-	/** Creates the query that returns the value of the only column of each row in rows mode `rows`, decoded by `type` of `method`. */
-	deriveValue(type, method, rows) {
-		const field = Object.freeze({
-			key: "value",
-			type: requireType(type, method)
-		});
-		return this.derive({
-			fields: [field],
-			value: true,
-			rows
-		});
-	}
-	/** Creates the query of one row in rows mode `rows`, rejecting a query of many rows. */
-	changeOneRow(rows) {
-		if (this.node.rows === "many") throw new Error(`${rows} applies only to a query of one row, such as one made by take`);
-		return this.derive({ rows });
-	}
-};
-/** Starts the query of the statement of `sql` bound to `db`, which resolves to the number of the rows of its command tag. */
-function startSqlQuery(sql, db) {
-	return new SqlQuery(Object.freeze({
-		kind: "text",
-		sql,
-		fields: void 0,
-		rows: "many",
-		value: false
-	}), db);
-}
-/** Returns `value` that `what` takes as its type, rejecting a value that is not a type, such as a column. */
-function requireType(value, what) {
-	if (!isType(value)) throw new TypeError(`${what} takes a type, such as t.integer, not a column or another value`);
-	return value;
-}
-// src/query/projections.ts
-/**
-* Creates the fields of `select` over `source`, appending new keys and replacing existing ones in place.
-*
-* `args` are the arguments of `select`: `"*"`, column keys, or a callback that receives the references of `source` with the relations of `context` and returns a selection.
-*/
-function mergeProjections(projections, source, args, context) {
-	const result = projections.slice();
-	const first = args[0];
-	if (typeof first === "function") addSelection(result, first(createSelectionRefs(source, context)));
-	else {
-		const keys = first === "*" ? Object.keys(source.table.columns) : args;
-		for (const key of keys) setProjection(result, projectColumn(source, key));
-	}
-	return result;
-}
-/** Adds the fields of `selection`, expressions, queries, and literals by key, to `projections`, replacing existing keys in place. */
-function addSelection(projections, selection) {
-	for (const key of Reflect.ownKeys(selection)) {
-		if (typeof key === "symbol") throw new TypeError("A selected field must have a string key");
-		setProjection(projections, selectValue(key, selection[key]));
-	}
-}
-/**
-* Creates the projection of the value of `get` or `pluck`, or of the argument of an aggregate method, such as `max`, over `source`.
-*
-* `arg` is the argument of `method`: a column key, or a callback that receives the columns and returns an expression.
-*/
-function projectValue(source, arg, method) {
-	if (typeof arg !== "function") return projectColumn(source, arg);
-	const value = arg(createColumnRefs(source));
-	if (!isExpression(value)) throw new TypeError(`The callback of ${method} must return an expression`);
-	const type = getType(value);
-	if (!type) throw new TypeError(`The expression of ${method} has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
-	return projectExpression("value", value, type);
-}
-/**
-* Creates the projection of the value of `field`, the only projection of a query of values, whose `NULL` `fallback` replaces: a value that the type of the field encodes, an expression, or a query of one value.
-*
-* The projection of an aggregate keeps its call, which lowering builds, and adds the fallback after its earlier ones.
-* The projection of `exists` stays as it is, since `EXISTS` is never `NULL`.
-*/
-function coalesceValue(field, fallback) {
-	const value = toFunctionOperandNode(fallback, field.type, "coalesce");
-	if (isExistsProjection(field)) return field;
-	if (isAggregateProjection(field)) return addFallback(field, value);
-	return Object.freeze({
-		key: field.key,
-		expression: createList("coalesce(", [field.expression, value], ")"),
-		type: field.type
-	});
-}
-/** Creates the field of a value of a selection under `key`: an expression with a type, a query whose rows become its value, or a literal. */
-function selectValue(key, value) {
-	if (value instanceof Literal) return Object.freeze({
-		key,
-		literal: value.literal
-	});
-	if (value instanceof SelectQuery) return Object.freeze({
-		key,
-		query: value.node,
-		db: value.db
-	});
-	if (value instanceof RecordQuery) throw new TypeError(`Selected field "${key}" is a query of $select, which cannot be nested; select its fields directly instead`);
-	if (value instanceof MutationQuery) throw new TypeError(`Selected field "${key}" is a query of insert, update, or delete, which cannot be nested`);
-	if (value instanceof SqlQuery) throw new TypeError(`Selected field "${key}" is a query of $query, which cannot be nested`);
-	if (!isExpression(value)) throw new TypeError(`Selected field "${key}" must be an expression, a query, or a literal`);
-	const type = getType(value);
-	if (!type) throw new TypeError(`Selected field "${key}" has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
-	return projectExpression(key, value, type);
-}
-/** Creates the projection of a column of the table of `source` under its key. */
-function projectColumn(source, key) {
-	const { type } = requireColumn(source.table, key);
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "column",
-			source,
-			key
-		}),
-		type
-	});
-}
-/** Creates the projection of an expression under `key`, decoded with `type`, the type of the expression. */
-function projectExpression(key, value, type) {
-	return Object.freeze({
-		key,
-		expression: toNode(value),
-		type
-	});
-}
-/** Adds or replaces a field by key, rejecting a key that a record cannot have. */
-function setProjection(projections, projection) {
-	const { key } = projection;
-	if (!isRecordKey(key)) throw new Error(`Field "${key}" cannot be selected: it is not a valid record key`);
-	for (let index = 0; index < projections.length; index++) if (projections[index].key === key) {
-		projections[index] = projection;
-		return;
-	}
-	projections.push(projection);
-}
-// src/query/values.ts
-/**
-* Returns the columns and the rows of `VALUES` of an insert of `records`, at least one, into `table`, reading the keys and values of each record when it is called.
-*
-* The columns are those that some record gives a value other than `undefined`, in the order that the records first give them, and a record that omits one inserts its `DEFAULT`.
-* Several records without values insert the `DEFAULT` of the first column of the table, since `DEFAULT VALUES` inserts one row.
-* It rejects a key that is not a column of `table`, and a query as a value.
-*/
-function toInsertRows(table, records, method) {
-	if (records.length === 0) throw new Error(`${method} takes at least one record`);
-	const columns = [];
-	const rows = [];
-	for (const record of records) {
-		if (typeof record !== "object" || record === null) throw new TypeError(`${method} takes records of the values of the columns of table "${table.name}"`);
-		const row = [];
-		for (const key of Object.keys(record)) {
-			const value = record[key];
-			if (value === void 0) continue;
-			let index = columns.indexOf(key);
-			if (index === -1) index = columns.push(key) - 1;
-			row[index] = resolveValue(table, key, value);
-		}
-		rows.push(row);
-	}
-	if (columns.length === 0 && rows.length > 1) {
-		const first = Object.keys(table.columns)[0];
-		if (first !== void 0) columns.push(first);
-	}
-	for (const row of rows) while (row.length < columns.length) row.push(void 0);
-	return {
-		columns,
-		values: rows
-	};
-}
-/**
-* Returns the assignments of an update of the rows of `source` that `set` gives: the values of its columns, or a callback that receives the columns and returns them, read when it is called.
-*
-* A value of `undefined` keeps its column, and an update must set at least one column.
-* It rejects a key that is not a column of the table of `source`, and a query as a value.
-*/
-function toAssignments(source, set) {
-	const { table } = source;
-	const values = typeof set === "function" ? set(createColumnRefs(source)) : set;
-	if (typeof values !== "object" || values === null) throw new TypeError(`update takes the values of the columns of table "${table.name}" or a callback that returns them`);
-	const assignments = [];
-	for (const key of Object.keys(values)) {
-		const value = values[key];
-		if (value !== void 0) assignments.push(Object.freeze({
-			key,
-			value: resolveValue(table, key, value)
-		}));
-	}
-	if (assignments.length === 0) throw new Error(`update takes the value of at least one column of table "${table.name}"; a column given as undefined keeps its value`);
-	return assignments;
-}
-/** Returns the node of `value` of the column of `table` under `key`: an expression, or a parameter encoded with the type of the column. */
-function resolveValue(table, key, value) {
-	const column = requireColumn(table, key);
-	if (value instanceof SelectQuery || value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError(`Column "${key}" of table "${table.name}" takes a value or an expression, not a query`);
-	return toValueNode(value, column.type);
-}
-// src/query/mutation.ts
-/**
-* Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
-*
-* Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
-* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
-* A bound query executes on its `Db` when awaited.
-*/
-var MutationQuery = class MutationQuery {
-	table;
-	node;
-	context;
-	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-	db;
-	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-	then;
-	constructor(table, node, context, db) {
-		this.table = table;
-		this.node = node;
-		this.context = context;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	select(...args) {
-		const { node } = this;
-		const { returning } = node;
-		if (returning !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
-		return this.derive({
-			returning: mergeProjections(returning ?? [], node.target, args, this.context),
-			value: false
-		});
-	}
-	get(arg) {
-		if (this.node.rows === "many") throw new Error("get applies only to a query that changes one row, such as of insert or find; use pluck to return the values of several rows");
-		return this.deriveValue(arg, "get");
-	}
-	pluck(arg) {
-		return this.deriveValue(arg, "pluck");
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-	[operandNode]() {
-		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of insert, update, or delete");
-	}
-	/** Creates a mutation of the same kind and `Db` with the node changes applied. */
-	derive(changes) {
-		return new MutationQuery(this.table, Object.freeze({
-			...this.node,
-			...changes
-		}), this.context, this.db);
-	}
-	/** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
-	deriveValue(arg, method) {
-		const { node } = this;
-		return this.derive({
-			returning: [projectValue(node.target, arg, method)],
-			value: true,
-			rows: toValueRows(node.rows)
-		});
-	}
-};
-/**
-* Creates the insert of `records` into the table of `query`, which must have no clauses, in rows mode `rows`: `one` for `insert` and `many` for `insertMany`, named by `method`.
-*
-* It returns the number of the inserted rows, until a selection returns their fields.
-*/
-function createInsert(query, records, rows, method) {
-	const { node } = query;
-	if (!isTableQuery(node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
-	const { columns, values } = toInsertRows(node.from.table, records, method);
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "insert",
-		target: node.from,
-		columns,
-		values,
-		returning: void 0,
-		rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the update of the rows of `query` that `set` gives, as `update` takes it, in the rows mode of the query. */
-function createUpdate(query, set) {
-	const { node } = query;
-	checkChangedRows(node, "update");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "update",
-		target: node.from,
-		set: toAssignments(node.from, set),
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the delete of the rows of `query`, in the rows mode of the query. */
-function createDelete(query) {
-	const { node } = query;
-	checkChangedRows(node, "delete");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "delete",
-		target: node.from,
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), query.context, query.db);
-}
-/**
-* Rejects a query whose rows `method`, `update` or `delete`, cannot change: one of a relation, with selected fields, which a mutation selects after it, with an order, a limit, or an offset, or without a filter that restricts its rows unless `all` allows it.
-*
-* A filter simplified to `TRUE`, such as `where({})`, restricts no row.
-*/
-function checkChangedRows(node, method) {
-	if (node.relation !== void 0) throw new Error(`${method} applies only to a query of a table, not of a relation`);
-	if (node.projections.length > 0) throw new Error(`${method} returns the fields selected after it, not before; call select, get, or pluck after ${method}`);
-	if (node.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, or orderBy`);
-	const predicate = combineFilters(node.filters);
-	if (!node.all && predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
-}
-// src/query/order.ts
-/** Direction and placement of `NULL` of a sort key node, by `OrderDirection`. */
-const directions = /* @__PURE__ */ Object.freeze({
-	asc: {
-		direction: "asc",
-		nulls: void 0
-	},
-	desc: {
-		direction: "desc",
-		nulls: void 0
-	},
-	"asc nulls first": {
-		direction: "asc",
-		nulls: "first"
-	},
-	"asc nulls last": {
-		direction: "asc",
-		nulls: "last"
-	},
-	"desc nulls first": {
-		direction: "desc",
-		nulls: "first"
-	},
-	"desc nulls last": {
-		direction: "desc",
-		nulls: "last"
-	}
-});
-const orderingNode = Symbol("kern-orm.ordering.node");
-/** Runtime class of an expression with a direction, which holds its sort key node. */
-var OrderingObject = class {
-	[orderingNode];
-	constructor(node) {
-		this[orderingNode] = node;
-		Object.freeze(this);
-	}
-};
-/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
-function asc(value) {
-	return orderBy(value, "asc");
-}
-/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
-function desc(value) {
-	return orderBy(value, "desc");
-}
-/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
-function orderBy(value, direction) {
-	if (!isOperandSource(value)) throw new TypeError("A sort key must be an expression or a query of one value");
-	return new OrderingObject(createOrderNode(value[operandNode](), direction));
-}
-/**
-* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
-*
-* `args` are column keys and objects of columns with directions, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one sort key or an array of them.
-*/
-function addOrder(node, context, args) {
-	const order = node.orderBy.slice();
-	const first = args[0];
-	if (typeof first === "function") {
-		const terms = first(createSelectionRefs(node.from, context), createSelectedRefs(node));
-		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
-		else order.push(readTerm(terms));
-		return order;
-	}
-	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
-	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
-		const columns = arg;
-		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
-	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
-	return order;
-}
-/**
-* Creates the sort key node of a sort key returned by the callback of `orderBy`.
-*
-* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
-*/
-function readTerm(term) {
-	if (term instanceof OrderingObject) return term[orderingNode];
-	if (isOperandSource(term)) return createOrderNode(term[operandNode](), "asc");
-	throw new TypeError("The callback of orderBy must return expressions, queries of one value, or sort keys of asc, desc, and orderBy");
-}
-/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
-function createOrderNode(expression, direction) {
-	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
-	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
-	return Object.freeze({
-		expression,
-		direction: placement.direction,
-		nulls: placement.nulls
-	});
-}
-/** Creates a reference to the column `key` of the table of `source`. */
-function createColumnNode(source, key) {
-	requireColumn(source.table, key);
-	return createNode({
-		kind: "column",
-		source,
-		key
-	});
-}
-/**
-* Creates the references of the callback of `orderBy` to the fields selected by `node`.
-*
-* Each is an expression over the node of its projection, so that a sort key of it is the projection itself.
-* A field of an aggregate or of `exists` is an expression of its query that holds the field, by which lowering finds the projection of the field.
-*/
-function createSelectedRefs(node) {
-	const { projections } = node;
-	if (node.value) return toSelectedExpression(projections[0]);
-	const refs = {};
-	for (const projection of projections) {
-		const { key } = projection;
-		if (isLiteralSelection(projection)) Object.defineProperty(refs, key, {
-			get() {
-				throw new Error(`Field "${key}" holds a literal and cannot be sorted by`);
-			},
-			enumerable: true
-		});
-		else if (isNestedSelection(projection)) {
-			if (isSelectedAsValue(projection.query)) refs[key] = toQueryExpression(projection);
-			else Object.defineProperty(refs, key, {
-				get() {
-					throw new Error(`Field "${key}" holds nested rows and cannot be sorted by`);
-				},
-				enumerable: true
-			});
-		} else refs[key] = toSelectedExpression(projection);
-	}
-	return refs;
-}
-/** Creates an expression over the node of a projection of a query, which has a type: only lowering adds projections of nested queries. */
-function toSelectedExpression(projection) {
-	return toExpression(projection.expression, projection.type);
-}
-/** Creates an expression of the value of `field`, a selected aggregate query or query of `exists`, with the type of its value. */
-function toQueryExpression(field) {
-	const { query } = field;
-	return toExpression(createNode({
-		kind: "nestedQuery",
-		query,
-		db: field.db,
-		field
-	}), query.projections[0].type);
-}
-// src/query/pagination.ts
-/** Creates the parameter of the number of rows of `limit` or `offset`, named by `method`, of query `node`, rejecting a query of one row and a count that is not a non-negative safe integer. */
-function createPageCount(node, method, count) {
-	if (node.rows !== "many") throw new Error(`${method} applies only to a query of many rows${createPaginationHint(node)}`);
-	if (!Number.isSafeInteger(count) || count < 0) throw new RangeError(`${method} takes a non-negative integer, not ${count}`);
-	return createNode({
-		kind: "param",
-		value: count,
-		type: void 0
-	});
-}
-/** Creates the hint of the error of `limit` or `offset` of query `node` of one row: the method to call them before, if any. */
-function createPaginationHint(node) {
-	if (node.relation?.kind === "one") return "";
-	if (isAggregateQuery(node)) return "; call it before count or another aggregate to aggregate the rows of a page";
-	if (isExistsQuery(node)) return "; call it before exists to check the rows of a page";
-	return "; call it before take or get";
-}
-// src/query/select.ts
-/**
-* Immutable select query of state `S`, unbound or bound to a `Db`.
-*
-* Every method returns a query of the same kind and leaves this query unchanged.
-* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
-* A bound query executes on its `Db` when awaited.
-*/
-var SelectQuery = class SelectQuery {
-	table;
-	node;
-	context;
-	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-	db;
-	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-	then;
-	constructor(table, node, context, db) {
-		this.table = table;
-		this.node = node;
-		this.context = context;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	where(filter) {
-		return this.derive(this.addFilter(filter));
-	}
-	select(...args) {
-		this.rejectValue("select");
-		return this.derive({ projections: mergeProjections(this.node.projections, this.node.from, args, this.context) });
-	}
-	clearSelect() {
-		this.rejectValue("clearSelect");
-		return this.derive({ projections: [] });
-	}
-	take() {
-		return this.deriveTaken({});
-	}
-	find(...values) {
-		return this.takeWhere(toPrimaryKeyValues(this.table, values));
-	}
-	findBy(values) {
-		return this.takeWhere(toKeyValues(this.table, values));
-	}
-	get(arg) {
-		this.rejectAggregate("get");
-		return this.deriveTaken({
-			projections: [projectValue(this.node.from, arg, "get")],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	pluck(arg) {
-		this.rejectAggregate("pluck");
-		return this.derive({
-			projections: [projectValue(this.node.from, arg, "pluck")],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	count(arg) {
-		if (arg !== void 0) return this.aggregateBy("count", arg);
-		this.rejectAggregate("count");
-		return this.deriveAggregate(countProjection);
-	}
-	countDistinct(arg) {
-		return this.aggregateBy("countDistinct", arg);
-	}
-	min(arg) {
-		return this.aggregateBy("min", arg);
-	}
-	max(arg) {
-		return this.aggregateBy("max", arg);
-	}
-	sum(arg) {
-		return this.aggregateBy("sum", arg);
-	}
-	avg(arg) {
-		return this.aggregateBy("avg", arg);
-	}
-	every(arg) {
-		return this.aggregateBy("every", arg);
-	}
-	some(arg) {
-		return this.aggregateBy("some", arg);
-	}
-	stringAgg(arg, delimiter) {
-		return this.aggregateBy("stringAgg", arg, delimiter);
-	}
-	exists() {
-		this.rejectAggregate("exists");
-		return this.deriveAggregate(getExistsProjection());
-	}
-	coalesce(fallback) {
-		const { node } = this;
-		if (!node.value) throw new Error("coalesce applies only to a query of values, such as one made by get, pluck, or an aggregate");
-		return this.derive({ projections: [coalesceValue(node.projections[0], fallback)] });
-	}
-	expr() {
-		const value = this[operandNode]();
-		return toExpression(value, this.node.projections[0].type);
-	}
-	orderBy(...args) {
-		return this.derive({ orderBy: addOrder(this.node, this.context, args) });
-	}
-	limit(count) {
-		return this.derive({ limit: createPageCount(this.node, "limit", count) });
-	}
-	offset(count) {
-		return this.derive({ offset: createPageCount(this.node, "offset", count) });
-	}
-	optional() {
-		return this.changeOneRow("optional", "optional");
-	}
-	nullable() {
-		if (this.node.value) throw new Error("nullable applies only to a query of records; use optional after get, pluck, or an aggregate");
-		return this.changeOneRow("nullable", "nullable");
-	}
-	required() {
-		return this.changeOneRow("required", "one");
-	}
-	insert(values) {
-		return createInsert(this, [values], "one", "insert");
-	}
-	insertMany(records) {
-		if (!Array.isArray(records)) throw new TypeError("insertMany takes an array of records");
-		return createInsert(this, records, "many", "insertMany");
-	}
-	update(set) {
-		return createUpdate(this, set);
-	}
-	delete() {
-		return createDelete(this);
-	}
-	all() {
-		if (this.node.rows !== "many") throw new Error("all applies only to a query of many rows");
-		return this.derive({ all: true });
-	}
-	use(callback, ...args) {
-		return requireDerived(this, callback(this, ...args), "The callback of use");
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/**
-	* Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
-	*
-	* It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
-	*/
-	[operandNode]() {
-		const { node } = this;
-		if (!node.value || node.rows === "many") throw new TypeError("An expression takes a query of one value, such as of get, an aggregate, or exists, not a query of records or of an array");
-		return createNode({
-			kind: "nestedQuery",
-			query: node,
-			db: this.db
-		});
-	}
-	/**
-	* Returns the node of the query as the values of `in`, which lowering replaces with its statement.
-	*
-	* It rejects a query of records, which `ValuesQuery` rejects in types.
-	*/
-	[valuesQueryNode]() {
-		const { node } = this;
-		if (!node.value) throw new TypeError("in takes a query of values, such as of pluck, not a query of records");
-		return createNode({
-			kind: "nestedQuery",
-			query: node,
-			db: this.db
-		});
-	}
-	/** Creates a query of the same kind and `Db` with the node changes applied. */
-	derive(changes) {
-		return new SelectQuery(this.table, Object.freeze({
-			...this.node,
-			...changes
-		}), this.context, this.db);
-	}
-	/**
-	* Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
-	*
-	* It adds the changes of `take` to `changes`, which must leave the limit as it is.
-	*/
-	deriveTaken(changes) {
-		if ((changes.rows ?? this.node.rows) === "many") {
-			changes.limit = limitToOne(this.node.limit);
-			changes.rows = "one";
-		}
-		return this.derive(changes);
-	}
-	/** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
-	deriveAggregate(projection) {
-		return this.derive({
-			projections: [projection],
-			rows: "one",
-			value: true,
-			guaranteed: false
-		});
-	}
-	/** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
-	aggregateBy(method, arg, delimiter) {
-		this.rejectAggregate(method);
-		return this.deriveAggregate(projectAggregate(method, projectValue(this.node.from, arg, method), delimiter));
-	}
-	/** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
-	addFilter(filter) {
-		const { node } = this;
-		return {
-			filters: addUserFilter(node.filters, filter, node.from, this.context),
-			rows: toFilteredRows(node.rows, node.value, node.guaranteed),
-			guaranteed: false
-		};
-	}
-	/** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
-	takeWhere(values) {
-		const changes = this.addFilter(values);
-		if (changes.rows === "many") changes.rows = "one";
-		return this.derive(changes);
-	}
-	/** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
-	changeOneRow(method, rows) {
-		if (this.node.rows === "many") throw new Error(`${method} applies only to a query of one row, such as one made by take`);
-		return this.derive({
-			rows,
-			guaranteed: false
-		});
-	}
-	/** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
-	rejectValue(method) {
-		if (!this.node.value) return;
-		this.rejectAggregate(method);
-		throw new Error(`${method} cannot be used after get or pluck; call get or pluck to replace the value`);
-	}
-	/** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
-	rejectAggregate(method) {
-		const { node } = this;
-		if (isAggregateQuery(node)) throw new Error(`${method} cannot be used after an aggregate`);
-		if (isExistsQuery(node)) throw new Error(`${method} cannot be used after exists`);
-	}
-};
-/**
-* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
-*
-* An ancestor of `query` also passes, since only the source occurrence is compared.
-*/
-function requireDerived(query, result, subject) {
-	if (!(result instanceof SelectQuery) || result.node.from !== query.node.from) throw new Error(`${subject} must return the query it receives or one derived from it`);
-	return result;
-}
-/** Binds a query to `db`, so that awaiting it executes it there. */
-function bindQuery(query, db) {
-	return new SelectQuery(query.table, query.node, query.context, db);
-}
-/** Starts a query over a new occurrence of the table. */
-function from(table) {
-	return startQuery(table, noContext);
-}
-/** Starts a query over a new occurrence of the table with the relations of `context`, such as a query of a table of a schema. */
-function startQuery(table, context) {
-	return new SelectQuery(table, createQueryNode(Object.freeze({
-		kind: "table",
-		table
-	})), context);
-}
 // src/expression/functions.ts
 function coalesce(first, ...rest) {
 	return callFunction("coalesce", first, rest);
@@ -3136,899 +54,24 @@ function toTypedExpression(value, name) {
 	if (!isExpression(expression) || getType(expression) === void 0) throw new TypeError(`The first operand of ${name} must be a query of one value of a table or an expression with a type to decode the result; build a sql fragment with a type, such as sql(t.integer)`);
 	return expression;
 }
-// src/query/relations.ts
-/** Creates the contexts of the queries of the tables under `keys` in a schema of relations `relations`, by table key. */
-function createQueryContexts(keys, relations) {
-	const contexts = Object.create(null);
-	for (const key of keys) {
-		const named = relations[key];
-		if (named === void 0) {
-			contexts[key] = noContext;
-			continue;
-		}
-		const getters = Object.create(null);
-		for (const name of Object.keys(named)) {
-			const definition = named[name];
-			getters[name] = Object.freeze({
-				get() {
-					return startRelated(this, definition, contexts[definition.targetKey]);
-				},
-				enumerable: true
-			});
-		}
-		contexts[key] = Object.freeze({ relations: Object.freeze(getters) });
-	}
-	return Object.freeze(contexts);
+// src/query/reusable-expression.ts
+function defineExpression(_table, expression) {
+	return expression;
 }
-/**
-* Starts the query of the records of relation `definition` of the row of `parent`, the references of `select`, in the context of the target table.
-*
-* The relation filter compares the key columns of the target with those of `parent` with SQL `=` directly rather than with the `eq` operators of their types, which a custom type can replace.
-*/
-function startRelated(parent, definition, context) {
-	const { target, from, to } = definition;
-	const source = Object.freeze({
-		kind: "table",
-		table: target
-	});
+// src/query/matches.ts
+function matches(columns, values) {
+	if (!isColumnValues(values)) throw new TypeError("The values of matches must be an object of column values");
 	const conditions = [];
-	for (let index = 0; index < from.length; index++) conditions.push(createNode({
-		kind: "comparison",
-		operator: "=",
-		left: createNode({
-			kind: "column",
-			source,
-			key: to[index]
-		}),
-		right: toNode(parent[from[index]])
-	}));
-	return new SelectQuery(target, createQueryNode(source, definition, Object.freeze({ relation: combineNodes("and", conditions) })), context);
-}
-// src/schema/schema.ts
-const schemaBrand = Symbol("kern-orm.schema");
-/** Key of the relation definitions of a schema, which composition reads. */
-const schemaRelations = Symbol("kern-orm.schema.relations");
-/**
-* Defines a schema of the tables of `parts`, keyed by their names in queries.
-*
-* A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
-* A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
-*/
-function defineSchema(...parts) {
-	const tables = /* @__PURE__ */ new Map();
-	const keys = /* @__PURE__ */ new Map();
-	const relations = /* @__PURE__ */ new Map();
-	for (const part of parts) {
-		const partTables = isSchema(part) ? part.$tables : part;
-		for (const key of Object.keys(partTables)) {
-			if (key.startsWith("$")) throw new Error(`Table key "${key}" must not start with "$"`);
-			const table = partTables[key];
-			const keyTable = tables.get(key);
-			if (keyTable !== void 0 && keyTable !== table) throw new Error(`Table key "${key}" refers to two different tables`);
-			const tableKey = keys.get(table);
-			if (tableKey !== void 0 && tableKey !== key) throw new Error(`Table "${table.name}" is included under two keys, "${tableKey}" and "${key}"`);
-			tables.set(key, table);
-			keys.set(table, key);
-		}
-		if (isSchema(part)) addRelations(relations, part[schemaRelations]);
-	}
-	return createSchema(Object.freeze(Object.fromEntries(tables)), keys, freezeRelations(relations));
-}
-/** Creates a schema of tables and relation definitions that are already checked; `keys` gives the key of each table. */
-function createSchema(tables, keys, relations) {
-	const methods = {
-		[schemaBrand]: true,
-		$tables: tables,
-		[schemaRelations]: relations,
-		$relations(declarations) {
-			const added = /* @__PURE__ */ new Map();
-			addRelations(added, relations);
-			for (const key of Object.keys(declarations)) {
-				if (!Object.hasOwn(tables, key)) throw new Error(`Relations are declared for table key "${key}", which is not part of the schema`);
-				const named = declarations[key];
-				if (named === void 0) continue;
-				for (const name of Object.keys(named)) addRelation(added, key, name, defineRelation(tables[key], key, name, named[name], (table) => keys.get(table)));
-			}
-			return createSchema(tables, keys, freezeRelations(added));
-		},
-		$select: (selection) => startRecordQuery(selection)
-	};
-	const contexts = createQueryContexts(Object.keys(tables), relations);
-	return defineEntries(methods, tables, (key) => startQuery(tables[key], contexts[key]));
-}
-function isSchema(part) {
-	return schemaBrand in part;
-}
-/** Adds a getter per table key to `methods` that starts a query with `start`, and freezes the result. */
-function defineEntries(methods, tables, start) {
-	const result = Object.defineProperties(methods, Object.fromEntries(Object.keys(tables).map((key) => [key, {
-		get: () => start(key),
-		enumerable: true
-	}])));
-	return Object.freeze(result);
-}
-// src/expression/sql.ts
-function sql(first, ...values) {
-	if (isTemplateStrings(first)) return createFragment(first, values, void 0);
-	if (!isType(first)) throw new TypeError("sql() accepts a type, not a column");
-	return (strings, ...values) => createFragment(strings, values, first);
-}
-/**
-* Creates a SQL fragment of a quoted name, such as of a table or a column known only at runtime, for the templates of `sql`, of `$query` and `$script` of a `Db`, and of `query` and `script` of a `Database`.
-*
-* Several names make a qualified name, such as `identifier(schema, table)` for `"schema"."table"`.
-* The fragment has no parameters, so a script takes it.
-* The name is not qualified by the PostgreSQL schema of the statement.
-*/
-function identifier(...names) {
-	let text = "";
-	for (const name of names) {
-		if (typeof name !== "string" || name === "") throw new TypeError("identifier() takes names as non-empty strings");
-		text += (text === "" ? "" : ".") + quoteIdentifier(name);
-	}
-	if (text === "") throw new TypeError("identifier() takes at least one name");
-	return toExpression(createNode({
-		kind: "raw",
-		fragments: [text],
-		values: []
-	}));
-}
-function param(type, value) {
-	if (!isType(type) && !isExpression(type)) throw new TypeError("param() accepts a type or an expression, not a column");
-	if (isExpression(type)) {
-		if (isExpression(value)) return value;
-		const valueType = getType(type);
-		return toExpression(toValueNode(value, valueType), valueType);
-	}
-	return toExpression(toCastValueNode(value, type), type);
-}
-function isTemplateStrings(value) {
-	return Array.isArray(value);
-}
-function createFragment(strings, values, type) {
-	return toExpression(toRawSqlNode(strings, values), type);
-}
-/**
-* Creates the node of the SQL of a template, whose interpolations stay structured nodes.
-*
-* An interpolated expression keeps its node, and a query of a table without clauses becomes the name of the table, qualified by the PostgreSQL schema of the statement.
-* Another query of a table becomes a query in an expression, which lowering replaces with its SQL.
-* Other values become query parameters.
-* It rejects the other queries, which a parameter would encode as text.
-*/
-function toRawSqlNode(strings, values) {
-	const nodes = [];
-	for (let index = 0; index < values.length; index++) nodes.push(toInterpolatedNode(values[index]));
-	return createNode({
-		kind: "raw",
-		fragments: [...strings],
-		values: nodes
-	});
-}
-/** Returns the node of a value interpolated into SQL, as `toRawSqlNode` takes it. */
-function toInterpolatedNode(value) {
-	if (value instanceof SelectQuery) {
-		const { node } = value;
-		return isTableQuery(node) ? createNode({
-			kind: "tableName",
-			table: value.table,
-			db: value.db
-		}) : createNode({
-			kind: "nestedQuery",
-			query: node,
-			db: value.db
-		});
-	}
-	if (value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of $select, a mutation, or a query of SQL text");
-	return toValueNode(value);
-}
-// src/execution/db.ts
-/** Binds `schema` to `database`; see `Database.bind`. */
-function bindSchema(schema, database, options = {}) {
-	const tables = new Set(Object.values(schema.$tables));
-	const relations = schema[schemaRelations];
-	const definitions = collectDefinitions(relations);
-	const { schemaName } = options;
-	const resolveSchemaName = () => typeof schemaName === "function" ? schemaName() : schemaName;
-	function compile(query) {
-		if (query.db !== void 0 && query.db !== db) throw new Error("Cannot run a query bound to another Db");
-		return compileStatement(lowerStatement(query.node, definitions, db), { schemaName: resolveSchemaName() }, tables, db);
-	}
-	const methods = {
-		$schema: schema,
-		$database: database,
-		get $schemaName() {
-			return resolveSchemaName();
-		},
-		$compile(query) {
-			const { text, parameters } = compile(query);
-			return createStatement(text, parameters);
-		},
-		async $execute(query) {
-			const compiled = compile(query);
-			return decodeStatement(compiled, await database.execute(compiled));
-		},
-		$select: (selection) => startRecordQuery(selection, db),
-		$query: (strings, ...values) => startSqlQuery(toRawSqlNode(strings, values), db),
-		async $script(script, ...values) {
-			if (typeof script === "string") return database.script(script);
-			const { text, parameters } = compile(startSqlQuery(toRawSqlNode(script, values), db));
-			if (parameters.length > 0) throw new Error("A script has no parameters, so it takes no values, also in the queries and sql fragments that it interpolates");
-			return database.script(text);
-		},
-		$transaction: (callback, options) => database.transaction(callback, options),
-		$ensureTransaction: (callback) => database.ensureTransaction(callback),
-		$isInTransaction: () => database.isInTransaction(),
-		$lock: (key) => database.lock(key)
-	};
-	const contexts = createQueryContexts(Object.keys(schema.$tables), relations);
-	const db = defineEntries(methods, schema.$tables, (key) => bindQuery(startQuery(schema.$tables[key], contexts[key]), db));
-	return db;
-}
-// src/execution/transaction.ts
-/**
-* Routes statements and scripts to the ambient transaction of the current async context or to the pool.
-*
-* This is the only place that decides which connection executes a statement.
-*/
-var TransactionCoordinator = class {
-	driver;
-	test;
-	#storage = new AsyncLocalStorage();
-	/** Open test fixtures, the innermost last. */
-	#fixtures = [];
-	/** Changes of the fixture stack, run one after another so that each one sees the stack the previous one left. */
-	#transitions = Promise.resolve();
-	/**
-	* The `close` functions of the test fixtures that are still opening, from the call that starts the opening until the fixture enters the stack or the opening ends otherwise.
-	*
-	* An opening holds the queue of the fixture stack while its seed runs, so a closing of the stack queued behind it would wait for a seed that may never settle.
-	* Closing the stack therefore calls these first: each one tells its opening to stop waiting for the seed.
-	*/
-	#openings = /* @__PURE__ */ new Set();
-	/**
-	* Outermost fixture in the stack whose closing is queued but has not finished.
-	*
-	* Openings that start after that closing is requested nest outside of the fixture once it closes, so a repeated closing of it, or a closing of a fixture nested in it, must not close them.
-	*/
-	#closing;
-	/** Closing of the database, set by the first `close`; from then on, operations outside a transaction reject. */
-	#closed;
-	constructor(driver, test = false) {
-		this.driver = driver;
-		this.test = test;
-	}
-	execute(statement) {
-		const target = this.#route("execute a query");
-		return target instanceof Error ? Promise.reject(target) : target.execute(statement);
-	}
-	/** Executes a script of statements without parameters where `execute` executes a statement. */
-	executeScript(text) {
-		const target = this.#route("execute a script");
-		return target instanceof Error ? Promise.reject(target) : target.executeScript(text);
-	}
-	/** Returns the connection of the ambient transaction or the driver of the pool that runs `operation`, or the error that rejects it. */
-	#route(operation) {
-		const level = this.#storage.getStore();
-		if (!level) {
-			if (this.#closed) return createDatabaseClosedError(operation);
-			return this.test ? new Error(describeOutsideTest(operation)) : this.driver;
-		}
-		return createUnavailableError(level, operation) ?? level.connection;
-	}
-	/**
-	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
-	*
-	* Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
-	* A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
-	*/
-	transaction(callback, options) {
-		const settings = getLevelSettings(options);
-		const parent = this.#storage.getStore();
-		if (parent) return this.#runNested(parent, callback, true, void 0, settings);
-		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a transaction"));
-		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true, void 0, settings);
-	}
-	/**
-	* Runs `callback` in the current transaction, or in a new transaction outside of one.
-	*
-	* Joining starts no savepoint, so a rejection of `callback` does not undo its changes.
-	* It rejects without calling `callback` when the current level accepts no statements, as a nested transaction would.
-	*/
-	async ensureTransaction(callback) {
-		const level = this.#storage.getStore();
-		if (!level?.inTransaction) return this.transaction(callback);
-		const unavailable = createUnavailableError(level, "join the transaction");
-		if (unavailable) throw unavailable;
-		return callback();
-	}
-	/**
-	* Tells whether the current async context runs in a transaction of `transaction`.
-	*
-	* A test transaction and the seed of a test fixture are not transactions, unless they run inside one, so that code under test behaves as in production.
-	*/
-	isInTransaction() {
-		return this.#storage.getStore()?.inTransaction ?? false;
-	}
-	/**
-	* Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
-	*
-	* Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
-	* When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
-	* Once the level ends, the transaction rejects with the reason of the signal.
-	* A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
-	* Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
-	*/
-	testTransaction(callback, { signal } = {}) {
-		if (!this.test) return Promise.reject(/* @__PURE__ */ new Error("testTransaction requires a database created with test: true"));
-		if (signal?.aborted) return Promise.reject(signal.reason);
-		const parent = this.#storage.getStore();
-		if (parent) return this.#runNested(parent, callback, false, signal);
-		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a test transaction"));
-		return this.#startTestLevel(signal).then((level) => level ? this.#runStarted(level, callback, false, signal) : this.#runRoot(callback, false, signal));
-	}
-	/**
-	* Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
-	*
-	* Test transactions started outside any transaction run in the innermost fixture.
-	* A fixture whose `seed` rejects rolls back and closes.
-	*/
-	createTestFixture(seed) {
-		return this.startTestFixture(seed).fixture;
-	}
-	/**
-	* Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
-	*
-	* Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
-	* Closing an open fixture also closes the fixtures opening in it.
-	*/
-	startTestFixture(seed) {
-		let level;
-		let closeRequested = false;
-		const closing = Promise.withResolvers();
-		let closedRejection;
-		const close = () => {
-			if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close a test fixture inside a transaction"));
-			closeRequested = true;
-			closing.resolve();
-			if (level && this.#fixtures.includes(level)) {
-				const opened = level;
-				if (this.#closing && this.#closing.depth <= opened.depth) return this.#enqueue(() => this.#closeFixture(opened));
-				this.#closing = opened;
-				return this.#closeAfterOpenings(() => this.#enqueue(async () => {
-					try {
-						await this.#closeFixture(opened);
-					} finally {
-						if (this.#closing === opened) this.#closing = void 0;
-					}
-				}));
-			}
-			return this.#enqueue(() => {
-				const rejection = closedRejection;
-				closedRejection = void 0;
-				if (rejection) throw rejection.error;
-			});
-		};
-		if (!this.test) return {
-			fixture: Promise.reject(/* @__PURE__ */ new Error("createTestFixture requires a database created with test: true")),
-			close
-		};
-		if (this.#storage.getStore()) return {
-			fixture: Promise.reject(/* @__PURE__ */ new Error("Cannot create a test fixture inside a transaction")),
-			close
-		};
-		if (this.#closed) return {
-			fixture: Promise.reject(createDatabaseClosedError("create a test fixture")),
-			close
-		};
-		/**
-		* Runs stages 2 and 3 of the fixture and puts it in the stack, returning `undefined` when closing was requested and the fixture rolled back cleanly.
-		*
-		* It rejects with a failure to start the fixture, with the rejection of `seed`, or with a failure to roll back, which suppresses the rejection of `seed`.
-		*/
-		const open = async () => {
-			if (closeRequested) return;
-			const parent = this.#fixtures.at(-1);
-			const started = parent ? await this.#startInFixture(parent) : await this.#beginFixture();
-			started.state = "open";
-			const outcome = closeRequested ? void 0 : await Promise.race([this.#seedFixture(started, seed), closing.promise]);
-			if (outcome && !outcome.rejection && !closeRequested) {
-				this.#fixtures.push(started);
-				level = started;
-				this.#openings.delete(close);
-				const { result } = outcome;
-				return {
-					get data() {
-						if (started.state !== "open") throw new Error("Test fixture is closed");
-						return result;
-					},
-					close,
-					[Symbol.asyncDispose]: close
-				};
-			}
-			const rejection = combineRejections(outcome?.rejection, { rejection: await this.#endFixture(started) });
-			if (rejection) throw rejection.error;
-		};
-		this.#openings.add(close);
-		return {
-			fixture: this.#enqueue(async () => {
-				let opened;
-				try {
-					opened = await open();
-				} catch (error) {
-					if (!closeRequested) throw error;
-					closedRejection = { error };
-				} finally {
-					this.#openings.delete(close);
-				}
-				if (!opened) throw new Error("Test fixture was closed before it opened");
-				return opened;
-			}),
-			close
-		};
-	}
-	/**
-	* Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
-	*
-	* A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
-	* A failed closing of the driver suppresses the failures of closing the fixtures.
-	* From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
-	*/
-	close() {
-		if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close the database inside a transaction"));
-		this.#closed ??= this.#close();
-		return this.#closed;
-	}
-	/** Closes the test fixtures and then the driver, see `close`. */
-	async #close() {
-		let rejection;
-		try {
-			await this.#closeAfterOpenings(() => this.#enqueue(() => {
-				const root = this.#fixtures[0];
-				return root && this.#closeFixture(root);
-			}));
-		} catch (error) {
-			rejection = { error };
-		}
-		try {
-			await this.driver.close();
-		} catch (error) {
-			rejection = suppress(error, rejection, "Closing the driver failed");
-		}
-		if (rejection) throw rejection.error;
-	}
-	/**
-	* Closes the fixtures still opening and runs `closeStack`, rejecting with the failures of all of them.
-	*
-	* A seed that never settles holds the queue of the fixture stack, so closing is requested for every opening before `closeStack` queues its change, and the rollback does not wait for the seeds.
-	*/
-	async #closeAfterOpenings(closeStack) {
-		const closings = [];
-		for (const closeOpening of this.#openings) closings.push(closeOpening());
-		closings.push(closeStack());
-		let rejection;
-		for (const closing of await Promise.allSettled(closings)) if (closing.status === "rejected") rejection = suppress(closing.reason, rejection, "Closing a test fixture failed");
-		if (rejection) throw rejection.error;
-	}
-	/**
-	* Runs `seed` in a savepoint of a fixture that is released when it resolves, returning its result or rejection.
-	*
-	* The savepoint has its own context, so late code of `seed` cannot reach the fixture after it ends.
-	*/
-	async #seedFixture(fixture, seed) {
-		try {
-			return await this.#run(await this.#startNested(fixture, false), seed, true);
-		} catch (error) {
-			return { rejection: { error } };
-		}
-	}
-	/** Closes an opened fixture as a change of the fixture stack. */
-	async #closeFixture(fixture) {
-		const index = this.#fixtures.indexOf(fixture);
-		if (index < 0) return;
-		let rejection;
-		try {
-			rejection = await this.#endFixture(fixture);
-		} finally {
-			this.#fixtures.length = index;
-		}
-		if (rejection) throw rejection.error;
-	}
-	/** Rolls back a fixture and releases the connection of the first one, returning the error to reject with. */
-	async #endFixture(fixture) {
-		const cleanup = await this.#end(fixture, false);
-		return fixture.parent ? cleanup.rejection : releaseConnection(fixture.connection, cleanup.failure, cleanup.rejection);
-	}
-	/**
-	* Starts the level of a test transaction in the innermost test fixture as a change of the fixture stack, resolving to `undefined` when no fixture is open.
-	*
-	* Aborted while it waits for its turn, it rejects at once and its change starts nothing, so that a test that has already ended never preempts the active level of the fixture.
-	* From its turn on, it settles with its change.
-	*/
-	#startTestLevel(signal) {
-		let waiting = true;
-		const start = () => this.#enqueue(() => {
-			if (signal?.aborted) return;
-			waiting = false;
-			const fixture = this.#fixtures.at(-1);
-			return fixture && this.#startInFixture(fixture, signal);
-		});
-		return signal ? settleUnlessAborted(start, signal, () => waiting) : start();
-	}
-	/** Runs a change of the fixture stack after the earlier ones. */
-	#enqueue(transition) {
-		const result = this.#transitions.then(transition);
-		this.#transitions = result.catch(() => {});
-		return result;
-	}
-	/** Starts the first test fixture: a transaction on a reserved connection. */
-	async #beginFixture() {
-		const connection = await this.driver.acquire();
-		try {
-			await connection.execute(beginStatement);
-		} catch (error) {
-			throw (await releaseConnection(connection, { error }, { error })).error;
-		}
-		return createLevel(connection, void 0, false);
-	}
-	/**
-	* Starts a nested level of a test fixture, preempting its active one.
-	*
-	* A fixture runs one nested level at a time, so a new one ends the previous one, such as a test that timed out.
-	* A level whose `signal` aborts while it preempts rejects with its reason instead of starting, and a failure to start after the abort suppresses the reason.
-	*/
-	async #startInFixture(fixture, signal) {
-		if (fixture.child) {
-			const cleanup = await this.#end(fixture.child, false, "preemption");
-			if (cleanup.rejection) throw suppressAbortReason(new Error("Cannot start a level of the test fixture: ending its active level failed", { cause: cleanup.rejection.error }), signal);
-		}
-		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
-		if (unavailable) throw suppressAbortReason(unavailable, signal);
-		signal?.throwIfAborted();
-		return this.#startNested(fixture, false, signal);
-	}
-	async #runRoot(callback, commits, signal, settings) {
-		const connection = await (signal ? acquireUnlessAborted(this.driver, signal) : this.driver.acquire());
-		if (signal?.aborted) throw (await releaseConnection(connection, void 0, { error: signal.reason })).error;
-		const level = createLevel(connection, void 0, commits);
-		let outcome;
-		try {
-			await connection.execute(beginStatement);
-		} catch (error) {
-			level.state = "closed";
-			outcome = {
-				rejection: { error: suppressAbortReason(error, signal) },
-				failure: { error }
-			};
-		}
-		if (!outcome && settings) try {
-			await applySettings(level, settings);
-		} catch (error) {
-			outcome = await getEndedOutcome(this.#end(level, false), error);
-		}
-		outcome ??= await this.#run(level, callback, commits, signal);
-		const rejection = await releaseConnection(connection, outcome.failure, outcome.rejection);
-		if (rejection) throw rejection.error;
-		return outcome.result;
-	}
-	async #runNested(parent, callback, commits, signal, settings) {
-		const unavailable = createUnavailableError(parent, "start a nested transaction");
-		if (unavailable) throw unavailable;
-		return this.#runStarted(await this.#startNested(parent, commits, signal, settings), callback, commits, signal);
-	}
-	/**
-	* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
-	*
-	* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
-	* A level whose settings fail rolls back to its savepoint first.
-	* The failure suppresses the reason of `signal` when the signal aborted before it.
-	*/
-	async #startNested(parent, transaction, signal, settings) {
-		const level = createLevel(parent.connection, parent, transaction);
-		parent.child = level;
-		try {
-			await level.connection.execute(createStatement(`SAVEPOINT ${getSavepointName(level)}`));
-		} catch (error) {
-			if (!level.cleanup) {
-				closeStarting(level);
-				throw suppressAbortReason(error, signal);
-			}
-			throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
-		}
-		if (settings) try {
-			await applySettings(level, settings);
-		} catch (error) {
-			throw suppressAbortReason(combineRejections({ error }, await this.#end(level, false)).error, signal);
-		}
-		return level;
-	}
-	/** Runs `callback` in a started level, returning its result or throwing its rejection. */
-	async #runStarted(level, callback, commits, signal) {
-		const { result, rejection } = await this.#run(level, callback, commits, signal);
-		if (rejection) throw rejection.error;
-		return result;
-	}
-	/**
-	* Runs `callback` in the context of a started `level`, then ends the level.
-	*
-	* A level that `commits` commits only when the callback resolves with no nested level running and no nested level that failed to end.
-	* When `signal` aborts, the level ends at once without waiting for the callback, and its outcome is a rejection with the reason of the signal.
-	*/
-	async #run(level, callback, commits, signal) {
-		if (level.cleanup) return getEndedOutcome(level.cleanup, createClosedError(level, void 0));
-		let result;
-		let rejection;
-		if (signal?.aborted) this.#end(level, false, "abort");
-		else {
-			level.state = "open";
-			try {
-				result = await (signal ? settleUnlessAborted(() => this.#storage.run(level, callback), signal, () => {
-					this.#end(level, false, "abort");
-					return true;
-				}) : this.#storage.run(level, callback));
-			} catch (error) {
-				rejection = { error };
-			}
-		}
-		if (level.cleanup) return getEndedOutcome(level.cleanup, level.endedBy === "abort" ? signal?.reason : createClosedError(level, rejection));
-		if (!rejection && level.child) rejection = { error: /* @__PURE__ */ new Error("Transaction was rolled back: a nested transaction was still running when its callback finished") };
-		if (!rejection && level.rollbackOnly) rejection = { error: new Error("Transaction was rolled back: a nested transaction failed to end", { cause: level.rollbackOnly.error }) };
-		const cleanup = await this.#end(level, commits && !rejection);
-		return {
-			result,
-			rejection: combineRejections(rejection, cleanup),
-			failure: cleanup.failure
-		};
-	}
-	/**
-	* Ends `level` once, whoever ends it: later calls return the cleanup already started.
-	*
-	* Statements of the level and of all levels nested in it fail from the start of the cleanup, and the nested levels end before it.
-	*/
-	#end(level, commit, endedBy) {
-		if (level.cleanup) return level.cleanup;
-		level.endedBy = endedBy;
-		level.state = "closing";
-		const nested = level.child && this.#end(level.child, false, "enclosing level");
-		level.cleanup = this.#cleanUp(level, commit, nested);
-		return level.cleanup;
-	}
-	async #cleanUp(level, commit, nested) {
-		const nestedCleanup = await nested;
-		const { parent } = level;
-		const cleanup = parent ? await endSavepoint(level, commit && !level.rollbackOnly) : await endTransaction(level.connection, commit);
-		level.state = "closed";
-		if (parent) {
-			if (parent.child === level) parent.child = void 0;
-			parent.rollbackOnly ??= cleanup.rejection;
-		}
-		return {
-			rejection: combineRejections(nestedCleanup?.rejection, cleanup),
-			failure: cleanup.failure
-		};
-	}
-};
-const beginStatement = createStatement("BEGIN");
-const commitStatement = createStatement("COMMIT");
-const rollbackStatement = createStatement("ROLLBACK");
-function createLevel(connection, parent, transaction) {
-	return {
-		connection,
-		parent,
-		depth: parent ? parent.depth + 1 : 0,
-		inTransaction: transaction || (parent?.inTransaction ?? false),
-		state: "starting",
-		child: void 0,
-		rollbackOnly: void 0,
-		cleanup: void 0,
-		endedBy: void 0,
-		restore: void 0
-	};
-}
-/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
-function getLevelSettings(options) {
-	return options?.searchPath ? [{
-		name: "search_path",
-		value: options.searchPath.map(quoteIdentifier).join(", ")
-	}] : void 0;
-}
-/**
-* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
-*
-* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
-*/
-async function applySettings(level, settings) {
-	if (level.cleanup) return;
-	if (level.parent) {
-		let text = "SELECT";
-		const names = [];
-		for (const { name } of settings) {
-			names.push(name);
-			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
-		}
-		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
-		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
-			name,
-			value: values[index]
-		})));
-		if (level.cleanup) return;
-	}
-	await level.connection.execute(createSettingStatement(settings));
-}
-/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
-function createSettingStatement(settings) {
-	let text = "SELECT";
-	const parameters = [];
-	for (const { name, value } of settings) {
-		parameters.push(name, value);
-		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
-	}
-	return createStatement(text, parameters);
-}
-/** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
-function getSavepointName(level) {
-	return `kern_${level.depth}`;
-}
-/**
-* Creates the error of `operation` on a level that rejects statements and nested levels, or returns `undefined` when it accepts them.
-*
-* A level that can only roll back keeps the failure of its nested level as the cause.
-*/
-function createUnavailableError(level, operation) {
-	if (level.state !== "open") return /* @__PURE__ */ new Error(`Cannot ${operation}: its transaction is already finished`);
-	if (level.child) return /* @__PURE__ */ new Error(`Cannot ${operation}: a nested transaction is running; await it first`);
-	if (level.rollbackOnly) return new Error(`Cannot ${operation}: a nested transaction failed to end, so the transaction can only roll back`, { cause: level.rollbackOnly.error });
-}
-/** Error message of an operation outside a test transaction on a coordinator created for tests. */
-function describeOutsideTest(operation) {
-	return `Cannot ${operation} outside a test transaction: the database was created with test: true, so wrap the test in testTransaction`;
-}
-/** Error of `operation` started outside a transaction after closing the database was requested. */
-function createDatabaseClosedError(operation) {
-	return /* @__PURE__ */ new Error(`Cannot ${operation}: the database is closed`);
-}
-/** Closes a nested level whose `SAVEPOINT` failed, freeing its parent for other statements. */
-function closeStarting(level) {
-	level.state = "closed";
-	if (level.parent?.child === level) level.parent.child = void 0;
-}
-/** Error of a level that another level ended, keeping the rejection of its callback as the cause. */
-function createClosedError(level, rejection) {
-	return new Error(level.endedBy === "preemption" ? "Transaction was rolled back: its test fixture started another level before it finished" : "Transaction was rolled back: its enclosing transaction ended first", rejection && { cause: rejection.error });
-}
-/** Error of a failure to start a test transaction, which suppresses the reason of `signal` when the signal aborted before the failure. */
-function suppressAbortReason(error, signal) {
-	return signal?.aborted ? suppress(error, { error: signal.reason }, "Starting the test transaction failed").error : error;
-}
-/** Outcome of a level that something other than its callback ended: a rejection with `error`, which a failed cleanup suppresses. */
-async function getEndedOutcome(cleanup, error) {
-	const ended = await cleanup;
-	return {
-		rejection: combineRejections({ error }, ended),
-		failure: ended.failure
-	};
-}
-/**
-* Runs `start` and settles as its promise, or rejects with the reason of `signal` when it aborts first and `abort`, called on the abort, returns `true`.
-*
-* It listens from before `start`, which may abort the signal before it returns, and stops once the promise of `start` settles, such as for the signal that `node:test` aborts after every test.
-* A later rejection of that promise stays handled, and a value it resolves with after the rejection goes to `discard`, which handles its own failures.
-*/
-function settleUnlessAborted(start, signal, abort, discard) {
-	const settled = Promise.withResolvers();
-	let abandoned = false;
-	const onAbort = () => {
-		if (abort()) {
-			abandoned = true;
-			settled.reject(signal.reason);
-		}
-	};
-	signal.addEventListener("abort", onAbort, { once: true });
-	let running;
-	try {
-		running = start();
-	} catch (error) {
-		signal.removeEventListener("abort", onAbort);
-		settled.reject(error);
-		return settled.promise;
-	}
-	running.then((value) => {
-		signal.removeEventListener("abort", onAbort);
-		if (abandoned) discard?.(value);
-		else settled.resolve(value);
-	}, (error) => {
-		signal.removeEventListener("abort", onAbort);
-		settled.reject(error);
-	});
-	return settled.promise;
-}
-/**
-* Acquires a connection for a test transaction, rejecting with the reason of `signal` when it aborts first.
-*
-* A connection acquired after the abort returns to the pool as best-effort cleanup: the test transaction has already rejected, so nothing awaits the release, and its failure is ignored.
-*/
-function acquireUnlessAborted(driver, signal) {
-	if (signal.aborted) return Promise.reject(signal.reason);
-	return settleUnlessAborted(() => driver.acquire(), signal, () => true, (connection) => {
-		Promise.resolve().then(() => connection.release()).catch(() => {});
-	});
-}
-/** Returns the connection of a transaction to the driver, keeping a failed release as a rejection that suppresses `rejection`. */
-async function releaseConnection(connection, failure, rejection) {
-	try {
-		await connection.release(failure);
-		return rejection;
-	} catch (error) {
-		return suppress(error, rejection, "Releasing the transaction connection failed");
-	}
-}
-/** Ends a transaction with `COMMIT` or `ROLLBACK`. */
-async function endTransaction(connection, commit) {
-	try {
-		const { command } = await connection.execute(commit ? commitStatement : rollbackStatement);
-		if (commit && command !== "COMMIT") return { rejection: { error: /* @__PURE__ */ new Error("Transaction was rolled back: a statement in it failed") } };
-		return {};
-	} catch (error) {
-		return {
-			rejection: { error },
-			failure: { error }
-		};
-	}
-}
-/**
-* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
-*
-* Before a release, it restores the settings that the level changed; a rollback restores them itself.
-*/
-async function endSavepoint(level, commit) {
-	const name = getSavepointName(level);
-	try {
-		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
-		else if (level.restore) await level.connection.execute(level.restore);
-		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
-		return {};
-	} catch (error) {
-		return { rejection: { error } };
+	for (const key of Object.keys(values)) {
+		const reference = columns[key];
+		const column = isExpression(reference) ? toNode(reference) : void 0;
+		if (column?.kind !== "column" || column.source.kind !== "table") throw new TypeError(`The references of matches have no column "${key}"`);
+		conditions.push(matchColumn(column.source, column.key, values[key]));
 	}
-}
-/** Rejection with the error of a cleanup, which suppresses the `earlier` rejection if there is one. */
-function combineRejections(earlier, cleanup) {
-	return cleanup.rejection ? suppress(cleanup.rejection.error, earlier, "Transaction rollback failed") : earlier;
-}
-/** Rejection with `error`, which suppresses the `earlier` rejection if there is one. */
-function suppress(error, earlier, message) {
-	return { error: earlier ? new SuppressedError(error, earlier.error, message) : error };
-}
-// src/execution/database.ts
-/** Creates a database over a driver; its transactions are shared by every schema bound to it. */
-function createDatabase({ driver, test }) {
-	const coordinator = new TransactionCoordinator(driver, test);
-	let tablelessDb;
-	const getTablelessDb = () => tablelessDb ??= bindSchema(defineSchema(), database);
-	const database = {
-		coordinator,
-		bind: (schema, options) => bindSchema(schema, database, options),
-		query: (strings, ...values) => getTablelessDb().$query(strings, ...values),
-		script: (script, ...values) => typeof script === "string" ? coordinator.executeScript(script) : getTablelessDb().$script(script, ...values),
-		execute: (statement) => coordinator.execute(statement),
-		transaction: (callback, options) => coordinator.transaction(callback, options),
-		ensureTransaction: (callback) => coordinator.ensureTransaction(callback),
-		isInTransaction: () => coordinator.isInTransaction(),
-		async lock(key) {
-			if (!coordinator.isInTransaction()) throw new Error("Cannot take an advisory lock outside a transaction, where it would end with its statement; a test transaction alone does not count");
-			await coordinator.execute(createLockStatement(key));
-		},
-		close: () => coordinator.close(),
-		[Symbol.asyncDispose]: () => coordinator.close()
-	};
-	return database;
-}
-/** Creates the statement that takes a transaction-level advisory lock on a 64-bit hash of `key`. */
-function createLockStatement(key) {
-	return createStatement("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key]);
+	return toBooleanExpression(combineNodes("and", conditions));
 }
 // src/query/helper.ts
 function defineHelper(_table, helper) {
 	return (query, ...args) => requireDerived(query, helper(query, ...args), "The callback of a helper");
 }
-export { FALSE, NotFoundError, RequiredRelationError, ResultDecodeError, TRUE, and, asc, caseWhen, coalesce, compare, createDatabase, createStatement, defineFilter, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, greatest, identifier, least, literal, many, not, one, or, orderBy, orderingOperators, param, sql, textOperators };
+export { FALSE, NotFoundError, RequiredRelationError, ResultDecodeError, TRUE, and, asc, caseWhen, coalesce, compare, createDatabase, createStatement, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, greatest, identifier, least, literal, many, matches, not, one, or, orderBy, orderingOperators, param, sql, textOperators };