@ultimabase/postgres 0.0.0-stage → 0.1.0

package/src/write.ts

@@ -0,0 +1,384 @@
+// A write as the fewest statements (D-99): its checks, then each change as a
+// data-modifying CTE that runs only when they pass, then the read, which sees
+// the changes through CTEs named as the written tables, or, with `before`,
+// takes the rows its model's delete removed from that delete's RETURNING
+// (D-102, D-104), or, with no such delete, those its update changed (D-133). A read of the one row a change writes takes it from that
+// change's RETURNING (D-103). The unique
+// constraint a refused change names is the kernel's `UniqueViolation` (D-98).
+import type { RawBuilder } from 'kysely'
+import { sql } from 'kysely'
+import type { Change, Check, Filter, Read, Row, Write } from 'ultimabase'
+import { RelationViolation, UniqueViolation } from 'ultimabase'
+import type { Sql } from './filter.ts'
+import { Filters, uuid, value } from './filter.ts'
+import type { Catalog, Table } from './names.ts'
+import { computed } from './numbers.ts'
+import type { Part } from './parts.ts'
+import { fieldsOf, grouped, inserted, sizeOf } from './parts.ts'
+import { notifying, pairs as linked, rows as noted } from './notify.ts'
+import { compileRows } from './read.ts'
+
+/** A statement of a write: how many checks its result carries, `c0`… */
+export type Statement = {
+	readonly sql: RawBuilder<{ readonly [column: string]: unknown }>
+	readonly checks: number
+}
+
+function assignments(
+	catalog: Catalog,
+	table: Table,
+	values: { readonly [field: string]: unknown },
+): (readonly [string, Sql])[] {
+	return Object.entries(values)
+		.filter(([, item]) => item !== undefined)
+		.map(([name, item]) => [
+			catalog.column(table, name),
+			value(catalog.kind(table, name), item),
+		])
+}
+
+const and = (gate: Sql | undefined): Sql =>
+	gate === undefined ? sql`` : sql` and ${gate}`
+
+/** The id a filter selects by `{ id: { equals } }` alone, if any. */
+function idOf(where: Filter | undefined): string | undefined {
+	if (where === undefined || Object.keys(where).length !== 1) return undefined
+	const id = where['id']
+	if (typeof id !== 'object' || id === null || Object.keys(id).length !== 1) {
+		return undefined
+	}
+	return 'equals' in id && typeof id.equals === 'string' ? id.equals : undefined
+}
+
+/** The CTE of a change, `undefined` when it changes nothing. */
+function part(
+	catalog: Catalog,
+	change: Exclude<Change, { readonly kind: 'insert' }>,
+	removed: ReadonlyMap<number, string>,
+): Part | undefined {
+	if (change.kind !== 'update' && change.kind !== 'delete') {
+		return links(catalog, change)
+	}
+	const table = catalog.table(change.model)
+	const name = sql.id(table.name)
+	const base = { table: table.name, key: ['id'] }
+	const filters = new Filters(catalog, removed)
+	const named = filters.alias()
+	const alias = sql.id(named)
+	const where = filters.where(change.model, named, change.where)
+	const reads = new Set([table.name, ...filters.tables])
+	if (change.kind === 'update') {
+		const fields = [
+			...Object.keys(change.set),
+			...Object.keys(change.compute ?? {}),
+		]
+		const set = sql.join([
+			...assignments(catalog, table, change.set).map(
+				([column, item]) => sql`${sql.id(column)} = ${item}`,
+			),
+			...computed(catalog, table, change.compute),
+		])
+		const row = idOf(change.where)
+		return {
+			...base,
+			...(row === undefined ? {} : { row }),
+			build: (gate) =>
+				sql`update ${name} as ${alias} set ${set} where ${where}${and(gate)} returning ${alias}.*`,
+			inserts: false,
+			removes: true,
+			adds: true,
+			reads,
+			noted: noted('update', change.model, fields),
+		}
+	}
+	return {
+		...base,
+		build: (gate) =>
+			sql`delete from ${name} as ${alias} where ${where}${and(gate)} returning ${alias}.*`,
+		inserts: false,
+		removes: true,
+		adds: false,
+		reads,
+		noted: noted('delete', change.model),
+	}
+}
+
+/** A link or unlink of nothing, or of ids no row has, changes nothing. */
+function links(
+	catalog: Catalog,
+	change: Extract<Change, { readonly kind: 'link' | 'unlink' }>,
+): Part | undefined {
+	const join = catalog.join(change.model, change.field)
+	const name = sql.id(join.table)
+	const self = sql.id(join.self)
+	const other = sql.id(join.other)
+	const key = [join.self, join.other].toSorted()
+	const id = sql`cast(${change.id} as uuid)`
+	// The same pair, whichever side names it.
+	const pairOf = (target: string): string =>
+		key[0] === join.self ? `${change.id}:${target}` : `${target}:${change.id}`
+	const pairs = (targets: readonly string[]) => ({
+		table: join.table,
+		key,
+		reads: new Set<string>(),
+		pairs: new Set(targets.map(pairOf)),
+		noted: linked(
+			change.kind,
+			change.model,
+			change.field,
+			join.self,
+			join.other,
+		),
+	})
+	if (change.kind === 'unlink') {
+		const targets = change.targets.filter((target) => uuid.test(target))
+		if (targets.length === 0) return undefined
+		const list = sql.join(targets.map((target) => sql`cast(${target} as uuid)`))
+		return {
+			...pairs(targets),
+			build: (gate) =>
+				sql`delete from ${name} where ${self} = ${id} and ${other} in (${list})${and(gate)} returning *`,
+			inserts: false,
+			removes: true,
+			adds: false,
+		}
+	}
+	if (change.targets.length === 0) return undefined
+	const rows = sql.join(
+		change.targets.map((target) => sql`(${id}, cast(${target} as uuid))`),
+	)
+	return {
+		...pairs(change.targets),
+		build: (gate) => {
+			const source =
+				gate === undefined
+					? sql`values ${rows}`
+					: sql`select * from (values ${rows}) as "v" where ${gate}`
+			return sql`insert into ${name} (${self}, ${other}) ${source} on conflict do nothing returning *`
+		},
+		inserts: true,
+		removes: false,
+		adds: true,
+	}
+}
+
+function checking(catalog: Catalog, checks: readonly Check[]): Sql {
+	const filters = new Filters(catalog)
+	const columns = checks.map((check, at) => {
+		const table = sql.id(catalog.table(check.model).name)
+		const alias = filters.alias()
+		const where = filters.where(check.model, alias, check.where)
+		// A locked row is counted as it is after any wait for its lock.
+		const rows = sql`${table} as ${sql.id(alias)} where ${where}`
+		const from = check.lock ? sql`(select from ${rows} for update) as t` : rows
+		return sql`(select count(*) from ${from}) = ${check.count} as ${sql.id(`c${at}`)}`
+	})
+	return sql`select ${sql.join(columns)}`
+}
+
+const cteName = (at: number): string => `#w${at}`
+const cte = (at: number): Sql => sql.id(cteName(at))
+
+/** Each written table as the read sees it: the changed rows in place. */
+function views(parts: ReadonlyMap<number, Part>): Sql[] {
+	const tables = new Map<string, [number, Part][]>()
+	for (const [at, each] of parts) {
+		tables.set(each.table, [...(tables.get(each.table) ?? []), [at, each]])
+	}
+	return [...tables].map(([table, written]) => {
+		const name = sql.id(table)
+		const key = written[0]?.[1].key ?? []
+		const keys = sql.join(key.map((column) => sql.id(column)))
+		const removed = written
+			.filter(([, each]) => each.removes)
+			.map(([at]) => sql`select ${keys} from ${cte(at)}`)
+		const kept =
+			removed.length === 0
+				? sql`select * from ${name}`
+				: sql`select * from ${name} where (${keys}) not in (${sql.join(removed, sql` union all `)})`
+		const added = written
+			.filter(([, each]) => each.adds)
+			.map(([at]) => sql`select * from ${cte(at)}`)
+		const body = sql.join([kept, ...added], sql` union all `)
+		return sql`${name} as not materialized (${body})`
+	})
+}
+
+/**
+ * The change of a statement that writes the one row `read` selects, when no
+ * other change of it writes that table: the read takes the row from its
+ * RETURNING rather than from the table's view (D-103).
+ */
+function sourceOf(
+	catalog: Catalog,
+	read: Read,
+	parts: ReadonlyMap<number, Part>,
+): number | undefined {
+	const id = idOf(read.where)
+	const table = catalog.table(read.model).name
+	const written = [...parts].filter(([, each]) => each.table === table)
+	const [only] = written
+	return id !== undefined && written.length === 1 && only?.[1].row === id
+		? only[0]
+		: undefined
+}
+
+/** The statements of a write, in the order they run. */
+export function compileWrite(
+	catalog: Catalog,
+	write: Write,
+	/** Where the feed's notifications go, when it has a taker (D-154). */
+	channel?: string,
+): Statement[] {
+	const checks = write.checks ?? []
+	// Each statement stays within PostgreSQL's 65,535 parameters, its checks
+	// and its read's aside.
+	const room =
+		65_535 -
+		sizeOf(checking(catalog, checks)) -
+		(write.read === undefined
+			? 0
+			: sizeOf(compileRows(catalog, write.read, undefined).rows))
+	const parts: Part[] = []
+	const removed = new Map<number, string>()
+	// Consecutive rows of a table, setting the same fields, go in one insert.
+	let batch: { readonly model: string; readonly rows: Row[] } | undefined
+	const flush = (): void => {
+		if (batch !== undefined) {
+			parts.push(inserted(catalog, batch.model, batch.rows))
+		}
+		batch = undefined
+	}
+	for (const [index, change] of write.changes.entries()) {
+		if (change.kind === 'insert') {
+			const fields = fieldsOf(change.row)
+			const joins =
+				batch?.model === change.model &&
+				fieldsOf(batch.rows[0] ?? {})
+					.toSorted()
+					.join() === fields.toSorted().join() &&
+				(batch.rows.length + 1) * fields.length <= room
+			if (!joins) {
+				flush()
+				batch = { model: change.model, rows: [] }
+			}
+			batch?.rows.push(change.row)
+			continue
+		}
+		flush()
+		const each = part(catalog, change, removed)
+		if (each === undefined) continue
+		if (change.kind === 'delete') removed.set(index, cteName(parts.length))
+		parts.push(each)
+	}
+	flush()
+	if (parts.length === 0 && checks.length === 0 && write.read === undefined) {
+		return []
+	}
+	const columns = checks.map((_, at) => sql.id(`c${at}`))
+	const gate =
+		checks.length === 0
+			? undefined
+			: sql`(select ${sql.join(columns, sql` and `)} from "#checks")`
+	const groups = grouped(parts, room)
+	const before = write.before === true
+	const table = write.read && catalog.table(write.read.model).name
+	// With `before`, the read runs beside its model's delete (D-104), or,
+	// when the write deletes nothing of it, its update (D-133).
+	const of = (adds: boolean): number =>
+		parts.findIndex(
+			(each) =>
+				before && each.table === table && each.removes && each.adds === adds,
+		)
+	const deleted = of(false)
+	const removal = deleted === -1 ? of(true) : deleted
+	let next = 0
+	return groups.map((group, index): Statement => {
+		const first = index === 0 && checks.length > 0
+		const numbered = new Map(group.map((each) => [next++, each]))
+		const ctes = [...numbered].map(
+			([at, each]) =>
+				sql`${cte(at)} as (${each.build(first ? gate : undefined)})`,
+		)
+		const reads = before ? numbered.has(removal) : index === groups.length - 1
+		const read = reads ? write.read : undefined
+		const seen = read !== undefined && !before
+		const source = seen ? sourceOf(catalog, read, numbered) : removal
+		const compiled =
+			read === undefined
+				? undefined
+				: compileRows(
+						catalog,
+						read,
+						source === undefined ? undefined : cte(source),
+					)
+		const fed = channel !== undefined && numbered.size > 0
+		const selected = [
+			...(first ? columns : []),
+			...(compiled === undefined ? [] : [sql`${compiled.rows} as "rows"`]),
+			// Referenced, the CTE runs.
+			...(fed ? [sql`(select count(*) from "#feed") as "fed"`] : []),
+		]
+		// The root's table needs no view when only its RETURNING is read.
+		const root = read === undefined ? '' : catalog.table(read.model).name
+		const viewed = [...numbered].filter(
+			([, each]) =>
+				source === undefined ||
+				each.table !== root ||
+				compiled?.tables.has(root) === true,
+		)
+		const all = [
+			...(first ? [sql`"#checks" as (${checking(catalog, checks)})`] : []),
+			...ctes,
+			...(seen ? views(new Map(viewed)) : []),
+			...(fed
+				? [
+						notifying(
+							channel,
+							[...numbered].map(([at, each]) => [cte(at), each.noted] as const),
+						),
+					]
+				: []),
+		]
+		const list = selected.length === 0 ? sql`1 as "one"` : sql.join(selected)
+		const body = sql`select ${list}${first ? sql` from "#checks"` : sql``}`
+		return {
+			sql: all.length === 0 ? sql`${body}` : sql`with ${sql.join(all)} ${body}`,
+			checks: first ? checks.length : 0,
+		}
+	})
+}
+
+type Refusal = {
+	readonly code: string
+	readonly constraint: string
+	readonly message: string
+}
+
+function isRefusal(error: unknown): error is Refusal {
+	return (
+		error instanceof Error &&
+		'code' in error &&
+		typeof error.code === 'string' &&
+		'constraint' in error &&
+		typeof error.constraint === 'string'
+	)
+}
+
+/** A constraint's refusal as the kernel's error; any other as is. */
+export function translate(catalog: Catalog, error: unknown): unknown {
+	if (!isRefusal(error)) return error
+	if (error.code === '23505') {
+		const unique = catalog.uniques.get(error.constraint)
+		if (unique !== undefined) {
+			return new UniqueViolation(unique.model, unique.fields)
+		}
+	}
+	const key = catalog.foreignKeys.get(error.constraint)
+	if (error.code === '23503' && key !== undefined) {
+		// Only the message tells the deleting side from the linking one.
+		const restricted = error.message.startsWith('update or delete')
+		return new RelationViolation(key.model, key.field, key.target, restricted)
+	}
+	return error
+}