@coda-console/kernel 0.2.1 → 0.3.0

package/src/schema.mjs

@@ -1,9 +1,13 @@
 // The kernel's tables and every statement it runs on them. Keeping the statements in one place lets a test check the
 // query plan of each one: none of them may scan a table.
 
+const UNENDED_CALL = "state IN ('sending', 'open')";
+const UNENDED_RUN = "status IN ('working', 'input-required')";
+
 // Entry n upgrades the schema from version n to n + 1. Migrations only go forward: the first entry is the 0.1.0 baseline,
 // and no entry changes once released, since a database already past it would never run it again. A changed table adds
-// an entry at the end.
+// an entry at the end. An entry is SQL text, or a function of the host's now() giving it, for one that needs the time it
+// runs at.
 export const MIGRATIONS = [
   `CREATE TABLE kernel_calls (
      from_addr TEXT NOT NULL,
@@ -98,13 +102,20 @@ export const MIGRATIONS = [
    CREATE INDEX kernel_outbox_lane ON kernel_outbox (lane, pos);
    CREATE INDEX kernel_outbox_call ON kernel_outbox (call_from, call_id);
    CREATE INDEX kernel_outbox_from ON kernel_outbox (from_addr, pos);`,
+  // 0.3.0: since when an ended call or run has been kept only to tell a repeat, by the host's clock, for forget() (9).
+  // A row that ended before this migration counts from it: by the host's clock, not SQLite's, as a simulated world's is
+  // not real; a letter about it still owed moves it on once confirmed. Like the rest of a migration, the backfill is no
+  // statement of SQL: it visits every row, once.
+  now => `ALTER TABLE kernel_calls ADD COLUMN quiet_at INTEGER;
+   ALTER TABLE kernel_runs ADD COLUMN quiet_at INTEGER;
+   UPDATE kernel_calls SET quiet_at = ${now} WHERE NOT (${UNENDED_CALL});
+   UPDATE kernel_runs SET quiet_at = ${now} WHERE NOT (${UNENDED_RUN});
+   CREATE INDEX kernel_calls_quiet ON kernel_calls (quiet_at);
+   CREATE INDEX kernel_runs_quiet ON kernel_runs (quiet_at);`,
 ];
 
 export const META = 'CREATE TABLE IF NOT EXISTS kernel_meta (key TEXT PRIMARY KEY, value INTEGER NOT NULL)';
 
