kern-orm 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { A as createList, C as isType, D as isEqualityCompatible, F as oneNode, I as trueNode, M as createSelectNode, N as falseNode, O as valuesQueryNode, P as noFilters, S as defineType, T as equalityOperators, _ as toBooleanExpression, a as stringifyJson, b as toValueNode, c as textOperators, d as compareNodes, f as createIsNullNode, g as operandNode, h as isOperandSource, j as createNode, k as defineGenericOperator, l as orderingOperators, m as isExpression, n as text, p as getType, s as encodeBytea, u as compare, v as toExpression, w as Column, x as getBooleanType, y as toNode } from "./text-BUNl8wpl.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,14 +33,21 @@ function combineFilters(filters) {
 	return combineNodes("and", operands);
 }
 // src/expression/predicates.ts
-/** Converts a condition operand into a node: a query nests in it, and an object of column values stays unresolved until `where`. */
+/** Converts a condition operand into a node: a query nests in it, and an object of column values stays unresolved until `where`; it rejects any other value. */
 function toConditionNode(operand) {
 	if (isOperandSource(operand)) return operand[operandNode]();
+	if (!isColumnValues(operand)) throw new TypeError("A condition must be an expression, such as TRUE or FALSE, a query of one Boolean value, or an object of column values");
 	return createNode({
 		kind: "values",
 		values: operand
 	});
 }
+/** Tells whether `value` can be an object of column values: a plain object, of this or another realm, or an object that has keys. */
+function isColumnValues(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.getPrototypeOf(prototype) === null || Object.keys(value).length > 0;
+}
 function and(...operands) {
 	return combineConditions("and", operands);
 }
@@ -55,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 {
@@ -111,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;
 }
 /**
@@ -232,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]);
@@ -243,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");
@@ -387,40 +642,144 @@ 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("\"", "\"\"")}"`;
-}
+// src/query/resolve-values.ts
 /**
-* Returns the longest prefix of `name` that takes at most `maxBytes` bytes in any server encoding.
+* Replaces objects of column values in a predicate with conditions on the columns of `source`.
 *
-* Every server encoding takes one byte for an ASCII character, and a character other than ASCII counts as the most bytes it can take.
+* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
 */
-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;
-}
-/**
+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.
@@ -538,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,
@@ -561,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,
@@ -853,237 +1214,54 @@ 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/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()
+// src/query/rows.ts
+/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
+function getRelationRows(relation) {
+	if (relation.kind === "many") return "many";
+	return relation.required ? "one" : "nullable";
+}
+/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
+function toFilteredRows(rows, value, guaranteed) {
+	if (!guaranteed || rows !== "one") return rows;
+	return value ? "optional" : "nullable";
+}
+/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
+function limitToOne(limit) {
+	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
+}
+/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
+function toValueRows(rows) {
+	return rows === "nullable" ? "optional" : rows;
+}
+// src/query/node.ts
+/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
+function createQueryNode(from, relation, filters = noFilters) {
+	return Object.freeze({
+		kind: "query",
+		from,
+		relation,
+		projections: [],
+		filters,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		rows: relation === void 0 ? "many" : getRelationRows(relation),
+		value: false,
+		guaranteed: relation?.required ?? false,
+		all: false
 	});
-	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 `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, order, limit, offset, rows other than `many`, or `all`. */
+function isTableQuery(node) {
+	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && node.rows === "many" && !node.all;
 }
