dzql 0.10.0 → 0.11.0

package/README.md

@@ -20,12 +20,12 @@ import { openPglite } from "dzql/pglite";   // Postgres in this process
 import { jwtAuth } from "dzql/auth-jwt";
 ```
 
-Its tests run delta's own cases (`@blueshed/delta/testing`) against it. Compiled SQL is replacing
-the framework SQL a piece at a time: `generateSql` writes functions for each of your documents
-(opening it, reading its name, who holds a row, a write's scope, what each document is told, the
-fan-out), each held equal to the framework's; documents it did not compile go to the framework. Apply `generateSql`
-after the framework, every time (`docs/delta/postgres.md`, "Compiled SQL"). The plan is in
-Workshop's `docs/postgres-split-plan.md`.
+Its tests run delta's own cases (`@blueshed/delta/testing`) against it. `generateSql` writes the
+SQL for each of your documents and collections, compiled from their definitions (opening a
+document, reading its name, who holds a row, a write's scope and rows, what each document is told,
+the fan-out, the ledger's reads): nothing interprets a definition at run time. Apply it after the
+framework, every time, one app per database (`docs/delta/postgres.md`, "Compiled SQL"). The plan
+is in Workshop's `docs/postgres-split-plan.md`.
 
 ## The whole-stack dzql (retiring)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "delta's compiled Postgres step: an app's delta definitions compiled to SQL",
   "repository": {
     "type": "git",

package/src/compile/cascades.ts

@@ -13,8 +13,8 @@
  * - `dzql_hanging_rows__<slug>(id)`: the rows that hang from it, and on down,
  *   parent first.
  * And `_delta_cascade_remove`, `_delta_cascade_rows` and `_delta_hanging_rows`,
- * sending each collection to its own and any other to the framework's
- * (`_framework`). The order is the framework's: child collections by key, then
+ * sending each collection to its own; a collection there is not has nothing
+ * to take. The order is the one the framework's had: child collections by key, then
  * the collections that cascade on it by key and key column, each in the
  * database's byte order (`COLLATE "C"`), and each one's rows by id.
  */
@@ -118,15 +118,15 @@ END;
 $$ LANGUAGE plpgsql STABLE;`;
 }
 
-/** A dispatcher: each collection of `schema` to its own, any other to the framework's. */
+/** A dispatcher: each collection of `schema` to its own; any other has nothing to take. */
 function dispatch(schema: Schema, name: string, what: string, volatility: string): string {
   const colls = Object.keys(schema.tables);
   const body = colls.length
     ? `  CASE p_collection_key
 ${colls.map((c) => `    WHEN ${lit(c)} THEN RETURN ${fn(what, c)}(p_id);`).join("\n")}
-    ELSE RETURN ${name}_framework(p_collection_key, p_id);
+    ELSE RETURN '[]'::jsonb;   -- a collection there is not: nothing to take, nothing hangs from it
   END CASE;`
-    : `  RETURN ${name}_framework(p_collection_key, p_id);`;
+    : `  RETURN '[]'::jsonb;`;
   return `CREATE OR REPLACE FUNCTION ${name}(p_collection_key TEXT, p_id BIGINT)
 RETURNS JSONB AS $$
 BEGIN
@@ -135,7 +135,7 @@ END;
 $$ LANGUAGE plpgsql${volatility};`;
 }
 
