kern-orm 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as falseNode, C as equalityOperators, D as createList, E as defineGenericOperator, M as oneNode, N as trueNode, O as createNode, S as Column, T as isEqualityCompatible, _ as toNode, a as stringifyJson, b as defineType, c as textOperators, d as compareNodes, f as createIsNullNode, g as toExpression, h as toBooleanExpression, j as noFilters, k as createSelectNode, l as orderingOperators, m as isExpression, n as text, p as getType, s as encodeBytea, u as compare, v as toValueNode, x as isType } from "./text-4Xs09pIf.mjs";
+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. */
@@ -33,13 +33,21 @@ function combineFilters(filters) {
 	return combineNodes("and", operands);
 }
 // src/expression/predicates.ts
-/** Converts a condition operand into a node; an object of column values stays unresolved until `where`. */
+/** 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) {
-	return isExpression(operand) ? toNode(operand) : createNode({
+	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);
 }
@@ -54,6 +62,244 @@ function combineConditions(kind, operands) {
 	for (const operand of operands) nodes.push(toConditionNode(operand));
 	return toBooleanExpression(combineNodes(kind, nodes));
 }
+// 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 {
@@ -110,9 +356,9 @@ function decodeStatement(plan, result) {
 		}
 	}
 	if (counted === "number") return count;
-	if (plan.rows !== "many") return {};
+	if (plan.rows !== "many") return createRecord(plan);
 	const records = [];
-	for (let index = 0; index < count; index++) records.push({});
+	for (let index = 0; index < count; index++) records.push(createRecord(plan));
 	return records;
 }
 /**
@@ -231,7 +477,7 @@ function decodeRow(plan, row, packed) {
 	let index = 0;
 	try {
 		if (plan.value) return packed ? decodePackedValue(fields[0], row[0]) : decodeDriverValue(fields[0], row[0]);
-		const record = {};
+		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]);
@@ -242,6 +488,16 @@ function decodeRow(plan, row, packed) {
 		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");
@@ -386,63 +642,167 @@ function toColumn(definition) {
 		hasDefault: false
 	}) : void 0;
 }
-// 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;
-}
+// src/query/resolve-values.ts
 /**
-* Returns the SQL name of the projection with `key` at `index` of its query.
+* Replaces objects of column values in a predicate with conditions on the columns of `source`.
 *
-* 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.
+* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
 */