-/** Tells whether a selected field is the projection of `exists`, which only `exists` selects. */
-function isExistsProjection(field) {
-	return field === existsProjection;
+/** Tells whether a selected field is the rows of a nested query. */
+function isNestedSelection(node) {
+	return "query" in node;
 }
-// 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/rows.ts
-/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
-function getRelationRows(relation) {
-	if (relation.kind === "many") return "many";
-	return relation.required ? "one" : "nullable";
-}
-/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
-function toFilteredRows(rows, value, guaranteed) {
-	if (!guaranteed || rows !== "one") return rows;
-	return value ? "optional" : "nullable";
-}
-/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
-function limitToOne(limit) {
-	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
-}
-/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
-function toValueRows(rows) {
-	return rows === "nullable" ? "optional" : rows;
-}
-// src/query/node.ts
-/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
-function createQueryNode(from, relation, filters = noFilters) {
-	return Object.freeze({
-		kind: "query",
-		from,
-		relation,
-		projections: [],
-		filters,
-		orderBy: [],
-		limit: void 0,
-		offset: void 0,
-		rows: relation === void 0 ? "many" : getRelationRows(relation),
-		value: false,
-		guaranteed: relation?.required ?? false,
-		all: false
-	});
-}
-/** Tells whether `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, order, limit, offset, rows other than `many`, or `all`. */
-function isTableQuery(node) {
-	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && node.rows === "many" && !node.all;
-}
-/** Tells whether a selected field is the rows of a nested query. */
-function isNestedSelection(node) {
-	return "query" in node;
+/** Tells whether a selected field is a literal. */
+function isLiteralSelection(node) {
+	return "literal" in node;
 }
 // src/schema/relation.ts
 /** Runtime mark of the declarations of `many` and `one`. */
@@ -1373,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",
@@ -1440,7 +1619,8 @@ function lowerText(node, context) {
 /** 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 lowered = returning === void 0 ? void 0 : lowerProjections(returning, context);
+	const recordTemplate = returning === void 0 ? void 0 : createRecordTemplate(returning);
+	const lowered = returning === void 0 ? void 0 : lowerProjections(dropLiterals(returning), context);
 	switch (node.kind) {
 		case "insert": {
 			const values = lowerEach(node.values, context, lowerRow);
@@ -1451,6 +1631,7 @@ function lowerMutation(node, context) {
 				columns: node.columns,
 				values,
 				returning: lowered,
+				recordTemplate,
 				rows,
 				value
 			});
@@ -1465,6 +1646,7 @@ function lowerMutation(node, context) {
 				set,
 				filters,
 				returning: lowered,
+				recordTemplate,
 				rows,
 				value
 			});
@@ -1477,6 +1659,7 @@ function lowerMutation(node, context) {
 				target,
 				filters,
 				returning: lowered,
+				recordTemplate,
 				rows,
 				value
 			});
@@ -1503,13 +1686,14 @@ function lowerSelect(node, context, positions) {
 	if (isExistsQuery(node)) return selectExists(node, context);
 	checkRelation(node, context);
 	if (isAggregateQuery(node)) return lowerAggregate(node, context);
-	const selected = node.projections;
+	const recordTemplate = createRecordTemplate(node.projections);
+	const selected = dropLiterals(node.projections);
 	const projections = lowerProjections(selected, context);
 	const filters = lowerFilters(node.filters, context);
 	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
 	const { relation } = node;
 	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
-	const page = node.offset !== void 0 && selected.some((field, index) => isPagedField(field, projections[index], orderBy)) ? lowerPage(node, projections, filters, orderBy, 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",
@@ -1522,9 +1706,27 @@ function lowerSelect(node, context, positions) {
 		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.
 *
@@ -1547,6 +1749,7 @@ function checkDb(db, context, subject) {
 }
 /**
 * Lowers `node` with `projections`, `filters`, and `orderBy`, the lowered parts of the node, to a statement that evaluates its nested queries, apart from those that it sorts by, over the rows of a derived page.
+* `queryFields` are the fields of the query without literals, and `projections` their lowered projections in the same order.
 * The derived source applies the filters, the order, the limit, and the offset, and replaces the occurrence of the table.
 *
 * It returns `undefined` when a nested query that it evaluates over the rows of the page holds a SQL fragment that refers to a column of the table outside the queries nested in the fragment.
@@ -1557,7 +1760,7 @@ function checkDb(db, context, subject) {
 * 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, filters, orderBy, positions, guaranteedBy) {
+function lowerPage(node, queryFields, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) {
 	const { from } = node;
 	const columnKeys = /* @__PURE__ */ new Set();
 	const fields = [];
@@ -1565,7 +1768,7 @@ function lowerPage(node, projections, filters, orderBy, positions, guaranteedBy)
 	for (let index = 0; index < projections.length; index++) {
 		const { expression } = projections[index];
 		let key;
-		if (isPagedField(node.projections[index], projections[index], orderBy)) {
+		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);
@@ -1628,7 +1831,8 @@ function lowerPage(node, projections, filters, orderBy, 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. */
@@ -1785,14 +1989,15 @@ function lowerRecord(node, context) {
 		kind: "select",
 		from: void 0,
 		joins: noJoins,
-		projections: lowerProjections(node.projections, context),
+		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)
 	});
 }
 /**
@@ -2026,550 +2231,45 @@ function compileToSQL(query, options) {
 	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);
-}
-/** 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/query/resolve-values.ts
+// src/query/record.ts
 /**
-* Replaces objects of column values in a predicate with conditions on the columns of `source`.
+* 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.
 *
-* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
+* 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.
 */
-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;
+var RecordQuery = class {
+	node;
+	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+	db;
+	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+	then;
+	constructor(node, db) {
+		this.node = node;
+		this.db = db;
+		this.then = db === void 0 ? void 0 : executeOnAwait;
+		Object.freeze(this);
 	}
-}
-/** 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
+	toSQL(options) {
+		return compileToSQL(this, options);
+	}
+	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+	[operandNode]() {
+		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of $select");
+	}
+};
 /**
-* 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.
+* Starts the query of `$select` of `selection`, an object of expressions, queries, and literals by key, bound to `db` when given.
 *
-* It rejects a table without a primary key, a number of values other than the number of its columns, and `null` and `undefined`.
+* It reads the keys and values of `selection` when it is called.
 */
-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 `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
-function asc(value) {
-	return orderBy(value, "asc");
-}
-/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
-function desc(value) {
-	return orderBy(value, "desc");
-}
-/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
-function orderBy(value, direction) {
-	if (!isOperandSource(value)) throw new TypeError("A sort key must be an expression or a query of one value");
-	return new OrderingObject(createOrderNode(value[operandNode](), direction));
-}
-/**
-* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
-*
-* `args` are column keys and objects of columns with directions, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one sort key or an array of them.
-*/
-function addOrder(node, context, args) {
-	const order = node.orderBy.slice();
-	const first = args[0];
-	if (typeof first === "function") {
-		const terms = first(createSelectionRefs(node.from, context), createSelectedRefs(node));
-		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
-		else order.push(readTerm(terms));
-		return order;
-	}
-	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
-	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
-		const columns = arg;
-		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
-	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
-	return order;
-}
-/**
-* Creates the sort key node of a sort key returned by the callback of `orderBy`.
-*
-* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
-*/
-function readTerm(term) {
-	if (term instanceof OrderingObject) return term[orderingNode];
-	if (isOperandSource(term)) return createOrderNode(term[operandNode](), "asc");
-	throw new TypeError("The callback of orderBy must return expressions, queries of one value, or sort keys of asc, desc, and orderBy");
-}
-/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
-function createOrderNode(expression, direction) {
-	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
-	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
-	return Object.freeze({
-		expression,
-		direction: placement.direction,
-		nulls: placement.nulls
-	});
-}
-/** Creates a reference to the column `key` of the table of `source`. */
-function createColumnNode(source, key) {
-	requireColumn(source.table, key);
-	return createNode({
-		kind: "column",
-		source,
-		key
-	});
-}
-/**
-* Creates the references of the callback of `orderBy` to the fields selected by `node`.
-*
-* Each is an expression over the node of its projection, so that a sort key of it is the projection itself.
-* A field of an aggregate or of `exists` is an expression of its query that holds the field, by which lowering finds the projection of the field.
-*/
-function createSelectedRefs(node) {
-	const { projections } = node;
-	if (node.value) return toSelectedExpression(projections[0]);
-	const refs = {};
-	for (const projection of projections) {
-		const { key } = projection;
-		if (isNestedSelection(projection)) {
-			if (isSelectedAsValue(projection.query)) refs[key] = toQueryExpression(projection);
-			else Object.defineProperty(refs, key, {
-				get() {
-					throw new Error(`Field "${key}" holds nested rows and cannot be sorted by`);
-				},
-				enumerable: true
-			});
-		} else refs[key] = toSelectedExpression(projection);
-	}
-	return refs;
-}
-/** Creates an expression over the node of a projection of a query, which has a type: only lowering adds projections of nested queries. */
-function toSelectedExpression(projection) {
-	return toExpression(projection.expression, projection.type);
-}
-/** Creates an expression of the value of `field`, a selected aggregate query or query of `exists`, with the type of its value. */
-function toQueryExpression(field) {
-	const { query } = field;
-	return toExpression(createNode({
-		kind: "nestedQuery",
-		query,
-		db: field.db,
-		field
-	}), query.projections[0].type);
-}
-// src/query/pagination.ts
-/** Creates the parameter of the number of rows of `limit` or `offset`, named by `method`, of query `node`, rejecting a query of one row and a count that is not a non-negative safe integer. */
-function createPageCount(node, method, count) {
-	if (node.rows !== "many") throw new Error(`${method} applies only to a query of many rows${createPaginationHint(node)}`);
-	if (!Number.isSafeInteger(count) || count < 0) throw new RangeError(`${method} takes a non-negative integer, not ${count}`);
-	return createNode({
-		kind: "param",
-		value: count,
-		type: void 0
-	});
-}
-/** Creates the hint of the error of `limit` or `offset` of query `node` of one row: the method to call them before, if any. */
-function createPaginationHint(node) {
-	if (node.relation?.kind === "one") return "";
-	if (isAggregateQuery(node)) return "; call it before count or another aggregate to aggregate the rows of a page";
-	if (isExistsQuery(node)) return "; call it before exists to check the rows of a page";
-	return "; call it before take or get";
-}
-// src/query/select.ts
-/**
-* Immutable select query of state `S`, unbound or bound to a `Db`.
-*
-* Every method returns a query of the same kind and leaves this query unchanged.
-* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
-* A bound query executes on its `Db` when awaited.
-*/
-var SelectQuery = class SelectQuery {
-	table;
-	node;
-	context;
-	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-	db;
-	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-	then;
-	constructor(table, node, context, db) {
-		this.table = table;
-		this.node = node;
-		this.context = context;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	where(filter) {
-		return this.derive(this.addFilter(filter));
-	}
-	select(...args) {
-		this.rejectValue("select");
-		return this.derive({ projections: mergeProjections(this.node.projections, this.node.from, args, this.context) });
-	}
-	clearSelect() {
-		this.rejectValue("clearSelect");
-		return this.derive({ projections: [] });
-	}
-	take() {
-		return this.deriveTaken({});
-	}
-	find(...values) {
-		return this.takeWhere(toPrimaryKeyValues(this.table, values));
-	}
-	findBy(values) {
-		return this.takeWhere(toKeyValues(this.table, values));
-	}
-	get(arg) {
-		this.rejectAggregate("get");
-		return this.deriveTaken({
-			projections: [projectValue(this.node.from, arg, "get")],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	pluck(arg) {
-		this.rejectAggregate("pluck");
-		return this.derive({
-			projections: [projectValue(this.node.from, arg, "pluck")],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	count(arg) {
-		if (arg !== void 0) return this.aggregateBy("count", arg);
-		this.rejectAggregate("count");
-		return this.deriveAggregate(countProjection);
-	}
-	countDistinct(arg) {
-		return this.aggregateBy("countDistinct", arg);
-	}
-	min(arg) {
-		return this.aggregateBy("min", arg);
-	}
-	max(arg) {
-		return this.aggregateBy("max", arg);
-	}
-	sum(arg) {
-		return this.aggregateBy("sum", arg);
-	}
-	avg(arg) {
-		return this.aggregateBy("avg", arg);
-	}
-	every(arg) {
-		return this.aggregateBy("every", arg);
-	}
-	some(arg) {
-		return this.aggregateBy("some", arg);
-	}
-	stringAgg(arg, delimiter) {
-		return this.aggregateBy("stringAgg", arg, delimiter);
-	}
-	exists() {
-		this.rejectAggregate("exists");
-		return this.deriveAggregate(getExistsProjection());
-	}
-	coalesce(fallback) {
-		const { node } = this;
-		if (!node.value) throw new Error("coalesce applies only to a query of values, such as one made by get, pluck, or an aggregate");
-		return this.derive({ projections: [coalesceValue(node.projections[0], fallback)] });
-	}
-	expr() {
-		const value = this[operandNode]();
-		return toExpression(value, this.node.projections[0].type);
-	}
-	orderBy(...args) {
-		return this.derive({ orderBy: addOrder(this.node, this.context, args) });
-	}
-	limit(count) {
-		return this.derive({ limit: createPageCount(this.node, "limit", count) });
-	}
-	offset(count) {
-		return this.derive({ offset: createPageCount(this.node, "offset", count) });
-	}
-	optional() {
-		return this.changeOneRow("optional", "optional");
-	}
-	nullable() {
-		if (this.node.value) throw new Error("nullable applies only to a query of records; use optional after get, pluck, or an aggregate");
-		return this.changeOneRow("nullable", "nullable");
-	}
-	required() {
-		return this.changeOneRow("required", "one");
-	}
-	insert(values) {
-		return createInsert(this, [values], "one", "insert");
-	}
-	insertMany(records) {
-		if (!Array.isArray(records)) throw new TypeError("insertMany takes an array of records");
-		return createInsert(this, records, "many", "insertMany");
-	}
-	update(set) {
-		return createUpdate(this, set);
-	}
-	delete() {
-		return createDelete(this);
-	}
-	all() {
-		if (this.node.rows !== "many") throw new Error("all applies only to a query of many rows");
-		return this.derive({ all: true });
-	}
-	use(callback, ...args) {
-		return requireDerived(this, callback(this, ...args), "The callback of use");
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/**
-	* Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
-	*
-	* It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
-	*/
-	[operandNode]() {
-		const { node } = this;
-		if (!node.value || node.rows === "many") throw new TypeError("An expression takes a query of one value, such as of get, an aggregate, or exists, not a query of records or of an array");
-		return createNode({
-			kind: "nestedQuery",
-			query: node,
-			db: this.db
-		});
-	}
-	/**
-	* Returns the node of the query as the values of `in`, which lowering replaces with its statement.
-	*
-	* It rejects a query of records, which `ValuesQuery` rejects in types.
-	*/
-	[valuesQueryNode]() {
-		const { node } = this;
-		if (!node.value) throw new TypeError("in takes a query of values, such as of pluck, not a query of records");
-		return createNode({
-			kind: "nestedQuery",
-			query: node,
-			db: this.db
-		});
-	}
-	/** Creates a query of the same kind and `Db` with the node changes applied. */
-	derive(changes) {
-		return new SelectQuery(this.table, Object.freeze({
-			...this.node,
-			...changes
-		}), this.context, this.db);
-	}
-	/**
-	* Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
-	*
-	* It adds the changes of `take` to `changes`, which must leave the limit as it is.
-	*/
-	deriveTaken(changes) {
-		if ((changes.rows ?? this.node.rows) === "many") {
-			changes.limit = limitToOne(this.node.limit);
-			changes.rows = "one";
-		}
-		return this.derive(changes);
-	}
-	/** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
-	deriveAggregate(projection) {
-		return this.derive({
-			projections: [projection],
-			rows: "one",
-			value: true,
-			guaranteed: false
-		});
-	}
-	/** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
-	aggregateBy(method, arg, delimiter) {
-		this.rejectAggregate(method);
-		return this.deriveAggregate(projectAggregate(method, projectValue(this.node.from, arg, method), delimiter));
-	}
-	/** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
-	addFilter(filter) {
-		const { node } = this;
-		return {
-			filters: addUserFilter(node.filters, filter, node.from, this.context),
-			rows: toFilteredRows(node.rows, node.value, node.guaranteed),
-			guaranteed: false
-		};
-	}
-	/** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
-	takeWhere(values) {
-		const changes = this.addFilter(values);
-		if (changes.rows === "many") changes.rows = "one";
-		return this.derive(changes);
-	}
-	/** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
-	changeOneRow(method, rows) {
-		if (this.node.rows === "many") throw new Error(`${method} applies only to a query of one row, such as one made by take`);
-		return this.derive({
-			rows,
-			guaranteed: false
-		});
-	}
-	/** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
-	rejectValue(method) {
-		if (!this.node.value) return;
-		this.rejectAggregate(method);
-		throw new Error(`${method} cannot be used after get or pluck; call get or pluck to replace the value`);
-	}
-	/** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
-	rejectAggregate(method) {
-		const { node } = this;
-		if (isAggregateQuery(node)) throw new Error(`${method} cannot be used after an aggregate`);
-		if (isExistsQuery(node)) throw new Error(`${method} cannot be used after exists`);
-	}
-};
-/**
-* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
-*
-* An ancestor of `query` also passes, since only the source occurrence is compared.
-*/
-function requireDerived(query, result, subject) {
-	if (!(result instanceof SelectQuery) || result.node.from !== query.node.from) throw new Error(`${subject} must return the query it receives or one derived from it`);
-	return result;
-}
-/** Binds a query to `db`, so that awaiting it executes it there. */
-function bindQuery(query, db) {
-	return new SelectQuery(query.table, query.node, query.context, db);
-}
-/** Starts a query over a new occurrence of the table. */
-function from(table) {
-	return startQuery(table, noContext);
-}
-/** Starts a query over a new occurrence of the table with the relations of `context`, such as a query of a table of a schema. */
-function startQuery(table, context) {
-	return new SelectQuery(table, createQueryNode(Object.freeze({
-		kind: "table",
-		table
-	})), context);
+function startRecordQuery(selection, db) {
+	const projections = [];
+	addSelection(projections, selection);
+	return new RecordQuery(Object.freeze({
+		kind: "record",
+		projections
+	}), db);
 }
 // src/query/sql-query.ts
 /**
@@ -2675,6 +2375,108 @@ function requireType(value, what) {
 	if (!isType(value)) throw new TypeError(`${what} takes a type, such as t.integer, not a column or another value`);
 	return value;
 }
+// src/query/projections.ts
+/**
+* Creates the fields of `select` over `source`, appending new keys and replacing existing ones in place.
+*
+* `args` are the arguments of `select`: `"*"`, column keys, or a callback that receives the references of `source` with the relations of `context` and returns a selection.
+*/
+function mergeProjections(projections, source, args, context) {
+	const result = projections.slice();
+	const first = args[0];
+	if (typeof first === "function") addSelection(result, first(createSelectionRefs(source, context)));
+	else {
+		const keys = first === "*" ? Object.keys(source.table.columns) : args;
+		for (const key of keys) setProjection(result, projectColumn(source, key));
+	}
+	return result;
+}
+/** Adds the fields of `selection`, expressions, queries, and literals by key, to `projections`, replacing existing keys in place. */
+function addSelection(projections, selection) {
+	for (const key of Reflect.ownKeys(selection)) {
+		if (typeof key === "symbol") throw new TypeError("A selected field must have a string key");
+		setProjection(projections, selectValue(key, selection[key]));
+	}
+}
+/**
+* Creates the projection of the value of `get` or `pluck`, or of the argument of an aggregate method, such as `max`, over `source`.
+*
+* `arg` is the argument of `method`: a column key, or a callback that receives the columns and returns an expression.
+*/
+function projectValue(source, arg, method) {
+	if (typeof arg !== "function") return projectColumn(source, arg);
+	const value = arg(createColumnRefs(source));
+	if (!isExpression(value)) throw new TypeError(`The callback of ${method} must return an expression`);
+	const type = getType(value);
+	if (!type) throw new TypeError(`The expression of ${method} has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
+	return projectExpression("value", value, type);
+}
+/**
+* Creates the projection of the value of `field`, the only projection of a query of values, whose `NULL` `fallback` replaces: a value that the type of the field encodes, an expression, or a query of one value.
+*
+* The projection of an aggregate keeps its call, which lowering builds, and adds the fallback after its earlier ones.
+* The projection of `exists` stays as it is, since `EXISTS` is never `NULL`.
+*/
+function coalesceValue(field, fallback) {
+	const value = toFunctionOperandNode(fallback, field.type, "coalesce");
+	if (isExistsProjection(field)) return field;
+	if (isAggregateProjection(field)) return addFallback(field, value);
+	return Object.freeze({
+		key: field.key,
+		expression: createList("coalesce(", [field.expression, value], ")"),
+		type: field.type
+	});
+}
+/** Creates the field of a value of a selection under `key`: an expression with a type, a query whose rows become its value, or a literal. */
+function selectValue(key, value) {
+	if (value instanceof Literal) return Object.freeze({
+		key,
+		literal: value.literal
+	});
+	if (value instanceof SelectQuery) return Object.freeze({
+		key,
+		query: value.node,
+		db: value.db
+	});
+	if (value instanceof RecordQuery) throw new TypeError(`Selected field "${key}" is a query of $select, which cannot be nested; select its fields directly instead`);
+	if (value instanceof MutationQuery) throw new TypeError(`Selected field "${key}" is a query of insert, update, or delete, which cannot be nested`);
+	if (value instanceof SqlQuery) throw new TypeError(`Selected field "${key}" is a query of $query, which cannot be nested`);
+	if (!isExpression(value)) throw new TypeError(`Selected field "${key}" must be an expression, a query, or a literal`);
+	const type = getType(value);
+	if (!type) throw new TypeError(`Selected field "${key}" has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
+	return projectExpression(key, value, type);
+}
+/** Creates the projection of a column of the table of `source` under its key. */
+function projectColumn(source, key) {
+	const { type } = requireColumn(source.table, key);
+	return Object.freeze({
+		key,
+		expression: createNode({
+			kind: "column",
+			source,
+			key
+		}),
+		type
+	});
+}
+/** Creates the projection of an expression under `key`, decoded with `type`, the type of the expression. */
+function projectExpression(key, value, type) {
+	return Object.freeze({
+		key,
+		expression: toNode(value),
+		type
+	});
+}
+/** Adds or replaces a field by key, rejecting a key that a record cannot have. */
+function setProjection(projections, projection) {
+	const { key } = projection;
+	if (!isRecordKey(key)) throw new Error(`Field "${key}" cannot be selected: it is not a valid record key`);
+	for (let index = 0; index < projections.length; index++) if (projections[index].key === key) {
+		projections[index] = projection;
+		return;
+	}
+	projections.push(projection);
+}
 // src/query/values.ts
 /**
 * Returns the columns and the rows of `VALUES` of an insert of `records`, at least one, into `table`, reading the keys and values of each record when it is called.
@@ -2710,41 +2512,325 @@ function toInsertRows(table, records, method) {
 	};
 }
 /**
-* Returns the assignments of an update of the rows of `source` that `set` gives: the values of its columns, or a callback that receives the columns and returns them, read when it is called.
+* Returns the assignments of an update of the rows of `source` that `set` gives: the values of its columns, or a callback that receives the columns and returns them, read when it is called.
+*
+* A value of `undefined` keeps its column, and an update must set at least one column.
+* It rejects a key that is not a column of the table of `source`, and a query as a value.
+*/
+function toAssignments(source, set) {
+	const { table } = source;
+	const values = typeof set === "function" ? set(createColumnRefs(source)) : set;
+	if (typeof values !== "object" || values === null) throw new TypeError(`update takes the values of the columns of table "${table.name}" or a callback that returns them`);
+	const assignments = [];
+	for (const key of Object.keys(values)) {
+		const value = values[key];
+		if (value !== void 0) assignments.push(Object.freeze({
+			key,
+			value: resolveValue(table, key, value)
+		}));
+	}
+	if (assignments.length === 0) throw new Error(`update takes the value of at least one column of table "${table.name}"; a column given as undefined keeps its value`);
+	return assignments;
+}
+/** Returns the node of `value` of the column of `table` under `key`: an expression, or a parameter encoded with the type of the column. */
+function resolveValue(table, key, value) {
+	const column = requireColumn(table, key);
+	if (value instanceof SelectQuery || value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError(`Column "${key}" of table "${table.name}" takes a value or an expression, not a query`);
+	return toValueNode(value, column.type);
+}
+// src/query/mutation.ts
+/**
+* Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
+*
+* Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
+* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
+* A bound query executes on its `Db` when awaited.
+*/
+var MutationQuery = class MutationQuery {
+	table;
+	node;
+	context;
+	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+	db;
+	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+	then;
+	constructor(table, node, context, db) {
+		this.table = table;
+		this.node = node;
+		this.context = context;
+		this.db = db;
+		this.then = db === void 0 ? void 0 : executeOnAwait;
+		Object.freeze(this);
+	}
+	select(...args) {
+		const { node } = this;
+		const { returning } = node;
+		if (returning !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
+		return this.derive({
+			returning: mergeProjections(returning ?? [], node.target, args, this.context),
+			value: false
+		});
+	}
+	get(arg) {
+		if (this.node.rows === "many") throw new Error("get applies only to a query that changes one row, such as of insert or find; use pluck to return the values of several rows");
+		return this.deriveValue(arg, "get");
+	}
+	pluck(arg) {
+		return this.deriveValue(arg, "pluck");
+	}
+	toSQL(options) {
+		return compileToSQL(this, options);
+	}
+	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+	[operandNode]() {
+		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of insert, update, or delete");
+	}
+	/** Creates a mutation of the same kind and `Db` with the node changes applied. */
+	derive(changes) {
+		return new MutationQuery(this.table, Object.freeze({
+			...this.node,
+			...changes
+		}), this.context, this.db);
+	}
+	/** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
+	deriveValue(arg, method) {
+		const { node } = this;
+		return this.derive({
+			returning: [projectValue(node.target, arg, method)],
+			value: true,
+			rows: toValueRows(node.rows)
+		});
+	}
+};
+/**
+* Creates the insert of `records` into the table of `query`, which must have no clauses, in rows mode `rows`: `one` for `insert` and `many` for `insertMany`, named by `method`.
+*
+* It returns the number of the inserted rows, until a selection returns their fields.
+*/
+function createInsert(query, records, rows, method) {
+	const { node } = query;
+	if (!isTableQuery(node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
+	const { columns, values } = toInsertRows(node.from.table, records, method);
+	return new MutationQuery(query.table, Object.freeze({
+		kind: "insert",
+		target: node.from,
+		columns,
+		values,
+		returning: void 0,
+		rows,
+		value: false
+	}), query.context, query.db);
+}
+/** Creates the update of the rows of `query` that `set` gives, as `update` takes it, in the rows mode of the query. */
+function createUpdate(query, set) {
+	const { node } = query;
+	checkChangedRows(node, "update");
+	return new MutationQuery(query.table, Object.freeze({
+		kind: "update",
+		target: node.from,
+		set: toAssignments(node.from, set),
+		filters: node.filters,
+		returning: void 0,
+		rows: node.rows,
+		value: false
+	}), query.context, query.db);
+}
+/** Creates the delete of the rows of `query`, in the rows mode of the query. */
+function createDelete(query) {
+	const { node } = query;
+	checkChangedRows(node, "delete");
+	return new MutationQuery(query.table, Object.freeze({
+		kind: "delete",
+		target: node.from,
+		filters: node.filters,
+		returning: void 0,
+		rows: node.rows,
+		value: false
+	}), query.context, query.db);
+}
+/**
+* Rejects a query whose rows `method`, `update` or `delete`, cannot change: one of a relation, with selected fields, which a mutation selects after it, with an order, a limit, or an offset, or without a filter that restricts its rows unless `all` allows it.
+*
+* A filter simplified to `TRUE`, such as `where({})`, restricts no row.
+*/
+function checkChangedRows(node, method) {
+	if (node.relation !== void 0) throw new Error(`${method} applies only to a query of a table, not of a relation`);
+	if (node.projections.length > 0) throw new Error(`${method} returns the fields selected after it, not before; call select, get, or pluck after ${method}`);
+	if (node.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, or orderBy`);
+	const predicate = combineFilters(node.filters);
+	if (!node.all && predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
+}
+// src/query/order.ts
+/** Direction and placement of `NULL` of a sort key node, by `OrderDirection`. */
+const directions = /* @__PURE__ */ Object.freeze({
+	asc: {
+		direction: "asc",
+		nulls: void 0
+	},
+	desc: {
+		direction: "desc",
+		nulls: void 0
+	},
+	"asc nulls first": {
+		direction: "asc",
+		nulls: "first"
+	},
+	"asc nulls last": {
+		direction: "asc",
+		nulls: "last"
+	},
+	"desc nulls first": {
+		direction: "desc",
+		nulls: "first"
+	},
+	"desc nulls last": {
+		direction: "desc",
+		nulls: "last"
+	}
+});
+const orderingNode = Symbol("kern-orm.ordering.node");
+/** Runtime class of an expression with a direction, which holds its sort key node. */
+var OrderingObject = class {
+	[orderingNode];
+	constructor(node) {
+		this[orderingNode] = node;
+		Object.freeze(this);
+	}
+};
+/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
+function asc(value) {
+	return orderBy(value, "asc");
+}
+/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
+function desc(value) {
+	return orderBy(value, "desc");
+}
+/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
+function orderBy(value, direction) {
+	if (!isOperandSource(value)) throw new TypeError("A sort key must be an expression or a query of one value");
+	return new OrderingObject(createOrderNode(value[operandNode](), direction));
+}
+/**
+* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
+*
+* `args` are column keys and objects of columns with directions, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one sort key or an array of them.
+*/
+function addOrder(node, context, args) {
+	const order = node.orderBy.slice();
+	const first = args[0];
+	if (typeof first === "function") {
+		const terms = first(createSelectionRefs(node.from, context), createSelectedRefs(node));
+		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
+		else order.push(readTerm(terms));
+		return order;
+	}
+	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
+	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+		const columns = arg;
+		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
+	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
+	return order;
+}
+/**
+* Creates the sort key node of a sort key returned by the callback of `orderBy`.
+*
+* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
+*/
+function readTerm(term) {
+	if (term instanceof OrderingObject) return term[orderingNode];
+	if (isOperandSource(term)) return createOrderNode(term[operandNode](), "asc");
+	throw new TypeError("The callback of orderBy must return expressions, queries of one value, or sort keys of asc, desc, and orderBy");
+}
+/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
+function createOrderNode(expression, direction) {
+	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
+	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
+	return Object.freeze({
+		expression,
+		direction: placement.direction,
+		nulls: placement.nulls
+	});
+}
+/** Creates a reference to the column `key` of the table of `source`. */
+function createColumnNode(source, key) {
+	requireColumn(source.table, key);
+	return createNode({
+		kind: "column",
+		source,
+		key
+	});
+}
+/**
+* Creates the references of the callback of `orderBy` to the fields selected by `node`.
 *
-* A value of `undefined` keeps its column, and an update must set at least one column.
-* It rejects a key that is not a column of the table of `source`, and a query as a value.
+* 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 toAssignments(source, set) {
-	const { table } = source;
-	const values = typeof set === "function" ? set(createColumnRefs(source)) : set;
-	if (typeof values !== "object" || values === null) throw new TypeError(`update takes the values of the columns of table "${table.name}" or a callback that returns them`);
-	const assignments = [];
-	for (const key of Object.keys(values)) {
-		const value = values[key];
-		if (value !== void 0) assignments.push(Object.freeze({
-			key,
-			value: resolveValue(table, key, value)
-		}));
+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);
 	}
-	if (assignments.length === 0) throw new Error(`update takes the value of at least one column of table "${table.name}"; a column given as undefined keeps its value`);
-	return assignments;
+	return refs;
 }
-/** Returns the node of `value` of the column of `table` under `key`: an expression, or a parameter encoded with the type of the column. */
-function resolveValue(table, key, value) {
-	const column = requireColumn(table, key);
-	if (value instanceof SelectQuery || value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError(`Column "${key}" of table "${table.name}" takes a value or an expression, not a query`);
-	return toValueNode(value, column.type);
+/** 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/mutation.ts
+/** Creates an expression of the value of `field`, a selected aggregate query or query of `exists`, with the type of its value. */
+function toQueryExpression(field) {
+	const { query } = field;
+	return toExpression(createNode({
+		kind: "nestedQuery",
+		query,
+		db: field.db,
+		field
+	}), query.projections[0].type);
+}
+// src/query/pagination.ts
+/** Creates the parameter of the number of rows of `limit` or `offset`, named by `method`, of query `node`, rejecting a query of one row and a count that is not a non-negative safe integer. */
+function createPageCount(node, method, count) {
+	if (node.rows !== "many") throw new Error(`${method} applies only to a query of many rows${createPaginationHint(node)}`);
+	if (!Number.isSafeInteger(count) || count < 0) throw new RangeError(`${method} takes a non-negative integer, not ${count}`);
+	return createNode({
+		kind: "param",
+		value: count,
+		type: void 0
+	});
+}
+/** Creates the hint of the error of `limit` or `offset` of query `node` of one row: the method to call them before, if any. */
+function createPaginationHint(node) {
+	if (node.relation?.kind === "one") return "";
+	if (isAggregateQuery(node)) return "; call it before count or another aggregate to aggregate the rows of a page";
+	if (isExistsQuery(node)) return "; call it before exists to check the rows of a page";
+	return "; call it before take or get";
+}
+// src/query/select.ts
 /**
-* Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
+* Immutable select query of state `S`, unbound or bound to a `Db`.
 *
-* Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
+* 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 MutationQuery = class MutationQuery {
+var SelectQuery = class SelectQuery {
 	table;
 	node;
 	context;
@@ -2760,242 +2846,295 @@ var MutationQuery = class MutationQuery {
 		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;
-		const { returning } = node;
-		if (returning !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
+		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({
-			returning: mergeProjections(returning ?? [], node.target, args, this.context),
-			value: false
+			projections: [projection],
+			rows: "one",
+			value: true,
+			guaranteed: false
 		});
 	}
-	get(arg) {
-		if (this.node.rows === "many") throw new Error("get applies only to a query that changes one row, such as of insert or find; use pluck to return the values of several rows");
-		return this.deriveValue(arg, "get");
+	/** 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));
 	}
-	pluck(arg) {
-		return this.deriveValue(arg, "pluck");
+	/** 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
+		};
 	}
-	toSQL(options) {
-		return compileToSQL(this, options);
+	/** 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);
 	}
-	/** 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 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
+		});
 	}
-	/** Creates a mutation of the same kind and `Db` with the node changes applied. */
-	derive(changes) {
-		return new MutationQuery(this.table, Object.freeze({
-			...this.node,
-			...changes
-		}), this.context, this.db);
+	/** 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`);
 	}
-	/** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
-	deriveValue(arg, method) {
+	/** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
+	rejectAggregate(method) {
 		const { node } = this;
-		return this.derive({
-			returning: [projectValue(node.target, arg, method)],
-			value: true,
-			rows: toValueRows(node.rows)
-		});
+		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`);
 	}
 };
 /**
-* Creates the insert of `records` into the table of `query`, which must have no clauses, in rows mode `rows`: `one` for `insert` and `many` for `insertMany`, named by `method`.
-*
-* It returns the number of the inserted rows, until a selection returns their fields.
-*/
-function createInsert(query, records, rows, method) {
-	const { node } = query;
-	if (!isTableQuery(node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
-	const { columns, values } = toInsertRows(node.from.table, records, method);
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "insert",
-		target: node.from,
-		columns,
-		values,
-		returning: void 0,
-		rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the update of the rows of `query` that `set` gives, as `update` takes it, in the rows mode of the query. */
-function createUpdate(query, set) {
-	const { node } = query;
-	checkChangedRows(node, "update");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "update",
-		target: node.from,
-		set: toAssignments(node.from, set),
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the delete of the rows of `query`, in the rows mode of the query. */
-function createDelete(query) {
-	const { node } = query;
-	checkChangedRows(node, "delete");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "delete",
-		target: node.from,
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), query.context, query.db);
-}
-/**
-* Rejects a query whose rows `method`, `update` or `delete`, cannot change: one of a relation, with selected fields, which a mutation selects after it, with an order, a limit, or an offset, or without a filter that restricts its rows unless `all` allows it.
-*
-* A filter simplified to `TRUE`, such as `where({})`, restricts no row.
-*/
-function checkChangedRows(node, method) {
-	if (node.relation !== void 0) throw new Error(`${method} applies only to a query of a table, not of a relation`);
-	if (node.projections.length > 0) throw new Error(`${method} returns the fields selected after it, not before; call select, get, or pluck after ${method}`);
-	if (node.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, or orderBy`);
-	const predicate = combineFilters(node.filters);
-	if (!node.all && predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
-}
-// src/query/projections.ts
-/**
-* Creates the fields of `select` over `source`, appending new keys and replacing existing ones in place.
+* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
 *
-* `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.
+* An ancestor of `query` also passes, since only the source occurrence is compared.
 */
-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));
-	}
+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;
 }
-/** 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]));
-	}
-}
-/**
-* 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);
+/** 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);
 }
-/**
-* 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) {
-	if (fallback === null || fallback === void 0) throw new TypeError(`coalesce takes a value other than ${String(fallback)}`);
-	if (isExistsProjection(field)) return field;
-	const value = toValueNode(fallback, field.type);
-	if (isAggregateProjection(field)) return addFallback(field, value);
-	return Object.freeze({
-		key: field.key,
-		expression: createList("coalesce(", [field.expression, value], ")"),
-		type: field.type
-	});
+/** Starts a query over a new occurrence of the table. */
+function from(table) {
+	return startQuery(table, noContext);
 }
-/** 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
-	});
-	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);
+/** 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);
 }
-/** 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
-	});
+// src/expression/functions.ts
+function coalesce(first, ...rest) {
+	return callFunction("coalesce", first, rest);
 }
-/** 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
-	});
+function greatest(first, ...rest) {
+	return callFunction("greatest", first, rest);
 }
-/** 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);
+function least(first, ...rest) {
+	return callFunction("least", first, rest);
 }
-// src/query/record.ts
-/**
-* Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and the results of independent queries, selected in one statement.
-*
-* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
-* A bound query executes on its `Db` when awaited.
-*/
-var RecordQuery = class {
-	node;
-	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-	db;
-	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-	then;
-	constructor(node, db) {
-		this.node = node;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
+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));
 	}
-	/** 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");
+	if (otherwise !== void 0) {
+		fragments.push(" ELSE ");
+		values.push(toCastValueNode(otherwise, type));
 	}
-};
-/**
-* Starts the query of `$select` of `selection`, an object of expressions and queries by key, bound to `db` when given.
-*
-* It reads the keys and values of `selection` when it is called.
-*/
-function startRecordQuery(selection, db) {
-	const projections = [];
-	addSelection(projections, selection);
-	return new RecordQuery(Object.freeze({
-		kind: "record",
-		projections
-	}), db);
+	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. */
@@ -3141,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);
@@ -3897,4 +4031,4 @@ function createLockStatement(key) {
 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, identifier, 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 };