-const UNENDED_CALL = "state IN ('sending', 'open')";
-const UNENDED_RUN = "status IN ('working', 'input-required')";
-
 export const SQL = {
   version: "SELECT value FROM kernel_meta WHERE key = 'version'",
   setVersion: "INSERT INTO kernel_meta (key, value) VALUES ('version', ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
@@ -112,30 +123,46 @@ export const SQL = {
   call: 'SELECT * FROM kernel_calls WHERE from_addr = ? AND id = ?',
   addCall: `INSERT INTO kernel_calls (from_addr, id, to_addr, op, digest, input, parent, lane, by_from, by_id, awaited, memo, state)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'sending')`,
+  // An imported call was taken already: open, at version 0, so that the first status its reread hears is newer.
+  adoptCall: `INSERT INTO kernel_calls (from_addr, id, to_addr, op, digest, input, parent, lane, by_from, by_id, awaited, memo, state, status, rev)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', 'working', 0) RETURNING *`,
   // A receipt says the callee took the call; the run it took is working at version 1 (C6).
   openCall: "UPDATE kernel_calls SET state = 'open', status = 'working', rev = 1 WHERE from_addr = ? AND id = ? AND state = 'sending'",
   hearCall: "UPDATE kernel_calls SET state = 'open', status = ?, rev = ?, asked = ?, asking = ?, progress = ? WHERE from_addr = ? AND id = ? RETURNING *",
-  endCall: 'UPDATE kernel_calls SET state = ?, result = ?, error = ?, progress = ?, owed = 1, local = ? WHERE from_addr = ? AND id = ?',
+  endCall: 'UPDATE kernel_calls SET state = ?, result = ?, error = ?, progress = ?, owed = 1, local = ?, quiet_at = ? WHERE from_addr = ? AND id = ?',
   paidCall: 'UPDATE kernel_calls SET owed = 0 WHERE from_addr = ? AND id = ?',
   owedCalls: 'SELECT from_addr, id FROM kernel_calls WHERE owed = 1',
   openCalls: "SELECT * FROM kernel_calls WHERE state = 'open'",
   detach: 'UPDATE kernel_calls SET awaited = 0 WHERE from_addr = ? AND id = ?',
   // The caller ends the call itself and takes no result from it; a late outcome is kept apart (C12).
-  abandonCall: "UPDATE kernel_calls SET state = 'failed', error = ?, local = 1, abandoned = 1 WHERE from_addr = ? AND id = ?",
+  abandonCall: "UPDATE kernel_calls SET state = 'failed', error = ?, local = 1, abandoned = 1, quiet_at = ? WHERE from_addr = ? AND id = ?",
   lateCall: 'UPDATE kernel_calls SET late = ?, owed = 1 WHERE from_addr = ? AND id = ?',
+  // A letter about an ended call or run has just left the outbox: a repeat of it may come until its retention (9).
+  quietCall: 'UPDATE kernel_calls SET quiet_at = ? WHERE from_addr = ? AND id = ? AND quiet_at IS NOT NULL',
   awaiting: `SELECT * FROM kernel_calls WHERE by_from = ? AND by_id = ? AND awaited = 1 AND ${UNENDED_CALL}`,
   calls: `SELECT * FROM kernel_calls WHERE from_addr = ? AND ${UNENDED_CALL} AND state = coalesce(?, state)`,
+  // An ended call whose handler has committed and about which no letter is owed, quiet since before the retention, is
+  // no longer needed to tell a repeat (9); an unended row is not quiet and is never taken.
+  forgetCalls: `DELETE FROM kernel_calls AS c WHERE quiet_at < ? AND owed = 0
+                AND NOT EXISTS (SELECT 1 FROM kernel_outbox AS o WHERE o.call_from = c.from_addr AND o.call_id = c.id)`,
 
   run: 'SELECT * FROM kernel_runs WHERE from_addr = ? AND id = ?',
   addRun: `INSERT INTO kernel_runs (from_addr, id, to_addr, op, digest, parent, awaited, root, status, rev)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'working', 1)`,
+  // An imported run was taken at version 1, as a run is (C6); one waiting for input is on its first question. One that
+  // has ended is never quiet: it owes no outcome letter, so nothing here tells when its caller has the outcome (9).
+  adoptRun: `INSERT INTO kernel_runs (from_addr, id, to_addr, op, digest, parent, awaited, root, status, rev, asked, asking, result, error, progress)
+             VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, 1, ?, ?, ?, ?, ?) RETURNING *`,
   dropRun: 'DELETE FROM kernel_runs WHERE from_addr = ? AND id = ?',
   haltRun: 'UPDATE kernel_runs SET cancel_asked = 1 WHERE from_addr = ? AND id = ?',
   updateRun: 'UPDATE kernel_runs SET status = ?, asked = ?, asking = ?, progress = ?, rev = rev + 1 WHERE from_addr = ? AND id = ? RETURNING *',
   // Without a progress of its own, an outcome carries the run's last one (C4).
-  endRun: `UPDATE kernel_runs SET status = ?, result = ?, error = ?, progress = coalesce(?, progress), rev = rev + 1
+  endRun: `UPDATE kernel_runs SET status = ?, result = ?, error = ?, progress = coalesce(?, progress), rev = rev + 1, quiet_at = ?
            WHERE from_addr = ? AND id = ? RETURNING to_addr, root, progress`,
   runs: `SELECT * FROM kernel_runs WHERE to_addr = ? AND ${UNENDED_RUN} AND status = coalesce(?, status)`,
+  quietRun: 'UPDATE kernel_runs SET quiet_at = ? WHERE from_addr = ? AND id = ? AND quiet_at IS NOT NULL',
+  forgetRuns: `DELETE FROM kernel_runs AS r WHERE quiet_at < ?
+               AND NOT EXISTS (SELECT 1 FROM kernel_outbox AS o WHERE o.call_from = r.from_addr AND o.call_id = r.id) RETURNING from_addr, id`,
 
   timer: 'SELECT * FROM kernel_timers WHERE from_addr = ? AND id = ?',
   timers: 'SELECT * FROM kernel_timers WHERE from_addr = ?',
@@ -152,6 +179,7 @@ export const SQL = {
   // Only the number of an answer taken is kept, and which question it answered (C8, S8).
   answer: 'SELECT 1 FROM kernel_answers WHERE from_addr = ? AND id = ?',
   addAnswer: 'INSERT INTO kernel_answers (from_addr, id, run_from, run_id, asked) VALUES (?, ?, ?, ?, ?)',
+  forgetAnswers: 'DELETE FROM kernel_answers WHERE run_from = ? AND run_id = ?',
 
   // A letter is identified by `seq` and ordered by `pos`: a letter that replaces another takes the other's `pos` (R3).
   owe: `INSERT INTO kernel_outbox (pos, from_addr, to_addr, lane, kind, call_from, call_id, envelope)