-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;
+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.
@@ -471,9 +831,11 @@ function needsParentheses(kind, position) {
 		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";
@@ -482,6 +844,7 @@ function needsParentheses(kind, position) {
 		case "not":
 		case "comparison":
 		case "in":
+		case "inQuery":
 		case "isNull": return position !== "condition";
 		default: return kind;
 	}
@@ -534,6 +897,7 @@ function compileStatement(node, options = {}, tables, db) {
 			text: compileQuery(context, void 0, node),
 			parameters: context.parameters,
 			fields: node.projections,
+			recordTemplate: node.recordTemplate,
 			rows: node.rows,
 			value: node.value,
 			counted: void 0,
@@ -557,6 +921,7 @@ function compileStatement(node, options = {}, tables, db) {
 				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,
@@ -709,12 +1074,18 @@ function compileExpression(context, scope, node) {
 		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];
@@ -722,12 +1093,9 @@ function compileExpression(context, scope, node) {
 			return text;
 		}
 		case "tableName": return compileInterpolatedTable(context, node);
-		case "subquery": {
-			const { length } = node.query.projections;
-			if (length !== 1) throw new Error(`A scalar subquery must select one field, not ${length}`);
-			return `(${compileQuery(context, scope, node.query)})`;
-		}
+		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])}`;
@@ -737,6 +1105,12 @@ function compileExpression(context, scope, node) {
 		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");
@@ -787,7 +1161,8 @@ function visitNodes(node, deep, visit) {
 		case "param":
 		case "boolean":
 		case "tableName":
-		case "values": return;
+		case "values":
+		case "nestedQuery": return;
 		case "cast":
 		case "not":
 		case "isNull":
@@ -805,11 +1180,16 @@ function visitNodes(node, deep, visit) {
 			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":
@@ -834,170 +1214,6 @@ function visitQuery(query, visit) {
 	if (query.limit !== void 0) visitNodes(query.limit, true, visit);
 	if (query.offset !== void 0) visitNodes(query.offset, true, visit);
 }
-// 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)
-});
-/** 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 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, `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)
-		});
-		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/rows.ts
 /** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
 function getRelationRows(relation) {
@@ -1043,6 +1259,10 @@ function isTableQuery(node) {
 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");
@@ -1331,7 +1551,8 @@ function packRows(query) {
 		fields: projections,
 		rows: query.rows,
 		value: query.value,
-		guaranteedBy: query.guaranteedBy
+		guaranteedBy: query.guaranteedBy,
+		recordTemplate: query.recordTemplate
 	});
 	const projection = Object.freeze({
 		key: "rows",
@@ -1370,85 +1591,176 @@ function createRef(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, definitions, db, true);
-		case "record": return lowerRecord(node, definitions, db);
-		case "text": return node;
-		default: return lowerMutation(node, definitions, db);
+		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 mutation to its statement, 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, definitions, db) {
-	const { returning } = node;
-	const lowered = returning === void 0 ? void 0 : lowerProjections(returning, definitions, db);
-	if (lowered === returning) return node;
-	const { target, rows, value } = node;
+/** 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": return Object.freeze({
-			kind: "insert",
-			target,
-			columns: node.columns,
-			values: node.values,
-			returning: lowered,
-			rows,
-			value
-		});
-		case "update": return Object.freeze({
-			kind: "update",
-			target,
-			set: node.set,
-			filters: node.filters,
-			returning: lowered,
-			rows,
-			value
-		});
-		case "delete": return Object.freeze({
-			kind: "delete",
-			target,
-			filters: node.filters,
-			returning: lowered,
-			rows,
-			value
-		});
+		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, definitions, db, positions) {
+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;
-	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`);
-	if (isAggregateQuery(node)) return lowerAggregate(node);
-	const projections = lowerProjections(node.projections, definitions, db);
 	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
-	const page = node.offset !== void 0 && projections !== node.projections ? lowerPage(node, projections, positions, guaranteedBy) : 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: node.filters,
-		orderBy: positions && node.orderBy.length > 0 ? sortByPositions(node.orderBy, projections) : node.orderBy,
+		filters,
+		orderBy: positions && orderBy.length > 0 ? sortByPositions(orderBy, projections) : orderBy,
 		limit: node.limit,
 		offset: node.offset,
 		rows: node.rows,
 		value: node.value,
-		guaranteedBy
+		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` to a statement that evaluates its nested queries over the rows of a derived page.
+* 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 holds a SQL fragment that refers to a column of the table outside the queries nested in the fragment.
+* 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, projections, positions, guaranteedBy) {
+function lowerPage(node, queryFields, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) {
 	const { from } = node;
 	const columnKeys = /* @__PURE__ */ new Set();
 	const fields = [];
