dzql 0.9.0 → 0.11.0

package/src/compile/lookups.ts

@@ -0,0 +1,118 @@
+/**
+ * Compiled lookups: a collection's definition, its table's serial, and a
+ * document read as it stood. What the write, the reads and the ledger still
+ * looked up at run time -- `_delta_collections` for a collection's table,
+ * parent and columns, a table's sequence by its name, the framework's read as
+ * it stood -- written from the definitions.
+ *
+ * `compileLookups(schema, docs)` writes:
+ * - `_delta_collection(key)`: each collection's definition, as generateSql
+ *   records it in `_delta_collections`, written in; NULL fields for a key of
+ *   none;
+ * - `_delta_serial_new(table, id)` and `_delta_serial_past(table, id)`: each
+ *   table's sequence named, read or moved as the framework's do (as the
+ *   functions' owner, for a caller with the table's privilege); for a table
+ *   there is not, no id is new and nothing moves;
+ * - `_delta_find_doc(name)`: the document a name is of, by the longest prefix
+ *   it starts with, as generateSql records it in `_delta_docs`, written in;
+ *   NULL for a name of none;
+ * - `delta_open_at(name, at)`: each compiled document to its own read as it
+ *   stood (`dzql_open_at__<slug>`), refusing a name of none.
+ *
+ * Each answers what the framework's did (recorded: tests/compile/lookups.test.ts).
+ */
+import { q, type DocDef, type Schema } from "@blueshed/delta/backend";
+import { findCascadeOn } from "../postgres/sql";
+import { lit, noDoc, openAtFunction } from "./opens";
+
+/** The caller, as the framework's serials ask: the role set, else the session's. */
+const CALLER = "COALESCE(NULLIF(current_setting('role'), 'none'), session_user)";
+
+/** The search path a definer function runs with: the schemas applied in, and pg_temp last (as the framework's serials). */
+const searchPath = (signature: string) => `DO $$
+DECLARE
+  v_path TEXT := COALESCE((SELECT string_agg(quote_ident(s), ', ') FROM unnest(current_schemas(false)) AS s), 'public') || ', pg_temp';
+BEGIN
+  EXECUTE format('ALTER FUNCTION ${signature} SET search_path = %s', v_path);
+END $$;`;
+
+export function compileLookups(schema: Schema, docs: DocDef[]): string {
+  const tables = Object.entries(schema.tables);
+
+  const collection = `CREATE OR REPLACE FUNCTION _delta_collection(p_key TEXT)
+RETURNS _delta_collections AS $$
+BEGIN
+  CASE p_key
+${tables.map(([key, t]) => {
+    const row = {
+      collection_key: key,
+      table_name: t.name,
+      columns_def: t.columns,
+      parent_collection: t.parent?.collection ?? null,
+      parent_fk: t.parent?.fkColumn ?? null,
+      temporal: t.temporal,
+      cascade_on: findCascadeOn(key, schema),
+    };
+    return `    WHEN ${lit(key)} THEN RETURN jsonb_populate_record(null::_delta_collections, ${lit(JSON.stringify(row))}::jsonb);`;
+  }).join("\n")}
+    ELSE RETURN NULL;   -- a collection there is not
+  END CASE;
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+
+  const serialNew = `CREATE OR REPLACE FUNCTION _delta_serial_new(p_table TEXT, p_id BIGINT)
+RETURNS BOOLEAN AS $$
+DECLARE
+  v_new BOOLEAN;
+BEGIN
+  CASE p_table
+${tables.map(([, t]) => `    WHEN ${lit(t.name)} THEN
+      IF NOT has_table_privilege(${CALLER}, p_table, 'SELECT') THEN RETURN FALSE; END IF;
+      SELECT p_id >= last_value + is_called::int INTO v_new FROM ${q(`seq_${t.name}`)};
+      RETURN v_new;`).join("\n")}
+    ELSE RETURN FALSE;   -- a table there is not: no id is new
+  END CASE;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+${searchPath("_delta_serial_new(text, bigint)")}`;
+
+  const serialPast = `CREATE OR REPLACE FUNCTION _delta_serial_past(p_table TEXT, p_id BIGINT)
+RETURNS void AS $$
+BEGIN
+  CASE p_table
+${tables.map(([, t]) => `    WHEN ${lit(t.name)} THEN
+      IF p_id > 9007199254740991 OR NOT has_table_privilege(${CALLER}, p_table, 'INSERT') THEN RETURN; END IF;
+      PERFORM setval(${lit(`seq_${t.name}`)}, p_id) FROM ${q(`seq_${t.name}`)} WHERE p_id >= last_value + is_called::int;`).join("\n")}
+    ELSE NULL;   -- a table there is not: nothing to move
+  END CASE;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+${searchPath("_delta_serial_past(text, bigint)")}`;
+
+  // longest first, as the framework's ORDER BY length(prefix) DESC: a name is of the longest prefix it starts with
+  const byLength = [...docs].sort((a, b) => b.prefix.length - a.prefix.length || (a.prefix < b.prefix ? -1 : 1));
+  const findDoc = `CREATE OR REPLACE FUNCTION _delta_find_doc(p_doc_name TEXT)
+RETURNS _delta_docs AS $$
+BEGIN
+${byLength.map((d) => {
+    const row = { prefix: d.prefix, root_collection: d.root, include: d.include, scope: d.scope, implied: !!d.implied, held: d.columns ?? {} };
+    return `  IF starts_with(p_doc_name, ${lit(d.prefix)}) THEN RETURN jsonb_populate_record(null::_delta_docs, ${lit(JSON.stringify(row))}::jsonb); END IF;`;
+  }).join("\n")}
+  RETURN NULL;   -- a name no document holds
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+
+  const openAt = `CREATE OR REPLACE FUNCTION delta_open_at(p_doc_name TEXT, p_at TIMESTAMPTZ)
+RETURNS JSONB AS $$
+DECLARE
+  v_def _delta_docs := _delta_find_doc(p_doc_name);
+BEGIN
+  CASE v_def.prefix
+${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${openAtFunction(d.prefix)}(p_doc_name, p_at);`).join("\n")}
+    ELSE ${noDoc("p_doc_name")}
+  END CASE;
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+
+  return [collection, findDoc, serialNew, serialPast, openAt, ""].join("\n\n");
+}