-/** The cascades and hanging rows of every collection of `schema`, and the dispatch to the framework's for any other. */
+/** The cascades and hanging rows of every collection of `schema`, and their dispatch. */
 export function compileCascades(schema: Schema): string {
   assertSlugs(schema);
   const colls = Object.keys(schema.tables);

package/src/compile/columns.ts

@@ -10,19 +10,18 @@
  *
  * - `dzql_columns__<slug>(collection, columns_def)` for each document: the
  *   columns it writes, the ones it names (`columns`) where it names some,
- *   from the list written in. `_delta_write_columns` sends each compiled
- *   document to its own, any other to the framework
- *   (`_delta_write_columns_framework`).
+ *   from the list written in. `_delta_write_columns` sends each document to
+ *   its own, and refuses a name of none.
  * - `_delta_assert_fields` itself: for each collection, each set of columns
  *   the definitions give it (all of them, and each document's own), checked
  *   by written statements -- the fields there are, the parent key, each
  *   column's type -- with the framework's messages, put together in the
  *   framework's order (`ORDER BY` in SQL, so the database's collation orders
  *   both alike). Columns of another set (a walk's, another version's) are
- *   checked by the framework's (`_delta_assert_fields_framework`).
+ *   checked by the columns given (`_delta_assert_fields_declared`).
  */
 import type { ColumnDef, DocDef, ResolvedTable, Schema } from "@blueshed/delta/backend";
-import { lit, named, need } from "./opens";
+import { lit, named, need, noDoc } from "./opens";
 
 /** A document's columns function: `dzql_columns__<slug>`. */
 export const columnsFunction = (prefix: string): string => named("columns", prefix);
@@ -105,7 +104,7 @@ RETURNS JSONB AS $$
 BEGIN
   CASE p_def.prefix
 ${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${columnsFunction(d.prefix)}(p_coll, p_columns_def);`).join("\n")}
-    ELSE RETURN _delta_write_columns_framework(p_def, p_coll, p_columns_def);
+    ELSE ${noDoc("p_def.prefix")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;
@@ -136,8 +135,8 @@ BEGIN
 ${branches.join("\n")}
     ELSE NULL;
   END CASE;
-  -- another set of columns (a walk's, another version's): the framework's
-  PERFORM _delta_assert_fields_framework(p_collection, p_columns, p_parent_fk, p_value);
+  -- another set of columns (a walk's, another version's): by the columns given
+  PERFORM _delta_assert_fields_declared(p_collection, p_columns, p_parent_fk, p_value);
 END;
 $$ LANGUAGE plpgsql IMMUTABLE;`;
   return [...docs.map((d) => columnsOf(schema, d)), dispatch, checks, ""].join("\n\n");

package/src/compile/holders.ts

@@ -10,10 +10,9 @@
  * row hangs from, its chain written as lookups, where the document is one row
  * of an unscoped definition; else every open name of its prefix), and the
  * writer's; each name its own prefix owns and whose document holds the row
- * (`dzql_holds__<slug>`). Any other document (registered by hand, or by another
- * `generateSql`) is asked by the framework's (`_delta_holders_framework`), told
- * which prefixes were asked already. SECURITY DEFINER, with the search path it
- * was applied with and pg_temp last, as the framework's.
+ * (`dzql_holds__<slug>`). There is no other document: the framework that asked
+ * the rest retired (todo #26). SECURITY DEFINER, with the search path it was
+ * applied with and pg_temp last, as the framework's was.
  */
 import type { DocDef, Schema } from "@blueshed/delta/backend";
 import { chainRoot, holdsFunction } from "./holds";
@@ -39,13 +38,12 @@ ${all ? "" : `      v_rid := ${coll === doc.root ? "(p_row->>'id')::BIGINT" : ch
       END LOOP;`;
 }
 
-/** The SQL that answers who holds a row: `_delta_holders`, each of `docs` asked by its own lookups, any other by the framework's. */
+/** The SQL that answers who holds a row: `_delta_holders`, each of `docs` asked by its own lookups. */
 export function compileHolders(schema: Schema, docs: DocDef[]): string {
   const branches = Object.keys(schema.tables).flatMap((coll) => {
     const holding = docs.filter((d) => d.root === coll || d.include.includes(coll));
     return holding.length ? [`    WHEN ${lit(coll)} THEN\n${holding.map((d) => askOf(schema, d, coll)).join("\n")}`] : [];
   });
-  const asked = `ARRAY[${docs.map((d) => lit(d.prefix)).join(", ")}]::text[]`;
   return `CREATE OR REPLACE FUNCTION _delta_holders(p_coll TEXT, p_row JSONB, p_writer TEXT)
 RETURNS TEXT[] AS $$
 DECLARE
@@ -58,11 +56,7 @@ BEGIN
       upper(current_setting('transaction_isolation')) USING ERRCODE = '0A000';
   END IF;
   IF p_row IS NULL THEN RETURN v_names; END IF;
-${branches.length ? `  CASE p_coll\n${branches.join("\n")}\n    ELSE NULL;\n  END CASE;\n` : ""}  -- the documents not compiled here, as the framework asks them
-  IF EXISTS (SELECT 1 FROM _delta_docs WHERE (root_collection = p_coll OR p_coll = ANY(include)) AND NOT (prefix = ANY(${asked}))) THEN
-    v_names := v_names || _delta_holders_framework(p_coll, p_row, p_writer, ${asked});
-  END IF;
-  RETURN v_names;
+${branches.length ? `  CASE p_coll\n${branches.join("\n")}\n    ELSE NULL;\n  END CASE;\n` : ""}  RETURN v_names;
 END;
 $$ LANGUAGE plpgsql VOLATILE SECURITY DEFINER;
 DO $$ BEGIN

package/src/compile/holds.ts

@@ -10,12 +10,11 @@
  * (`scopeOf`, a name its columns cannot take holding nothing), a temporal row
  * not told to a document named with a time past, and an included row's chain
  * of parents up to the root, as written lookups. And `_delta_doc_holds`
- * itself, which sends each compiled document to its function and any other
- * (registered by hand, or by another `generateSql`) to the framework's
- * (`_delta_doc_holds_framework`).
+ * itself, which sends each document to its function and refuses a name of none (`no doc def for`: the framework that read the rest
+ * retired, todo #26).
  */
 import { q, type DocDef, type ResolvedTable, type Schema } from "@blueshed/delta/backend";
-import { lit, named, need, scopeOf , currentOnly } from "./opens";
+import { lit, named, need, noDoc, scopeOf, currentOnly } from "./opens";
 
 /** A document's holds function: `dzql_holds__<slug>`. */
 export const holdsFunction = (prefix: string): string => named("holds", prefix);
@@ -83,7 +82,7 @@ RETURNS BOOLEAN AS $$
 BEGIN
   CASE p_def.prefix
 ${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${holdsFunction(d.prefix)}(p_doc_name, p_coll, p_row);`).join("\n")}
-    ELSE RETURN _delta_doc_holds_framework(p_def, p_doc_name, p_coll, p_row);
+    ELSE ${noDoc("p_doc_name")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

package/src/compile/ledger.ts

@@ -8,17 +8,16 @@
  * - `dzql_open_whole__<slug>(name)` for each document: its open with every
  *   column of every row, whatever columns it names (`readOf`, whole), and
  *   `_delta_open` itself, sending each compiled document to its own open, shown
- *   (`dzql_open__<slug>`) or whole, and any other to the framework's
- *   (`_delta_open_framework`);
+ *   (`dzql_open__<slug>`) or whole, and refusing a name of none;
  * - `_delta_same(collection, field, a, b)`: two values of a field the same, a
  *   time by the instant it names. The field's type is the writing process's
  *   (`delta.declared`), else the schema's, written in for each collection;
- *   any other collection is the framework's (`_delta_same_framework`);
+ *   a collection there is not, the same as JSON;
  * - `_delta_row_standing(collection, id)`: a row as it stands, as `{row}`, for
- *   every collection of the schema; any other the framework's.
+ *   every collection of the schema; NULL for one there is not.
  */
 import type { DocDef, Schema } from "@blueshed/delta/backend";
-import { lit, openFunction, openWholeFunction, readOf, standingRows } from "./opens";
+import { lit, noDoc, openFunction, openWholeFunction, readOf, standingRows } from "./opens";
 
 /** The SQL the ledger reads by, for `schema` and each of `docs`. */
 export function compileLedger(schema: Schema, docs: DocDef[]): string {
@@ -31,7 +30,7 @@ DECLARE
 BEGIN
   CASE v_def.prefix
 ${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN CASE WHEN p_whole THEN ${openWholeFunction(d.prefix)}(p_doc_name) ELSE ${openFunction(d.prefix)}(p_doc_name) END;`).join("\n")}
-    ELSE RETURN _delta_open_framework(p_doc_name, p_whole);   -- a name no document compiled here holds (none at all: the framework refuses it)
+    ELSE ${noDoc("p_doc_name")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql;`;
@@ -51,7 +50,7 @@ ${colls.map(([coll, t]) => {
         v_declared := NULLIF(current_setting('delta.declared', true), '')::jsonb -> ${lit(coll)};
         v_type := CASE WHEN v_declared IS NOT NULL THEN v_declared -> p_field ->> 'type'${times.length ? ` WHEN p_field IN (${times.map(lit).join(", ")}) THEN 'timestamptz'` : ""} END;`;
   }).join("\n")}
-      ELSE RETURN _delta_same_framework(p_coll, p_field, a, b);
+      ELSE NULL;   -- a collection there is not: its values the same as JSON
     END CASE;
     IF v_type = 'timestamptz' THEN RETURN (a #>> '{}')::timestamptz = (b #>> '{}')::timestamptz; END IF;
   END IF;
@@ -64,7 +63,7 @@ RETURNS JSONB AS $$
 BEGIN
   CASE p_coll
 ${colls.map(([coll, t]) => `    WHEN ${lit(coll)} THEN RETURN jsonb_build_object('row', (SELECT _delta_strip_temporal(to_jsonb(t.*)) FROM ${standingRows(t)} t WHERE t.id = p_id));`).join("\n")}
-    ELSE RETURN _delta_row_standing_framework(p_coll, p_id);
+    ELSE RETURN NULL;   -- a collection there is not
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

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

@@ -27,6 +27,12 @@ import { columnSqlType } from "../postgres/sql";
 /** A string as an SQL literal. */
 export const lit = (s: string): string => `'${s.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, "")}`;

package/src/compile/resolve.ts

@@ -10,11 +10,11 @@
  * 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
- * compiled document to its own and any other to the framework
- * (`_delta_resolve_scope_framework`).
+ * 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, scopeOf } from "./opens";
+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);
@@ -67,7 +67,7 @@ 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 RETURN _delta_resolve_scope_framework(p_def, p_doc_name, p_refuse);
+    ELSE ${noDoc("p_doc_name")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

package/src/compile/root.ts

@@ -9,11 +9,11 @@
  * (`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 compiled document to its own and any other to the framework
- * (`_delta_root_there_framework`).
+ * 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, scopeOf, standingRows } from "./opens";
+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);
@@ -53,7 +53,7 @@ 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 RETURN _delta_root_there_framework(p_def, p_doc_name, p_scope, p_view, p_id);
+    ELSE ${noDoc("p_doc_name")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

package/src/compile/rows.ts

@@ -15,17 +15,18 @@
  *   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. The framework's 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 the framework's.
+ * - `_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 (`_framework`) answers, and sends any
- * collection it was not compiled for there.
+ * 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, standingRows } from "./opens";
+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 {
@@ -36,7 +37,7 @@ function dispatch(schema: Schema, branch: (coll: string, table: Schema["tables"]
   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 the dispatch to the framework's for any other. */
+/** 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 $$
@@ -44,7 +45,7 @@ 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;`, "RETURN _delta_row_lock_framework(p_coll, p_table, p_temporal, p_id);")}
+      RETURN v_row;`, noCollection("p_coll"))}
 END;
 $$ LANGUAGE plpgsql;`;
 
@@ -61,7 +62,7 @@ ${dispatch(schema, (_, t) => (t.temporal
       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;`), "RETURN _delta_row_put_framework(p_coll, p_table, p_temporal, p_id, p_row, p_ts);")}
+      RETURN v_row;`), noCollection("p_coll"))}
 END;
 $$ LANGUAGE plpgsql;`;
 
@@ -69,7 +70,7 @@ $$ LANGUAGE plpgsql;`;
   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}`)});`, "RETURN _delta_next_id_framework(p_coll, p_table);")}
+${dispatch(schema, (_, t) => `RETURN nextval(${lit(`seq_${t.name}`)});`, noCollection("p_coll"))}
 END;
 $$ LANGUAGE plpgsql;`;
 
@@ -77,7 +78,7 @@ $$ LANGUAGE plpgsql;`;
 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), "PERFORM _delta_row_clear_moment_framework(p_coll, p_table, p_id, p_ts);")}
+      RETURN;` : null), noCollection("p_coll"))}
 END;
 $$ LANGUAGE plpgsql;`;
 
@@ -87,7 +88,7 @@ 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 _delta_row_there_framework(p_collection_key, p_id);")}
+    "RETURN FALSE;   -- a collection there is not: no row of it is there")}
 END;
 $$ LANGUAGE plpgsql STABLE;`;
 
@@ -97,7 +98,7 @@ 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;`, "RETURN _delta_row_read_framework(p_coll, p_view, p_id);")}
+      RETURN v_row;`, noCollection("p_coll"))}
 END;
 $$ LANGUAGE plpgsql STABLE;`;
 
@@ -113,8 +114,8 @@ ${dispatch(schema, (_, t) => {
         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_framework(p_coll, p_table, p_row);`;
-  }, "RETURN _delta_row_add_framework(p_coll, p_table, p_row);")}
+      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;`;
 

package/src/compile/scope.ts

@@ -10,11 +10,12 @@
  * its included collections whole and its root rows by the name's conditions;
  * a single document holds a row whose parent chain, walked up through the
  * tables as they stand, reaches its root, which meets the rest of its name's
- * scope. And `_delta_row_in_scope` itself, which sends each compiled document
- * to its own and any other to the framework (`_delta_row_in_scope_framework`).
+ * scope. And `_delta_row_in_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 { q, type DocDef, type Schema } from "@blueshed/delta/backend";
-import { lit, named, need, scopeOf , currentOnly } from "./opens";
+import { lit, named, need, noDoc, scopeOf, currentOnly } from "./opens";
 
 /** A document's write-scope function: `dzql_in_scope__<slug>`. */
 export const inScopeFunction = (prefix: string): string => named("in_scope", prefix);
@@ -79,7 +80,7 @@ RETURNS BOOLEAN AS $$
 BEGIN
   CASE p_def.prefix
 ${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${inScopeFunction(d.prefix)}(p_doc_name, p_collection_key, p_id);`).join("\n")}
-    ELSE RETURN _delta_row_in_scope_framework(p_def, p_doc_name, p_collection_key, p_id);
+    ELSE ${noDoc("p_doc_name")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

package/src/compile/told.ts

@@ -8,11 +8,12 @@
  * definition: whether the name makes it one row (`scopeOf`), its root, the
  * columns it shows of each collection it names them for (`columns`, the row's
  * id and parent key with them), and the empty root an implied one opens with
- * when its root leaves. And `_delta_told` itself, which sends each compiled
- * document to its own and any other to the framework (`_delta_told_framework`).
+ * when its root leaves. And `_delta_told` 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, scopeOf } from "./opens";
+import { lit, named, need, noDoc, scopeOf } from "./opens";
 
 /** A document's telling function: `dzql_told__<slug>`. */
 export const toldFunction = (prefix: string): string => named("told", prefix);
@@ -86,7 +87,7 @@ RETURNS JSONB AS $$
 BEGIN
   CASE p_def.prefix
 ${docs.map((d) => `    WHEN ${lit(d.prefix)} THEN RETURN ${toldFunction(d.prefix)}(p_target, p_rows);`).join("\n")}
-    ELSE RETURN _delta_told_framework(p_def, p_target, p_rows);
+    ELSE ${noDoc("p_target")}
   END CASE;
 END;
 $$ LANGUAGE plpgsql STABLE;`;

package/src/postgres/codegen.ts

@@ -36,6 +36,7 @@ import { compileColumns } from "../compile/columns";
 import { compileRows } from "../compile/rows";
 import { compileCascades } from "../compile/cascades";
 import { compileLedger } from "../compile/ledger";
+import { compileLookups } from "../compile/lookups";
 import { compileTold } from "../compile/told";
 
 export interface GenerateSqlOptions {
@@ -180,6 +181,6 @@ export function generateSql(
   lines.push("");
 
   // each document opened by SQL compiled for it (dzql), which docTypeFromDef calls
-  lines.push("", compileOpens(schema, docs), "", compileHolds(schema, docs), "", compileInScope(schema, docs), "", compileTold(schema, docs), "", compileHolders(schema, docs), "", compileResolve(schema, docs), "", compileRootThere(schema, docs), "", compileColumns(schema, docs), "", compileRows(schema), "", compileCascades(schema), "", compileLedger(schema, docs));
+  lines.push("", compileOpens(schema, docs), "", compileHolds(schema, docs), "", compileInScope(schema, docs), "", compileTold(schema, docs), "", compileHolders(schema, docs), "", compileResolve(schema, docs), "", compileRootThere(schema, docs), "", compileColumns(schema, docs), "", compileRows(schema), "", compileCascades(schema), "", compileLedger(schema, docs), "", compileLookups(schema, docs));
   return lines.join("\n");
 }