@@ -1456,7 +1768,7 @@ function lowerPage(node, projections, positions, guaranteedBy) {
 	for (let index = 0; index < projections.length; index++) {
 		const { expression } = projections[index];
 		let key;
-		if (isNestedSelection(node.projections[index])) {
+		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);
@@ -1486,8 +1798,8 @@ function lowerPage(node, projections, positions, guaranteedBy) {
 		from,
 		joins: noJoins,
 		projections: sourced,
-		filters: node.filters,
-		orderBy: node.orderBy,
+		filters,
+		orderBy,
 		limit: node.limit,
 		offset: node.offset,
 		rows: "many",
@@ -1519,17 +1831,19 @@ function lowerPage(node, projections, positions, guaranteedBy) {
 		offset: void 0,
 		rows: node.rows,
 		value: node.value,
-		guaranteedBy
+		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) {
+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 = node.filters;
-	let args = aggregate.arguments;
-	let order = field.ordered ? node.orderBy : noOrder;
+	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 = [];
@@ -1543,8 +1857,8 @@ function lowerAggregate(node) {
 			from: node.from,
 			joins: noJoins,
 			projections,
-			filters: node.filters,
-			orderBy: counted ? noOrder : node.orderBy,
+			filters,
+			orderBy: counted ? noOrder : orderBy,
 			limit: node.limit,
 			offset: node.offset,
 			rows: "many",
@@ -1571,7 +1885,7 @@ function lowerAggregate(node) {
 		arguments: args,
 		orderBy: order
 	});
-	const { fallbacks } = field;
+	const fallbacks = lowerEach(field.fallbacks, context, lowerExpression);
 	let value = call;
 	if (fallbacks.length > 0) {
 		const values = [call];
@@ -1607,12 +1921,15 @@ function refersToSource(node, source) {
 		case "param":
 		case "boolean":
 		case "values":
+		case "nestedQuery":
 		case "tableName":
 		case "subquery":
-		case "exists": return false;
+		case "exists":
+		case "textSubquery": return false;
 		case "cast":
 		case "not":
-		case "isNull": return refersToSource(node.operand, source);
+		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);
@@ -1622,40 +1939,102 @@ function refersToSource(node, 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, definitions, db) {
+function lowerRecord(node, context) {
 	return Object.freeze({
 		kind: "select",
 		from: void 0,
 		joins: noJoins,
-		projections: lowerProjections(node.projections, definitions, db),
+		projections: lowerProjections(dropLiterals(node.projections), context),
 		filters: noFilters,
 		orderBy: noOrder,
 		limit: void 0,
 		offset: void 0,
 		rows: "one",
 		value: false,
-		guaranteedBy: void 0
+		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; checks them as `lowerQuery` does.
+* 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 nested queries, it returns `selected` itself.
+* Without queries, it returns `selected` itself.
 */
-function lowerProjections(selected, definitions, db) {
+function lowerProjections(selected, context) {
 	let lowered;
 	for (let index = 0; index < selected.length; index++) {
 		const field = selected[index];
+		let projection;
 		if (isNestedSelection(field)) {
-			if (field.db !== void 0 && field.db !== db) throw new Error(db === void 0 ? `Selected field "${field.key}" is bound to a Db, so only that Db can compile the query` : `Selected field "${field.key}" is bound to another Db`);
-			lowered ??= selected.slice(0, index);
-			const query = lowerSelect(field.query, definitions, db, false);
-			lowered.push(isAggregateQuery(field.query) ? projectAggregateValue(field.key, query) : projectRows(field.key, query));
-		} else if (lowered !== void 0) lowered.push(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({
@@ -1667,508 +2046,230 @@ function projectAggregateValue(key, query) {
 		type: query.projections[0].type
 	});
 }
-// 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);
+/** 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);
 }
-/** 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);
+/**
+* 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
+		}));
 	}
-	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/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);
+	return lowered ?? orderBy;
 }
-/** Creates the references of the callback of `select` 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;
+/** 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;
 }
-// src/query/resolve-values.ts
 /**
-* Replaces objects of column values in a predicate with conditions on the columns of `source`.
+* 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.
 *
-* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
+* It returns `node` itself when it holds no query, and creates only the nodes that hold one.
 */
-function resolveValues(node, source) {
+function lowerExpression(node, context) {
 	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 "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 = [];
-			for (const operand of node.operands) operands.push(resolveValues(operand, source));
-			return combineNodes(node.kind, operands);
+			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
+			});
 		}
-		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` combined with `AND` with the user filters of `filters`. */
-function addUserFilter(filters, filter, source) {
-	const predicate = resolveValues(toConditionNode(typeof filter === "function" ? filter(createColumnRefs(source)) : filter), source);
-	const { user } = filters;
-	return Object.freeze({
-		...filters,
-		user: user ? combineNodes("and", [user, predicate]) : predicate
+/**
+* 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)
 	});
 }
-function defineFilter(_table, filter) {
-	return filter;
+/** 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);
 }
-// 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/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 `expression` in ascending order, in the callback of `orderBy`. */
-function asc(expression) {
-	return orderBy(expression, "asc");
-}
-/** Sorts by `expression` in descending order, in the callback of `orderBy`. */
-function desc(expression) {
-	return orderBy(expression, "desc");
-}
-/** Sorts by `expression` in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
-function orderBy(expression, direction) {
-	if (!isExpression(expression)) throw new TypeError("A sort key must be an expression");
-	return new OrderingObject(createOrderNode(toNode(expression), 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 and the selected fields and returns one sort key or an array of them.
-*/
-function addOrder(node, args) {
-	const order = node.orderBy.slice();
-	const first = args[0];
-	if (typeof first === "function") {
-		const terms = first(createColumnRefs(node.from), createSelectedRefs(node));
-		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
-		else order.push(readTerm(terms));
-		return order;
+/** 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);
+		}
 	}
-	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;
+	return lowered ?? items;
 }
-/** Creates the sort key node of a sort key returned by the callback of `orderBy`. */
-function readTerm(term) {
-	if (term instanceof OrderingObject) return term[orderingNode];
-	if (isExpression(term)) return createOrderNode(toNode(term), "asc");
-	throw new TypeError("The callback of orderBy must return expressions, 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
-	});
+// 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);
 }
-/**
-* 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.
-*/
-function createSelectedRefs(node) {
-	const { projections } = node;
-	if (node.value) return toSelectedExpression(projections[0]);
-	const refs = {};
-	for (const projection of projections) {
-		const { key } = projection;
-		if (isNestedSelection(projection)) Object.defineProperty(refs, key, {
-			get() {
-				throw new Error(`Field "${key}" holds a nested query and cannot be sorted by`);
-			},
-			enumerable: true
-		});
-		else refs[key] = toSelectedExpression(projection);
+/** 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);
 	}
-	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);
-}
-// 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 "";
-	return isAggregateQuery(node) ? "; call it before count or another aggregate to aggregate the rows of a page" : "; call it before take or get";
+	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/select.ts
+// src/query/record.ts
 /**
-* Immutable select query of state `S`, unbound or bound to a `Db`.
+* 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.
 *
-* 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;
+var RecordQuery = class {
 	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;
+	constructor(node, db) {
 		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);
-	}
-	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)] });
-	}
-	orderBy(...args) {
-		return this.derive({ orderBy: addOrder(this.node, 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);
 	}
-	/** 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`, an aggregate 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),
-			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. */
-	rejectAggregate(method) {
-		if (isAggregateQuery(this.node)) throw new Error(`${method} cannot be used after an aggregate`);
+	/** 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");
 	}
 };
 /**
-* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
+* Starts the query of `$select` of `selection`, an object of expressions, queries, and literals by key, bound to `db` when given.
 *
-* An ancestor of `query` also passes, since only the source occurrence is compared.
+* It reads the keys and values of `selection` when it is called.
 */
-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);
+function startRecordQuery(selection, db) {
+	const projections = [];
+	addSelection(projections, selection);
+	return new RecordQuery(Object.freeze({
+		kind: "record",
+		projections
+	}), db);
 }
 // src/query/sql-query.ts
 /**
@@ -2230,6 +2331,10 @@ var SqlQuery = class SqlQuery {
 	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({
@@ -2265,10 +2370,112 @@ function startSqlQuery(sql, db) {
 		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;
+/** 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
 /**
@@ -2374,6 +2581,10 @@ var MutationQuery = class MutationQuery {
 	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({
@@ -2449,138 +2660,481 @@ function checkChangedRows(node, method) {
 	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/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));
+// 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"
 	}
-	return result;
-}
-/** Adds the fields of `selection`, expressions and queries 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]));
+});
+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 projection of the value of `get` or `pluck`, or of the argument of an aggregate method, such as `max`, over `source`.
+* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
 *
-* `arg` is the argument of `method`: a column key, or a callback that receives the columns and returns an expression.
+* `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 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);
+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 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, or an expression.
+* Creates the sort key node of a sort key returned by the callback of `orderBy`.
 *
-* The projection of an aggregate keeps its call, which lowering builds, and adds the fallback after its earlier ones.
+* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
 */
-function coalesceValue(field, fallback) {
-	if (fallback === null || fallback === void 0) throw new TypeError(`coalesce takes a value other than ${String(fallback)}`);
-	const value = toValueNode(fallback, field.type);
-	if (isAggregateProjection(field)) return addFallback(field, 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({
-		key: field.key,
-		expression: createList("coalesce(", [field.expression, value], ")"),
-		type: field.type
+		expression,
+		direction: placement.direction,
+		nulls: placement.nulls
 	});
 }
-/** Creates the field of a value of a selection under `key`: an expression with a type, or a query whose rows become its value. */
-function selectValue(key, value) {
-	if (value instanceof SelectQuery) return Object.freeze({
-		key,
-		query: value.node,
-		db: value.db
+/** 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
 	});
-	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 or a query`);
-	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 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 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
+/** 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
 	});
 }
-/** 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);
+/** 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/record.ts
+// src/query/select.ts
 /**
-* Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and the results of independent queries, selected in one statement.
+* 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 RecordQuery = class {
+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(node, db) {
+	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`);
+	}
 };
 /**
-* Starts the query of `$select` of `selection`, an object of expressions and queries by key, bound to `db` when given.
+* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
 *
-* It reads the keys and values of `selection` when it is called.
+* An ancestor of `query` also passes, since only the source occurrence is compared.
 */
-function startRecordQuery(selection, db) {
-	const projections = [];
-	addSelection(projections, selection);
-	return new RecordQuery(Object.freeze({
-		kind: "record",
-		projections
-	}), db);
+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);
+}
+function greatest(first, ...rest) {
+	return callFunction("greatest", first, rest);
+}
+function least(first, ...rest) {
+	return callFunction("least", first, rest);
+}
+function caseWhen(type, branches, otherwise) {
+	if (!isType(type)) throw new TypeError("caseWhen() accepts a type, not a column");
+	if (branches.length === 0) return toExpression(toCastValueNode(otherwise === void 0 ? null : otherwise, type), type);
+	const fragments = [];
+	const values = [];
+	for (const branch of branches) {
+		fragments.push(values.length === 0 ? "CASE WHEN " : " WHEN ", " THEN ");
+		values.push(toCaseConditionNode(branch[0]), toCastValueNode(branch[1], type));
+	}
+	if (otherwise !== void 0) {
+		fragments.push(" ELSE ");
+		values.push(toCastValueNode(otherwise, type));
+	}
+	fragments.push(" END");
+	return toExpression(createNode({
+		kind: "raw",
+		fragments,
+		values
+	}), type);
+}
+/** Converts a condition of `caseWhen` into a node, rejecting a value other than an expression or a query, such as an object of column values, which has no table here. */
+function toCaseConditionNode(condition) {
+	if (!isOperandSource(condition)) throw new TypeError("A condition of caseWhen must be an expression or a query of one value");
+	return condition[operandNode]();
+}
+/** Creates the expression of the call of the SQL function `name`, of the type of its first operand. */
+function callFunction(name, first, rest) {
+	const expression = toTypedExpression(first, name);
+	const type = getType(expression);
+	const operands = [toNode(expression)];
+	for (const value of rest) operands.push(toFunctionOperandNode(value, type, name));
+	return toExpression(createList(`${name}(`, operands, ")"), type);
+}
+/** Converts the first operand of the function `name` into an expression with a type, rejecting any other value. */
+function toTypedExpression(value, name) {
+	const expression = value instanceof SelectQuery ? value.expr() : value;
+	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. */
@@ -2699,6 +3253,26 @@ function sql(first, ...values) {
 	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)) {
@@ -2706,12 +3280,7 @@ function param(type, value) {
 		const valueType = getType(type);
 		return toExpression(toValueNode(value, valueType), valueType);
 	}
-	const node = toValueNode(value, type);
-	return toExpression(node.kind === "param" ? createNode({
-		kind: "cast",
-		operand: node,
-		type
-	}) : node, type);
+	return toExpression(toCastValueNode(value, type), type);
 }
 function isTemplateStrings(value) {
 	return Array.isArray(value);
@@ -2720,9 +3289,12 @@ function createFragment(strings, values, type) {
 	return toExpression(toRawSqlNode(strings, values), type);
 }
 /**
-* Creates the node of the SQL of a template: interpolated expressions keep their nodes, a query of a table without clauses becomes the name of the table, qualified by the PostgreSQL schema of the statement, and other values become query parameters.
+* Creates the node of the SQL of a template, whose interpolations stay structured nodes.
 *
-* It rejects other queries, which a parameter would encode as text.
+* 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 = [];
@@ -2736,14 +3308,18 @@ function toRawSqlNode(strings, values) {
 /** Returns the node of a value interpolated into SQL, as `toRawSqlNode` takes it. */
 function toInterpolatedNode(value) {
 	if (value instanceof SelectQuery) {
-		if (!isTableQuery(value.node)) throw new TypeError("sql takes a query of a table without clauses, such as db.form, as the name of the table, not a query with clauses");
-		return createNode({
+		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 without clauses, such as db.form, as the name of the table, not another query");
+	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
@@ -2777,10 +3353,13 @@ function bindSchema(schema, database, options = {}) {
 		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 takes no values, since it has no parameters; interpolate only tables and sql fragments without values");
+			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)
+		$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));
@@ -2851,6 +3430,27 @@ var TransactionCoordinator = class {
 		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.
@@ -3017,7 +3617,7 @@ var TransactionCoordinator = class {
 	*/
 	async #seedFixture(fixture, seed) {
 		try {
-			return await this.#run(await this.#startNested(fixture), seed, true);
+			return await this.#run(await this.#startNested(fixture, false), seed, true);
 		} catch (error) {
 			return { rejection: { error } };
 		}
@@ -3069,7 +3669,7 @@ var TransactionCoordinator = class {
 		} catch (error) {
 			throw (await releaseConnection(connection, { error }, { error })).error;
 		}
-		return createLevel(connection, void 0);
+		return createLevel(connection, void 0, false);
 	}
 	/**
 	* Starts a nested level of a test fixture, preempting its active one.
@@ -3085,12 +3685,12 @@ var TransactionCoordinator = class {
 		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
 		if (unavailable) throw suppressAbortReason(unavailable, signal);
 		signal?.throwIfAborted();
-		return this.#startNested(fixture, signal);
+		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);
+		const level = createLevel(connection, void 0, commits);
 		let outcome;
 		try {
 			await connection.execute(beginStatement);
@@ -3114,16 +3714,17 @@ var TransactionCoordinator = class {
 	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, signal, settings), callback, commits, signal);
+		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, signal, settings) {
-		const level = createLevel(parent.connection, parent);
+	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)}`));
@@ -3210,11 +3811,12 @@ var TransactionCoordinator = class {
 const beginStatement = createStatement("BEGIN");
 const commitStatement = createStatement("COMMIT");
 const rollbackStatement = createStatement("ROLLBACK");
-function createLevel(connection, parent) {
+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,
@@ -3410,13 +4012,23 @@ function createDatabase({ driver, test }) {
 		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]);
+}
 // src/query/helper.ts
 function defineHelper(_table, helper) {
 	return (query, ...args) => requireDerived(query, helper(query, ...args), "The callback of a helper");
 }
-export { NotFoundError, RequiredRelationError, ResultDecodeError, and, asc, compare, createDatabase, createStatement, defineFilter, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, many, not, one, or, orderBy, orderingOperators, param, sql, textOperators };
+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 };