package/src/compile/opens.ts

@@ -25,12 +25,26 @@ import { q, type ColumnDef, type DocDef, type ResolvedTable, type Schema } from
 import { columnSqlType } from "../postgres/sql";
 
 /** A string as an SQL literal. */
-const lit = (s: string): string => `'${s.replace(/'/g, "''")}'`;
+export const lit = (s: string): string => `'${s.replace(/'/g, "''")}'`;
 
-/** A document's function name: its prefix, lower case, every other character `_`. */
-export function openFunction(prefix: string): string {
-  return `dzql_open__${prefix.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
-}
+/** A name no document compiled here holds: there is none (the framework that read the rest retired, todo #26). */
+export const noDoc = (name: string): string => `RAISE EXCEPTION 'no doc def for: %', ${name} USING ERRCODE = 'P0001';`;
+
+/** A collection none was compiled for: the write asks only its own, and delta_apply refuses any other first. */
+export const noCollection = (key: string): string => `RAISE EXCEPTION 'unknown collection: %', ${key} USING ERRCODE = '22023';`;
+
+/** A compiled function's name: `dzql_<kind>__` and the document's prefix (or a collection's key), lower case, every other character `_`. */
+export const named = (kind: string, name: string): string =>
+  `dzql_${kind}__${name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
+
+/** A document's open: `dzql_open__<slug>`. */
+export const openFunction = (prefix: string): string => named("open", prefix);
+
+/** A table's rows as they stand: its current view where temporal, else the table. */
+export const standingRows = (table: ResolvedTable): string => q(table.temporal ? `current_${table.name}` : table.name);
+
+/** A temporal table's rows as they stand, as a condition on `alias`: ` AND <alias>.valid_to IS NULL`; nothing for a table that is not. */
+export const currentOnly = (table: ResolvedTable, alias: string): string => (table.temporal ? ` AND ${alias}.valid_to IS NULL` : "");
 
 /**
  * A row as a document reads it: as stored (a temporal row without its
@@ -102,7 +116,7 @@ function includedList(schema: Schema, doc: DocDef, coll: string): string {
   return `(SELECT COALESCE(jsonb_object_agg(t.id, ${rowOf(table, doc, coll, "t")}), '{}'::jsonb) FROM ${q(table.name)} t${standing(table, "t").replace(" AND", " WHERE")})`;
 }
 
-function need(schema: Schema, doc: DocDef, coll: string): ResolvedTable {
+export function need(schema: Schema, doc: DocDef, coll: string): ResolvedTable {
   const table = schema.tables[coll];
   if (!table) throw new Error(`[dzql compile] document ${doc.prefix} names a collection the schema does not have: ${coll}`);
   return table;
@@ -118,6 +132,10 @@ interface CompiledScope {
   conds: string;
   /** Whether a name can make it one row: no scope (a name with an id), or an `id` equality. */
   single: boolean;
+  /** `body` without what it sets for the reads (v_single, v_id, p_at): reading the values and checking each. */
+  checks: string;
+  /** After `checks`: plpgsql building `_delta_resolve_scope`'s answer as it builds it -- v_where (text), v_values, v_at. */
+  resolve: string;
 }
 
 const REAL = String.raw`^\s*[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)(e[+-]?[0-9]+)?\s*$`;
@@ -125,8 +143,10 @@ const WHOLE = String.raw`^\s*[+-]?[0-9]+\s*$`;
 const SAFE = String.raw`^\s*[+-]?0*[0-9]{1,16}\s*$`;
 const DAY = String.raw`^\s*([0-9]{4})-([0-9]{2})-([0-9]{2})\s*$`;
 
-/** Refuse a name's value: the framework's message, as a 400 (22P02). */
-const refuse = (message: string, value: string) => `RAISE EXCEPTION '${message.replace(/'/g, "''")}', ${value} USING ERRCODE = '22P02';`;
+/** What a value its column cannot take does: given the message and the value's variable, the plpgsql. */
+type Refuse = (message: string, value: string) => string;
+/** An open refuses it: the framework's message, as a 400 (22P02). */
+const raiseRefusal: Refuse = (message, value) => `RAISE EXCEPTION '${message.replace(/'/g, "''")}', ${value} USING ERRCODE = '22P02';`;
 
 /**
  * A document's scope, compiled from its definition as `_delta_resolve_scope`
@@ -136,7 +156,7 @@ const refuse = (message: string, value: string) => `RAISE EXCEPTION '${message.r
  * value its column cannot take refused with the same message, and an `id`
  * equality making the document one row (single mode).
  */
-function scopeOf(schema: Schema, doc: DocDef): CompiledScope {
+export function scopeOf(schema: Schema, doc: DocDef, refuse: Refuse = raiseRefusal): CompiledScope {
   const root = need(schema, doc, doc.root);
   const entries = Object.entries(doc.scope ?? {});
   if (entries.length === 0) {
@@ -147,6 +167,8 @@ function scopeOf(schema: Schema, doc: DocDef): CompiledScope {
   IF v_single THEN v_id := v_rest::BIGINT; END IF;`,
       conds: "",
       single: true,
+      checks: "",
+      resolve: "",
     };
   }
   const parsed = entries
@@ -163,28 +185,38 @@ function scopeOf(schema: Schema, doc: DocDef): CompiledScope {
     .sort((a, b) => a.key.length - b.key.length || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));   // jsonb's order of keys
   const params = [...new Set(parsed.map((p) => p.param))].sort((a, b) => (a === "id" ? -1 : b === "id" ? 1 : a < b ? -1 : a > b ? 1 : 0));
   const declare = ["v_parts TEXT[];", "v_date TEXT[];"];
-  const body: string[] = [`v_parts := string_to_array(substring(p_name FROM ${doc.prefix.length + 1}), ':');`, "v_single := FALSE;"];
+  const read = `v_parts := string_to_array(substring(p_name FROM ${doc.prefix.length + 1}), ':');`;
+  const body: string[] = [read, "v_single := FALSE;"];
+  const checks: string[] = [read];
+  const resolve: string[] = [];
   const conds: string[] = [];
+  // a check goes in both; what the reads set, in body alone
+  const check = (...lines: string[]) => { body.push(...lines); checks.push(...lines); };
+  // the framework's where, in its words: `%I <op> %L`, joined by AND
+  const where = (v: string, expr: string) => resolve.push(`IF ${v} IS NOT NULL THEN v_where := v_where || CASE WHEN v_where <> '' THEN ' AND ' ELSE '' END || ${expr}; END IF;`);
   parsed.forEach(({ key, op, param }, i) => {
     const v = `v_s${i + 1}`;
     declare.push(`${v} TEXT;`);
-    body.push(`${v} := NULLIF(v_parts[${params.indexOf(param) + 1}], '');`);
+    check(`${v} := NULLIF(v_parts[${params.indexOf(param) + 1}], '');`);
     const isKey = op !== "at" && (key === "id" || key === root.parent?.fkColumn);
     const def = root.columns[key];
     if (op === "at") {
-      body.push(dayOf(v, key), `IF ${v} IS NOT NULL THEN p_at := ${v}::TIMESTAMPTZ; END IF;`);
+      check(dayOf(v, key, refuse));
+      body.push(`IF ${v} IS NOT NULL THEN p_at := ${v}::TIMESTAMPTZ; END IF;`);
+      resolve.push(`IF ${v} IS NOT NULL THEN v_at := ${v}; END IF;`);
       return;
     }
     if (!isKey && !def) throw new Error(`[dzql compile] document ${doc.prefix}: scope key "${key}" is not a column of "${doc.root}"`);
     if (op === "like") {
       conds.push(`(${v} IS NULL OR t.${q(key)} ILIKE ${v} || '%')`);
+      where(v, `format('%I ILIKE %L', ${lit(key)}, ${v} || '%')`);
       return;
     }
     const sqlOp = op === "!=" ? "<>" : op;
     if (isKey) {
       const n = `v_n${i + 1}`;
       declare.push(`${n} BOOLEAN;`);
-      body.push(`IF ${v} IS NOT NULL THEN
+      check(`IF ${v} IS NOT NULL THEN
     IF ${v} ~ '${WHOLE}' THEN
       IF ${v} !~ '${SAFE}' THEN ${refuse(`${key} % is past 2^53 - 1, which no number holds exactly`, v)}
       ELSIF abs(${v}::numeric) > 9007199254740991 THEN ${refuse(`${key} % is past 2^53 - 1, which no number holds exactly`, v)}
@@ -200,16 +232,18 @@ function scopeOf(schema: Schema, doc: DocDef): CompiledScope {
       const asText = ["!=", "<", "<="].includes(op) ? `t.${q(key)} IS NOT NULL` : "FALSE";
       conds.push(`(${v} IS NULL OR (CASE WHEN ${n} THEN t.${q(key)} ${sqlOp} ${v}::BIGINT ELSE ${asText} END))`);
       if (key === "id" && op === "=") body.push(`IF ${v} IS NOT NULL THEN v_single := TRUE; v_id := ${v}::BIGINT; END IF;`);
+      where(v, `CASE WHEN ${n} THEN format('%I ${op} %L', ${lit(key)}, ${v}) ELSE ${asText === "FALSE" ? "'FALSE'" : `format('%I IS NOT NULL', ${lit(key)})`} END`);
+      if (op === "=") resolve.push(`IF ${v} IS NOT NULL THEN v_values := v_values || jsonb_build_object(${lit(key)}, ${v}); END IF;`);
       return;
     }
     if (def!.type === "integer") {
-      body.push(`IF ${v} IS NOT NULL THEN
+      check(`IF ${v} IS NOT NULL THEN
     IF ${v} !~ '${SAFE}' THEN ${refuse(`${key} must be an integer, not "%"`, v)}
     ELSIF abs(${v}::numeric) > 9007199254740991 THEN ${refuse(`${key} must be an integer, not "%"`, v)}
     END IF;
   END IF;`);
     } else if (def!.type === "real") {
-      body.push(`IF ${v} IS NOT NULL THEN
+      check(`IF ${v} IS NOT NULL THEN
     IF ${v} !~* '${REAL}' THEN ${refuse(`${key} must be a number, not "%"`, v)} END IF;
     BEGIN
       PERFORM ${v}::float8;
@@ -218,15 +252,20 @@ function scopeOf(schema: Schema, doc: DocDef): CompiledScope {
     END;
   END IF;`);
     } else if (def!.type === "timestamptz") {
-      body.push(dayOf(v, key));
+      check(dayOf(v, key, refuse));
     }
     conds.push(`(${v} IS NULL OR t.${q(key)} ${sqlOp} ${v}::${columnSqlType(def!)})`);
+    where(v, `format('%I ${op} %L', ${lit(key)}, ${v})`);
+    if (op === "=") resolve.push(`IF ${v} IS NOT NULL THEN v_values := v_values || jsonb_build_object(${lit(key)}, ${v}); END IF;`);
   });
-  return { declare, body: body.join("\n  "), conds: conds.join(" AND "), single: parsed.some((p) => p.key === "id" && p.op === "=") };
+  return {
+    declare, body: body.join("\n  "), conds: conds.join(" AND "), single: parsed.some((p) => p.key === "id" && p.op === "="),
+    checks: checks.join("\n  "), resolve: resolve.join("\n  "),
+  };
 }
 
 /** A date, YYYY-MM-DD, that the calendar has, read as the instant midnight UTC begins it; anything else refused. */
-function dayOf(v: string, key: string): string {
+function dayOf(v: string, key: string, refuse: Refuse): string {
   return `IF ${v} IS NOT NULL THEN
     v_date := regexp_match(${v}, '${DAY}');
     IF v_date IS NULL OR v_date[1]::int < 1 OR v_date[2]::int NOT BETWEEN 1 AND 12 THEN
@@ -239,20 +278,27 @@ function dayOf(v: string, key: string): string {
 }
 
 /** A document's function for `open_at`: the document as it stood at a time the caller gives. */
-export const openAtFunction = (prefix: string): string => openFunction(prefix).replace(/^dzql_open__/, "dzql_open_at__");
+export const openAtFunction = (prefix: string): string => named("open_at", prefix);
+
+/** A document's whole read, for the ledger: `dzql_open_whole__<slug>`. */
+export const openWholeFunction = (prefix: string): string => named("open_whole", prefix);
 
 /**
  * One document's read, as `open` (`delta_open`: the time is the name's, an implied
  * root opens with its defaults, the version is kept) or as `open_at`
  * (`delta_open_at`: the time is the caller's, a root not there is null, no version).
+ * `whole`: as `open`, every column of every row whatever columns the document
+ * names (`_delta_open(name, TRUE)`: what the ledger's inverse and a walk's guard
+ * read), with no `_as`.
  */
-function readOf(schema: Schema, doc: DocDef, at: boolean): string {
+export function readOf(schema: Schema, given: DocDef, at: boolean, whole = false): string {
+  const doc: DocDef = whole ? { ...given, columns: undefined } : given;
   const root = need(schema, doc, doc.root);
   const rootJson = rowOf(root, doc, doc.root, "t");
   const fields = (included: (coll: string) => string) =>
     doc.include.map((c) => ` || jsonb_build_object(${lit(c)}, ${included(c)})`).join("");
   const emptyIncludes = doc.include.map((c) => ` || jsonb_build_object(${lit(c)}, '{}'::jsonb)`).join("");
-  const fn = at ? openAtFunction(doc.prefix) : openFunction(doc.prefix);
+  const fn = whole ? openWholeFunction(doc.prefix) : at ? openAtFunction(doc.prefix) : openFunction(doc.prefix);
   const scope = scopeOf(schema, doc);
   const where = (first: string[]) => [...first, ...(scope.conds ? [scope.conds] : [])].join(" AND ") || "TRUE";
   const params = at ? "p_name TEXT, p_given TIMESTAMPTZ" : "p_name TEXT";
@@ -287,7 +333,7 @@ BEGIN
   END IF;` : ""}
   ${done}
 END;
-$$ LANGUAGE plpgsql;
+$$ LANGUAGE plpgsql;${whole ? "" : `
 
 CREATE OR REPLACE FUNCTION ${fn}_as(p_user_id TEXT, ${params})
 RETURNS JSONB AS $$
@@ -295,7 +341,7 @@ BEGIN
   PERFORM set_config('app.user_id', p_user_id, true);
   RETURN ${fn}(${at ? "p_name, p_given" : "p_name"});
 END
-$$ LANGUAGE plpgsql;`;
+$$ LANGUAGE plpgsql;`}`;
 }
 
 /** One document's reads: its open and its open_at, each with its `_as`. */

package/src/compile/resolve.ts

@@ -0,0 +1,75 @@
+/**
+ * Compiled scope resolution: a document's name read as its definition's scope
+ * reads it. Asked by every write (`delta_apply`: its mode, its root's id, the
+ * values an add to a list is given, the conditions its root must meet), by
+ * the framework's reads and by the ops log -- `_delta_resolve_scope`.
+ *
+ * `compileResolve(schema, docs)` writes `dzql_scope__<slug>(name, refuse)` for
+ * each document, giving the framework's answer exactly, as JSON: `where` (the
+ * conditions as SQL text, in the framework's words), `values` (the equality
+ * bindings), `mode` and `at`; a value its column cannot take refused with the
+ * same message (`scopeOf`), raised, or with `refuse` false answered as the
+ * scope that holds nothing. And `_delta_resolve_scope` itself, which sends each
+ * document to its own and refuses a name of none (`no doc def for`: the framework that read the rest
+ * retired, todo #26).
+ */
+import type { DocDef, Schema } from "@blueshed/delta/backend";
+import { lit, named, need, noDoc, scopeOf } from "./opens";
+
+/** A document's scope function: `dzql_scope__<slug>`. */
+export const resolveFunction = (prefix: string): string => named("scope", prefix);
+
+/** Refused: raised (22P02), or with `p_refuse` false, the scope that holds nothing, naming why. */
+const refuse = (message: string, value: string): string => {
+  const m = message.replace(/'/g, "''");
+  return `IF p_refuse THEN RAISE EXCEPTION '${m}', ${value} USING ERRCODE = '22P02'; END IF;
+      RETURN jsonb_build_object('where', 'FALSE', 'values', '{}'::jsonb, 'mode', 'list', 'at', NULL, 'refused', format('${m.replace(/%/g, "%s")}', ${value}));`;
+};
+
+/** One document's scope function. */
+function resolveOf(schema: Schema, doc: DocDef): string {
+  need(schema, doc, doc.root);
+  const head = `CREATE OR REPLACE FUNCTION ${resolveFunction(doc.prefix)}(p_name TEXT, p_refuse BOOLEAN)
+RETURNS JSONB AS $$`;
+  if (Object.keys(doc.scope ?? {}).length === 0) {
+    // no scope: a name with nothing after its prefix is the list; else the one row its id names
+    return `${head}
+DECLARE
+  v_rest TEXT := substring(p_name FROM ${doc.prefix.length + 1});
+BEGIN
+  IF v_rest = '' THEN
+    RETURN jsonb_build_object('where', 'TRUE', 'values', '{}'::jsonb, 'mode', 'list', 'at', NULL);
+  END IF;
+  RETURN jsonb_build_object('where', format('id = %L', v_rest), 'values', jsonb_build_object('id', v_rest::BIGINT), 'mode', 'single', 'at', NULL);
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+  }
+  const scope = scopeOf(schema, doc, refuse);
+  return `${head}
+DECLARE
+  v_where  TEXT := '';
+  v_values JSONB := '{}'::jsonb;
+  v_at     TEXT;
+  ${scope.declare.join("\n  ")}
+BEGIN
+  ${scope.checks}
+  ${scope.resolve}
+  IF v_where = '' THEN v_where := 'TRUE'; END IF;
+  RETURN jsonb_build_object('where', v_where, 'values', v_values, 'mode', CASE WHEN v_values ? 'id' THEN 'single' ELSE 'list' END, 'at', v_at);
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+}
+
+/** The SQL that resolves each of `docs`' names: a function per document, and `_delta_resolve_scope` sending each to its own. */
+export function compileResolve(schema: Schema, docs: DocDef[]): string {
+  const dispatch = `CREATE OR REPLACE FUNCTION _delta_resolve_scope(p_def _delta_docs, p_doc_name TEXT, p_refuse BOOLEAN)
+RETURNS JSONB AS $$
+BEGIN
+  CASE p_def.prefix
+${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${resolveFunction(d.prefix)}(p_doc_name, p_refuse);`).join("\n")}
+    ELSE ${noDoc("p_doc_name")}
+  END CASE;
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+  return [...docs.map((d) => resolveOf(schema, d)), dispatch, ""].join("\n\n");
+}

package/src/compile/root.ts

@@ -0,0 +1,61 @@
+/**
+ * Compiled root check: is a single document's root row there now, meeting the
+ * whole of its name's scope? Asked before each op of a write (`delta_apply`),
+ * so a document whose root is gone takes no writes.
+ *
+ * `compileRootThere(schema, docs)` writes `dzql_root_there__<slug>(name, id)`
+ * for each document, answering what the framework's `_delta_root_there`
+ * answers, from its definition: the name's values read and checked
+ * (`scopeOf`, refused with the same message), and the root's current rows
+ * asked with its conditions written as typed SQL, where the framework runs
+ * the resolver's conditions as text. And `_delta_root_there` itself, which
+ * sends each document to its own and refuses a name of none (`no doc def for`: the framework that read the rest
+ * retired, todo #26).
+ */
+import type { DocDef, Schema } from "@blueshed/delta/backend";
+import { lit, named, need, noDoc, scopeOf, standingRows } from "./opens";
+
+/** A document's root check: `dzql_root_there__<slug>`. */
+export const rootThereFunction = (prefix: string): string => named("root_there", prefix);
+
+/** One document's root check. */
+function rootThereOf(schema: Schema, doc: DocDef): string {
+  const root = need(schema, doc, doc.root);
+  const rows = standingRows(root);   // the root's rows as they stand, as the framework's view reads them
+  const head = `CREATE OR REPLACE FUNCTION ${rootThereFunction(doc.prefix)}(p_name TEXT, p_id BIGINT)
+RETURNS BOOLEAN AS $$`;
+  if (Object.keys(doc.scope ?? {}).length === 0) {
+    // no scope: a name with an id is that row (the framework's `id = '<id>'`), one without, any
+    return `${head}
+DECLARE
+  v_rest TEXT := substring(p_name FROM ${doc.prefix.length + 1});
+BEGIN
+  IF v_rest = '' THEN RETURN EXISTS (SELECT 1 FROM ${rows} t WHERE t.id = p_id); END IF;
+  RETURN EXISTS (SELECT 1 FROM ${rows} t WHERE t.id = p_id AND t.id = v_rest::BIGINT);
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+  }
+  const scope = scopeOf(schema, doc);
+  return `${head}
+DECLARE
+  ${scope.declare.join("\n  ")}
+BEGIN
+  ${scope.checks}
+  RETURN EXISTS (SELECT 1 FROM ${rows} t WHERE t.id = p_id${scope.conds ? ` AND ${scope.conds}` : ""});
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+}
+
+/** The SQL that answers whether each of `docs`' root is there: a function per document, and `_delta_root_there` sending each to its own. */
+export function compileRootThere(schema: Schema, docs: DocDef[]): string {
+  const dispatch = `CREATE OR REPLACE FUNCTION _delta_root_there(p_def _delta_docs, p_doc_name TEXT, p_scope JSONB, p_view TEXT, p_id BIGINT)
+RETURNS BOOLEAN AS $$
+BEGIN
+  CASE p_def.prefix
+${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${rootThereFunction(d.prefix)}(p_doc_name, p_id);`).join("\n")}
+    ELSE ${noDoc("p_doc_name")}
+  END CASE;
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+  return [...docs.map((d) => rootThereOf(schema, d)), dispatch, ""].join("\n\n");
+}

package/src/compile/rows.ts

@@ -0,0 +1,123 @@
+/**
+ * Compiled row SQL: the statements a write runs on a row, written for each
+ * collection. The framework builds each from the table's name at run time
+ * (`EXECUTE format(...)`), planned again on every call; written out, each is a
+ * statement whose plan the database keeps.
+ *
+ * `compileRows(schema)` writes, for every collection of the schema:
+ * - `_delta_row_lock`: the row as it stands (a temporal one's open version),
+ *   locked for the write;
+ * - `_delta_row_put`: a replace's row stored -- a temporal one a new version
+ *   (one this write made gives way to it, the standing one closes), else the
+ *   row again -- answered as stored;
+ * - `_delta_next_id`: an add's id, from the collection's sequence;
+ * - `_delta_row_clear_moment`: a temporal version this write made and took
+ *   back, so an add of its id takes its place;
+ * - `_delta_row_there`: is the row there now (a temporal one's open version)?
+ * - `_delta_row_read`: the row as it stands, without its validity;
+ * - `_delta_row_add`: an add's row stored. An INSERT names the columns the row
+ *   gives (`_delta_insert_sql`), so one it leaves out takes its database
+ *   default: where the row gives exactly every column the schema declares (its
+ *   id, parent key, columns and validity), that INSERT is one statement,
+ *   written here; a row with any other keys is stored by the columns it gives
+ *   (`_delta_row_add_given`).
+ *
+ * Each answers what the framework's did. A collection none was compiled for is
+ * refused (`unknown collection`), and a row of it is not there.
+ */
+import { q, type Schema } from "@blueshed/delta/backend";
+import { lit, noCollection, standingRows } from "./opens";
+
+/** A CASE over the collections, each branch from `branch`, any other collection to `fallback`. */
+function dispatch(schema: Schema, branch: (coll: string, table: Schema["tables"][string]) => string | null, fallback: string): string {
+  const branches = Object.entries(schema.tables).flatMap(([coll, table]) => {
+    const b = branch(coll, table);
+    return b === null ? [] : [`    WHEN ${lit(coll)} THEN\n      ${b}`];
+  });
+  return branches.length ? `  CASE p_coll\n${branches.join("\n")}\n    ELSE ${fallback}\n  END CASE;` : `  ${fallback}`;
+}
+
+/** The row SQL of every collection of `schema`, and its dispatch. */
+export function compileRows(schema: Schema): string {
+  const lock = `CREATE OR REPLACE FUNCTION _delta_row_lock(p_coll TEXT, p_table TEXT, p_temporal BOOLEAN, p_id BIGINT)
+RETURNS JSONB AS $$
+DECLARE
+  v_row JSONB;
+BEGIN
+${dispatch(schema, (_, t) => `SELECT to_jsonb(t.*) INTO v_row FROM ${q(t.name)} t WHERE t.id = p_id${t.temporal ? " AND valid_to IS NULL" : ""} FOR UPDATE;
+      RETURN v_row;`, noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql;`;
+
+  const put = `CREATE OR REPLACE FUNCTION _delta_row_put(p_coll TEXT, p_table TEXT, p_temporal BOOLEAN, p_id BIGINT, p_row JSONB, p_ts TIMESTAMPTZ)
+RETURNS JSONB AS $$
+DECLARE
+  v_row JSONB;
+BEGIN
+${dispatch(schema, (_, t) => (t.temporal
+    ? `DELETE FROM ${q(t.name)} WHERE id = p_id AND valid_to IS NULL AND valid_from = p_ts;
+      UPDATE ${q(t.name)} SET valid_to = p_ts WHERE id = p_id AND valid_to IS NULL;
+      INSERT INTO ${q(t.name)} AS t SELECT * FROM jsonb_populate_record(null::${q(t.name)}, p_row || jsonb_build_object('valid_from', p_ts, 'valid_to', NULL))
+        RETURNING to_jsonb(t.*) INTO v_row;
+      RETURN v_row;`
+    : `DELETE FROM ${q(t.name)} WHERE id = p_id;
+      INSERT INTO ${q(t.name)} AS t SELECT * FROM jsonb_populate_record(null::${q(t.name)}, p_row) RETURNING to_jsonb(t.*) INTO v_row;
+      RETURN v_row;`), noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql;`;
+
+  // the sequence named as the framework names it: nextval of the text 'seq_<table>'
+  const next = `CREATE OR REPLACE FUNCTION _delta_next_id(p_coll TEXT, p_table TEXT)
+RETURNS BIGINT AS $$
+BEGIN
+${dispatch(schema, (_, t) => `RETURN nextval(${lit(`seq_${t.name}`)});`, noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql;`;
+
+  const clear = `CREATE OR REPLACE FUNCTION _delta_row_clear_moment(p_coll TEXT, p_table TEXT, p_id BIGINT, p_ts TIMESTAMPTZ)
+RETURNS void AS $$
+BEGIN
+${dispatch(schema, (_, t) => (t.temporal ? `DELETE FROM ${q(t.name)} WHERE id = p_id AND valid_from = p_ts AND valid_to = p_ts;
+      RETURN;` : null), noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql;`;
+
+  const there = `CREATE OR REPLACE FUNCTION _delta_row_there(p_collection_key TEXT, p_id BIGINT)
+RETURNS BOOLEAN AS $$
+DECLARE
+  p_coll TEXT := p_collection_key;
+BEGIN
+${dispatch(schema, (_, t) => `RETURN p_id IS NOT NULL AND EXISTS (SELECT 1 FROM ${standingRows(t)} WHERE id = p_id);`,
+    "RETURN FALSE;   -- a collection there is not: no row of it is there")}
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+
+  const read = `CREATE OR REPLACE FUNCTION _delta_row_read(p_coll TEXT, p_view TEXT, p_id BIGINT)
+RETURNS JSONB AS $$
+DECLARE
+  v_row JSONB;
+BEGIN
+${dispatch(schema, (_, t) => `SELECT _delta_strip_temporal(to_jsonb(t.*)) INTO v_row FROM ${standingRows(t)} t WHERE t.id = p_id;
+      RETURN v_row;`, noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql STABLE;`;
+
+  const add = `CREATE OR REPLACE FUNCTION _delta_row_add(p_coll TEXT, p_table TEXT, p_row JSONB)
+RETURNS JSONB AS $$
+DECLARE
+  v_row JSONB;
+BEGIN
+${dispatch(schema, (_, t) => {
+    const keys = [...new Set(["id", ...(t.parent ? [t.parent.fkColumn] : []), ...Object.keys(t.columns), ...(t.temporal ? ["valid_from", "valid_to"] : [])])];
+    const cols = keys.map((k) => q(k)).join(", ");
+    return `IF p_row ?& ARRAY[${keys.map(lit).join(", ")}] AND (SELECT count(*) FROM jsonb_object_keys(p_row)) = ${keys.length} THEN
+        INSERT INTO ${q(t.name)} AS t (${cols}) SELECT ${cols} FROM jsonb_populate_record(null::${q(t.name)}, p_row) RETURNING to_jsonb(t.*) INTO v_row;
+        RETURN v_row;
+      END IF;
+      RETURN _delta_row_add_given(p_table, p_row);   -- some other set of keys: the INSERT names those it gives`;
+  }, noCollection("p_coll"))}
+END;
+$$ LANGUAGE plpgsql;`;
+
+  return [lock, put, next, clear, there, read, add, ""].join("\n\n");
+}