@eltjs/elt-sqlite 0.3.0 → 0.3.2

package/README.md

@@ -120,6 +120,12 @@ Each commit in the SQLite file has a number. A reader that compares the file at
 - As of a position before the newest commit, each table, its reader view and each view of the file show the rows that the commit of the position left. A column that a later commit added is `NULL`. The sync history keeps no versions, and a read of it fails. A stored view that names a table as `main.<table>` makes the reading fail, because that name shows the table as it is now.
 
 - `asOfSelect(database, table, position, { schema })` gives the `SELECT` that reads one table as of a position: the rows of the table with `committed_in ≤ P`, and the rows of its history with `committed_in ≤ P < replaced_in`. A reading uses the same `SELECT` for its `TEMP` views. `schema` names the SQLite file where `database` attached it, `main` by default. Thus a reader can copy a table as of a position into a database of its own. It checks the position as `reading` does, so run the `SELECT` in the same read transaction. See [Read the file as of a position](./docs/recipes/read-the-file-as-of-a-position.md).
+- `asOfDefinitions(database, { schema, position, prefix })` gives the `CREATE TEMP VIEW` statements of the [views of a position](./CONTEXT.md) of the file that `database` attached as `schema`, or `{ expired }` as `asOfSelect` does. Thus one connection reads several files as of a position each, with no copy. Each table, reader view, view and table of the sync history is the view `<prefix>_<name>`, for example `mail_messages`:
+  - A table reads as `asOfSelect` reads it, without `_elt_row_hash`.
+  - A stored view names the views of the position in place of its tables and views. SQLite's own `ALTER TABLE … RENAME` maps the names, in a database of its own with a table of the same columns for each name. A stored view that reads a table with no view of the position, for example `catalog`, fails when it is read.
+  - A table of the sync history fails when it is read, and so does each view over it.
+  - A view reads the file when it is read, so a later commit changes nothing in it. When the retention deletes history that the position reads, or the file is made again, each read of a table fails with the reason: in the same statement, the view compares the epoch and min valid of the file with the position.
+  - The views fail through the SQL functions of `asOfFunctions`. Register each one on the connection: `database.function(name, implementation)`.
 
 ### Retention
 
@@ -136,7 +142,7 @@ new SQLiteDestination({
 - Min valid is a position, and it never passes the newest position. Thus a pass that stays open longer than the retention does not expire the position before it.
 - A position older than min valid is expired: `reading`, `positions` and `asOfSelect` give `{ expired }` with a reason that names the retention.
 - A file in a [file storage](../../elt/README.md#local-files) that only the deleted history rows refer to goes when the stream of its table next commits.
-- `_elt_commits` keeps its rows.
+- The same commit deletes each row of `_elt_commits` with a number less than W, and each closed load of `_elt_loads` that has no commit left. W is a position, so each load with a commit before W ends at or before W. The row of W stays, because a reading as of W gives its `committed_at`. A `committed_in` of a row is only compared with numbers, so it needs no row in `_elt_commits`. An open load stays, also when it has no commit yet.
 - A retention that is less than zero throws a `RangeError`. A retention in months or years throws a `RangeError` of `Temporal`, because their length depends on the date.
 
 ## Checkpoints
@@ -248,6 +254,7 @@ A refresh is a load in `_elt_loads`, so a [reading](#commit-numbers-and-position
 
 - Each transaction of the refresh that changes a row takes one commit number. A transaction that changes no row takes none. No commit inside a refresh that is open is a position.
 - The raw table has the columns `committed_in` and `_elt_row_hash` after the columns of the rule. The view `<name>` does not show them. `_elt_row_hash` is the SHA-256 of the values of the other columns, as for a copy.
+- A rule column cannot have the name of the key, of an engine column, of `committed_in` or of `_elt_row_hash`, in any ASCII case, as SQLite compares column names. The constructor of `ComputedDataset` refuses such a rule with a `TypeError` that names the column and the dataset.
 - When the rule makes a row again with the same values, for example a `failed` row that fails again with the same error, the row stays as it is, with its `committed_in`.
 - Before a commit changes or deletes an output row, it copies the row into the [history](./CONTEXT.md) of the raw table. When the declaration changes, the commit that makes the table again copies each row of the old table into the history. A column that the old table did not have is `NULL` as of a position before.
 
@@ -296,7 +303,8 @@ src/
   sqlite-writer.ts           the stage, the commit, evolve, reload and the difference of a table
   sqlite-loads.ts            SQLiteLoad: the loads and commit numbers of a file, its positions and its retention
   sqlite-history.ts          SQLiteHistory: the history of a table, and the rows that the retention deletes
-  sqlite-as-of.ts            readings and asOfSelect: the file as of a position
+  sqlite-as-of.ts            readings, asOfSelect and asOfFunctions: the file as of a position
+  sqlite-as-of-definitions.ts asOfDefinitions: the views of a position of an attached file
   sqlite-checkpoint-store.ts SQLiteCheckpointStore
   sqlite-sync-history.ts     SQLiteSyncHistory
   sqlite-catalog.ts          installSQLiteCatalog

package/dist/computed-dataset.js

@@ -6,11 +6,10 @@ import { DerivedDataset, } from '@eltjs/elt';
 import { busyTimeout } from './open-destination.js';
 import { SQLiteDestination } from './sqlite-destination.js';
 import { SQLiteHistory, rowHash } from './sqlite-history.js';
-import { identifiers } from './sqlite-identifiers.js';
+import { identifiers, quote } from './sqlite-identifiers.js';
 import { SQLiteLoad } from './sqlite-loads.js';
 import { publishSQLiteViews } from './sqlite-views.js';
 import { View } from './view.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
 // The columns the dataset keeps on every output row beside the rule's own.
 const engineColumns = {
     input_hash: 'SHA-256 of the input the row was made from; the row is made again when its input changes.',
@@ -55,6 +54,20 @@ export class ComputedDataset extends DerivedDataset {
             name: this.#table,
             location: identifiers.key(this.#table),
         });
+        // SQLite takes two names that differ only in ASCII case for one column,
+        // and would refuse the table at the first refresh.
+        const taken = new Map([
+            compute.key.name,
+            ...Object.keys(engineColumns),
+            'committed_in',
+            '_elt_row_hash',
+        ].map((column) => [identifiers.key(column), column]));
+        for (const column of Object.keys(compute.output)) {
+            const other = taken.get(identifiers.key(column));
+            if (other !== undefined)
+                throw new TypeError(`Computed dataset ${name} cannot have the column ${column}: the dataset already has the column ${other}`);
+            taken.set(identifiers.key(column), column);
+        }
         this.#columns = Object.freeze([
             compute.key.name,
             ...Object.keys(engineColumns),

package/dist/index.d.ts

@@ -5,7 +5,8 @@ export { SQLiteCheckpointStore } from './sqlite-checkpoint-store.ts';
 export { SQLiteColumn } from './sqlite-column.ts';
 export { SQLiteColumns } from './sqlite-columns.ts';
 export { SQLiteDestination } from './sqlite-destination.ts';
-export { type SQLiteReading, asOfSelect } from './sqlite-as-of.ts';
+export { asOfDefinitions } from './sqlite-as-of-definitions.ts';
+export { type SQLiteReading, asOfFunctions, asOfSelect, } from './sqlite-as-of.ts';
 export { type PassState, type PassStatus, readPassStatus, type StreamPassStatus, } from './sqlite-passes.ts';
 export { SQLiteSyncHistory } from './sqlite-sync-history.ts';
 export { SQLiteTable } from './sqlite-table.ts';

package/dist/index.js

@@ -5,7 +5,8 @@ export { SQLiteCheckpointStore } from './sqlite-checkpoint-store.js';
 export { SQLiteColumn } from './sqlite-column.js';
 export { SQLiteColumns } from './sqlite-columns.js';
 export { SQLiteDestination } from './sqlite-destination.js';
-export { asOfSelect } from './sqlite-as-of.js';
+export { asOfDefinitions } from './sqlite-as-of-definitions.js';
+export { asOfFunctions, asOfSelect, } from './sqlite-as-of.js';
 export { readPassStatus, } from './sqlite-passes.js';
 export { SQLiteSyncHistory } from './sqlite-sync-history.js';
 export { SQLiteTable } from './sqlite-table.js';

package/dist/sqlite-as-of-definitions.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * The `CREATE TEMP VIEW` statements that show the file attached as `schema`
+ * as of a position, each relation as `${prefix}_${name}`, for a host that
+ * reads several files in one connection: each target, each stored view with
+ * its names mapped to these views, and the sync history and each view that
+ * reads what keeps no row versions, which fail. Each view reads the file
+ * when it is read, so it stays the same across later commits, and fails
+ * through `asOfFunctions` once the file no longer reads the position exactly:
+ * the retention deleted its history, or the file was made again. A position
+ * the file cannot read now is expired.
+ */
+export declare function asOfDefinitions(database: DatabaseSync, { schema, position, prefix, }: {
+    readonly schema: string;
+    readonly position: string;
+    readonly prefix: string;
+}): readonly string[] | {
+    readonly expired: string;
+};

package/dist/sqlite-as-of-definitions.js

@@ -0,0 +1,67 @@
+import { open } from '@zukhruf/sqlite-open';
+import { columnsOf, literal, readable, selectAsOf, storedViews, syncHistoryTables, syncHistoryViews, versioned, } from './sqlite-as-of.js';
+import { quote } from './sqlite-identifiers.js';
+/**
+ * The `CREATE TEMP VIEW` statements that show the file attached as `schema`
+ * as of a position, each relation as `${prefix}_${name}`, for a host that
+ * reads several files in one connection: each target, each stored view with
+ * its names mapped to these views, and the sync history and each view that
+ * reads what keeps no row versions, which fail. Each view reads the file
+ * when it is read, so it stays the same across later commits, and fails
+ * through `asOfFunctions` once the file no longer reads the position exactly:
+ * the retention deleted its history, or the file was made again. A position
+ * the file cannot read now is expired.
+ */
+export function asOfDefinitions(database, { schema, position, prefix, }) {
+    const asked = readable(database, position, schema);
+    if ('expired' in asked)
+        return asked;
+    const named = (name) => `${prefix}_${name}`;
+    const targets = versioned(database, schema);
+    const views = storedViews(database, schema);
+    const columns = new Map([
+        ...targets.map(({ target }) => target),
+        ...views.map(({ name }) => name),
+        ...syncHistoryTables,
+    ]
+        .map((name) => [
+        name,
+        columnsOf(database, quote(name), schema),
+    ])
+        .filter(([, names]) => names.length > 0));
+    return [
+        ...targets.map((version) => `CREATE TEMP VIEW ${quote(named(version.target))} AS ${selectAsOf(database, version, asked.number, schema, asked)}`),
+        ...syncHistoryViews(database, schema, named),
+        ...views.map((view) => `CREATE TEMP VIEW ${quote(named(view.name))} AS ${mapped(view, columns, named)}`),
+    ];
+}
+// The query of a stored view with each relation it names renamed, as
+// SQLite's own ALTER TABLE ... RENAME rewrites the views that name a table:
+// the view is made in a database of its own beside a table of the columns of
+// each other relation, and each table is renamed. A view that reads a table
+// with no view of the position reads as a view that fails.
+function mapped({ name, sql }, columns, named) {
+    using scratch = open(':memory:');
+    scratch.exec('PRAGMA legacy_alter_table = OFF');
+    const others = [...columns].filter(([relation]) => relation !== name);
+    for (const [relation, names] of others)
+        scratch.exec(`CREATE TABLE ${quote(relation)} (${names.map(quote).join(', ')})`);
+    scratch.exec(sql);
+    try {
+        scratch.prepare(`SELECT * FROM ${quote(name)}`);
+    }
+    catch (error) {
+        if (Error.isError(error) && /no such table: /.test(error.message))
+            return `SELECT NULL WHERE "_elt_unversioned"(${literal(`View ${quote(name)} cannot be read as of a position: it reads a table that keeps no row versions (${error.message})`)})`;
+        throw error;
+    }
+    for (const [relation] of others)
+        scratch.exec(`ALTER TABLE ${quote(relation)} RENAME TO ${quote(named(relation))}`);
+    const renamed = String(scratch
+        .prepare(`SELECT "sql" FROM sqlite_schema WHERE "name" = ?`)
+        .get(name)?.sql);
+    const head = `CREATE VIEW ${quote(name)} AS `;
+    if (!renamed.startsWith(head))
+        throw new TypeError(`View ${quote(name)} is not one that elt made: it does not begin with ${head}`);
+    return renamed.slice(head.length);
+}

package/dist/sqlite-as-of.d.ts

@@ -1,4 +1,20 @@
-import { type DatabaseSync } from 'node:sqlite';
+import { type DatabaseSync, type SQLInputValue } from 'node:sqlite';
+import { type Position } from './sqlite-loads.ts';
+type Versioned = {
+    readonly target: string;
+    readonly history: string;
+};
+/**
+ * The SQL functions that views of a position call to fail, by name: a host
+ * registers each one on the connection that reads the views, as
+ * `database.function(name, implementation)`. `_elt_unversioned` refuses a
+ * read of what keeps no row versions; `_elt_readable` refuses a read of a
+ * position that the attached file no longer reads exactly.
+ */
+export declare const asOfFunctions: {
+    _elt_unversioned(reason: SQLInputValue): never;
+    _elt_readable(schema: SQLInputValue, position: SQLInputValue, epoch: SQLInputValue, minValid: SQLInputValue): 1;
+};
 /**
  * The SQLite file as of one position: `sql` reads in one read transaction,
  * and sees each target as it was at that position. Dispose it to close it.
@@ -27,3 +43,17 @@ export declare function asOfSelect(database: DatabaseSync, target: string, posit
 }): string | {
     readonly expired: string;
 };
+export declare function readable(database: DatabaseSync, position: string, schema: string): Position | {
+    readonly expired: string;
+};
+export declare function selectAsOf(database: DatabaseSync, { target, history }: Versioned, number: number, schema: string, guard?: Position): string;
+export declare const literal: (text: string) => string;
+export declare const syncHistoryTables: string[];
+export declare function syncHistoryViews(database: DatabaseSync, schema: string, name: (table: string) => string): string[];
+export declare function storedViews(database: DatabaseSync, schema: string): {
+    readonly name: string;
+    readonly sql: string;
+}[];
+export declare function versioned(database: DatabaseSync, schema: string): Versioned[];
+export declare function columnsOf(database: DatabaseSync, table: string, schema?: string): string[];
+export {};

package/dist/sqlite-as-of.js

@@ -2,10 +2,36 @@ import { constants } from 'node:sqlite';
 import { UnavailableError, open } from '@zukhruf/sqlite-open';
 import { busyTimeout } from './open-destination.js';
 import { histories } from './sqlite-history.js';
-import { identifiers } from './sqlite-identifiers.js';
+import { identifiers, quote } from './sqlite-identifiers.js';
 import { committedAt, expiry, parsePosition, readNumbering, } from './sqlite-loads.js';
 import { attempts, checks, coverage } from './sqlite-sync-history-schema.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+import { version as rowHash } from './sqlite-writer.js';
+/**
+ * The SQL functions that views of a position call to fail, by name: a host
+ * registers each one on the connection that reads the views, as
+ * `database.function(name, implementation)`. `_elt_unversioned` refuses a
+ * read of what keeps no row versions; `_elt_readable` refuses a read of a
+ * position that the attached file no longer reads exactly.
+ */
+export const asOfFunctions = {
+    _elt_unversioned(reason) {
+        throw new Error(String(reason));
+    },
+    // The guard knows the epoch and min_valid of the file only, so it gives
+    // the position as the newest commit: a file made again has another epoch.
+    _elt_readable(schema, position, epoch, minValid) {
+        const asked = parsePosition(String(position));
+        const expired = expiry({
+            epoch: String(epoch),
+            minValid: Number(minValid),
+            newest: asked.number,
+            ends: [],
+        }, asked);
+        if (expired === undefined)
+            return 1;
+        throw new Error(`${expired} (the file attached as ${String(schema)})`);
+    },
+};
 // A reader of the file, or null while no file is at the path.
 export function reader(path) {
     try {
@@ -67,8 +93,10 @@ function shadow(database, number) {
     const targets = versioned(database, 'main');
     for (const version of targets)
         database.exec(`CREATE TEMP VIEW ${quote(version.target)} AS ${selectAsOf(database, version, number, 'main')}`);
-    shadowSyncHistory(database);
-    const views = storedViews(database);
+    database.function('_elt_unversioned', asOfFunctions._elt_unversioned);
+    for (const view of syncHistoryViews(database, 'main', (table) => table))
+        database.exec(view);
+    const views = storedViews(database, 'main');
     for (const { sql } of views)
         database.exec(sql.replace(/^CREATE VIEW /, 'CREATE TEMP VIEW '));
     refuseQualified(database, views.map(({ name }) => name), new Set(targets.map(({ target }) => identifiers.key(target))));
@@ -84,47 +112,65 @@ function shadow(database, number) {
  * or older than the retention, is expired.
  */
 export function asOfSelect(database, target, position, { schema = 'main' } = {}) {
+    const asked = readable(database, position, schema);
+    if ('expired' in asked)
+        return asked;
+    const version = versioned(database, schema).find((version) => identifiers.key(version.target) === identifiers.key(target));
+    if (version === undefined)
+        throw new TypeError(`${quote(target)} is not a target of ${schema}`);
+    return selectAsOf(database, version, asked.number, schema);
+}
+// The position, when the file attached as schema reads it now.
+export function readable(database, position, schema) {
     const asked = parsePosition(position);
     const numbered = readNumbering(database, schema);
     const expired = expiry(numbered, asked);
     if (expired !== undefined)
         return { expired };
     refuseInsidePass(numbered, asked, schema === 'main' ? 'the file' : `the file attached as ${schema}`);
-    const version = versioned(database, schema).find((version) => identifiers.key(version.target) === identifiers.key(target));
-    if (version === undefined)
-        throw new TypeError(`${quote(target)} is not a target of ${schema}`);
-    return selectAsOf(database, version, asked.number, schema);
+    return asked;
 }
 // A target as of commit number: its current rows that the commit had made,
 // and the history rows that the commit had made and a later commit replaced.
-// A column that the history lacks reads as NULL there.
-function selectAsOf(database, { target, history }, number, schema) {
-    const columns = columnsOf(database, quote(target), schema);
+// A column that the history lacks reads as NULL there. A guarded select is
+// for a view that outlives the read transaction: each read first checks, in
+// the same statement, that the file still reads the position exactly, and
+// it leaves out the row hash of the writers.
+export function selectAsOf(database, { target, history }, number, schema, guard) {
+    const columns = columnsOf(database, quote(target), schema).filter((column) => guard === undefined || quote(column) !== rowHash);
     const kept = new Set(columnsOf(database, quote(history), schema).map((column) => identifiers.key(column)));
-    const current = columns.map(quote).join(', ');
+    const current = columns.map((column) => `"r".${quote(column)}`).join(', ');
     const replaced = columns
         .map((column) => kept.has(identifiers.key(column))
-        ? quote(column)
+        ? `"r".${quote(column)}`
         : `NULL AS ${quote(column)}`)
         .join(', ');
     const file = quote(schema);
-    return `SELECT ${current} FROM ${file}.${quote(target)} WHERE "committed_in" <= ${number} UNION ALL SELECT ${replaced} FROM ${file}.${quote(history)} WHERE "committed_in" <= ${number} AND "replaced_in" > ${number}`;
+    // The guard is the outer loop of a CROSS JOIN, which SQLite keeps in
+    // place, so it runs once and also when the target holds no row.
+    const from = guard === undefined
+        ? (table) => `FROM ${file}.${quote(table)} AS "r" WHERE`
+        : (table) => `FROM ${file}."_elt_epoch" AS "e" CROSS JOIN ${file}.${quote(table)} AS "r" WHERE "_elt_readable"(${literal(schema)}, ${literal(`${guard.epoch}:${guard.number}`)}, "e"."epoch", "e"."min_valid") AND`;
+    return `SELECT ${current} ${from(target)} "r"."committed_in" <= ${number} UNION ALL SELECT ${replaced} ${from(history)} "r"."committed_in" <= ${number} AND "r"."replaced_in" > ${number}`;
 }
-// The sync history keeps no versions, so each of its tables reads as a view
-// that fails, and so does each view over them.
-function shadowSyncHistory(database) {
-    database.function('_elt_unversioned', { deterministic: false }, () => {
-        throw new Error('The sync history cannot be read as of a position: it keeps no row versions');
+export const literal = (text) => `'${text.replaceAll("'", "''")}'`;
+// The tables of the sync history, unquoted.
+export const syncHistoryTables = [attempts, coverage, checks].map((table) => table.slice(1, -1));
+// The sync history keeps no versions, so each of its tables of schema reads
+// as a TEMP view, named by name, that fails, and so does each view over them.
+export function syncHistoryViews(database, schema, name) {
+    return syncHistoryTables.flatMap((table) => {
+        const columns = columnsOf(database, quote(table), schema);
+        return columns.length === 0
+            ? []
+            : [
+                `CREATE TEMP VIEW ${quote(name(table))} AS SELECT ${columns.map((column) => `NULL AS ${quote(column)}`).join(', ')} WHERE "_elt_unversioned"('The sync history cannot be read as of a position: it keeps no row versions')`,
+            ];
     });
-    for (const table of [attempts, coverage, checks]) {
-        const columns = columnsOf(database, table);
-        if (columns.length > 0)
-            database.exec(`CREATE TEMP VIEW ${table} AS SELECT ${columns.map((column) => `NULL AS ${quote(column)}`).join(', ')} WHERE "_elt_unversioned"()`);
-    }
 }
-function storedViews(database) {
+export function storedViews(database, schema) {
     return database
-        .prepare(String.raw `SELECT "name", "sql" FROM main.sqlite_schema WHERE "type" = 'view' AND "name" NOT LIKE 'sqlite\_%' ESCAPE '\'`)
+        .prepare(String.raw `SELECT "name", "sql" FROM ${quote(schema)}.sqlite_schema WHERE "type" = 'view' AND "name" NOT LIKE 'sqlite\_%' ESCAPE '\'`)
         .all()
         .map(({ name, sql }) => ({ name: String(name), sql: String(sql) }));
 }
@@ -160,7 +206,7 @@ function refuseQualified(database, views, targets) {
     }
 }
 // Each target with its history, as the file attached as schema records them.
-function versioned(database, schema) {
+export function versioned(database, schema) {
     const file = quote(schema);
     if (database
         .prepare(`SELECT 1 FROM ${file}.sqlite_schema WHERE "type" = 'table' AND "name" = ?`)
@@ -175,7 +221,7 @@ function versioned(database, schema) {
     }));
 }
 // The columns of a table of schema, named as SQL quotes it.
-function columnsOf(database, table, schema = 'main') {
+export function columnsOf(database, table, schema = 'main') {
     return database
         .prepare(`PRAGMA ${quote(schema)}.table_info(${table})`)
         .all()

package/dist/sqlite-column.js

@@ -1,4 +1,5 @@
 import { FileRead, isCalendarDate, isTimestamp } from '@eltjs/elt';
+import { quote } from './sqlite-identifiers.js';
 // STRICT tables accept only these types, so dates and times are their
 // canonical ISO text, which sorts in time order, and exact decimals are text.
 const storageTypes = {
@@ -156,7 +157,7 @@ export class SQLiteColumn {
         });
     }
     get quotedName() {
-        return `"${this.name.replaceAll('"', '""')}"`;
+        return quote(this.name);
     }
     // Original file bytes live in a chunk table; the column keeps the file's id.
     get storesFile() {

package/dist/sqlite-file-store.js

@@ -1,7 +1,6 @@
 import { createHash, hash } from 'node:crypto';
 import { Declaration } from '@zukhruf/sqlite-drift';
-import { identifiers } from './sqlite-identifiers.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+import { identifiers, quote } from './sqlite-identifiers.js';
 const tablePrefix = '_elt_files_';
 const chunks = '("file" INTEGER NOT NULL, "n" INTEGER NOT NULL, "bytes" BLOB NOT NULL, PRIMARY KEY ("file", "n")) STRICT';
 // The highest id that each store gave a file it published. Ids only go up: a

package/dist/sqlite-history.js

@@ -1,8 +1,7 @@
 import { createHash, hash } from 'node:crypto';
 import { Declaration } from '@zukhruf/sqlite-drift';
 import { SQLiteFileStore } from './sqlite-file-store.js';
-import { identifiers } from './sqlite-identifiers.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+import { identifiers, quote } from './sqlite-identifiers.js';
 export const histories = '_elt_histories';
 // Which table keeps the replaced rows of which target, by the target's
 // location, so a reader finds the history of each target.

package/dist/sqlite-identifiers.d.ts

@@ -5,4 +5,5 @@ declare class SQLiteIdentifiers extends Identifiers {
     key(name: string): string;
 }
 export declare const identifiers: Readonly<SQLiteIdentifiers>;
+export declare const quote: (name: string) => string;
 export {};

package/dist/sqlite-identifiers.js

@@ -17,3 +17,5 @@ class SQLiteIdentifiers extends Identifiers {
     }
 }
 export const identifiers = Object.freeze(new SQLiteIdentifiers());
+// SQLite quotes an identifier in double quotes and doubles each one inside it.
+export const quote = (name) => `"${name.replaceAll('"', '""')}"`;

package/dist/sqlite-loads.js

@@ -3,6 +3,7 @@ import { Declaration } from '@zukhruf/sqlite-drift';
 import { transaction } from '@zukhruf/sqlite-transaction';
 import { openDestination } from './open-destination.js';
 import { expireHistory } from './sqlite-history.js';
+import { quote } from './sqlite-identifiers.js';
 const epochs = '"_elt_epoch"';
 const loads = '"_elt_loads"';
 const commits = '"_elt_commits"';
@@ -106,7 +107,12 @@ export class SQLiteLoad {
 // window becomes min_valid, and the history keeps no row that only readings
 // before it read. min_valid is a position, never past the newest one, so the
 // newest position stays readable while a pass stays open longer than the
-// window.
+// window. The numbering then keeps no commit before min_valid and no closed
+// load left with none, so it holds only what a reading still reads: min_valid
+// is a position, so each load that has a commit before it ends at or before
+// it, and keeps min_valid's own commit, whose committed_at a reading there
+// reads. A committed_in of a row only compares with numbers, and needs no
+// commit row. An open load keeps its row with or without commits.
 function retain(database, { clock, retention }) {
     const cutoff = new Date(clock.Date.now() - retention.total('milliseconds')).toISOString();
     const minValid = Number(database.prepare(`SELECT "min_valid" FROM ${epochs}`).get()?.min_valid);
@@ -120,6 +126,10 @@ function retain(database, { clock, retention }) {
         return;
     expireHistory(database, expired);
     database.prepare(`UPDATE ${epochs} SET "min_valid" = ?`).run(expired);
+    database.prepare(`DELETE FROM ${commits} WHERE "number" < ?`).run(expired);
+    database
+        .prepare(`DELETE FROM ${loads} WHERE "closed_at" IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${commits} AS c WHERE c."load" = ${loads}."id")`)
+        .run();
 }
 // Records a load of owner that opens at openedAt, with the numbering and
 // its epoch if the file has none yet, and gives its id.
@@ -187,7 +197,7 @@ export function expiry(numbered, { epoch, number }) {
 export function readNumbering(database, schema = 'main') {
     if (schema === 'main' && numbering.drift(database) !== 'fits')
         return null;
-    const file = `"${schema.replaceAll('"', '""')}"`;
+    const file = quote(schema);
     let row;
     try {
         row = database

package/dist/sqlite-table.js

@@ -1,7 +1,7 @@
 import { Target } from '@eltjs/elt';
 import { SQLiteColumn, canonical } from './sqlite-column.js';
 import { SQLiteColumns } from './sqlite-columns.js';
-import { identifiers } from './sqlite-identifiers.js';
+import { identifiers, quote } from './sqlite-identifiers.js';
 // A reusable target definition. Empty columns mean infer from the Copy's
 // stream. Its own name, its view's and its columns' follow the destination's
 // naming rule, so a field SQLite would take for another still loads.
@@ -69,7 +69,7 @@ export class SQLiteTable extends Target {
         return identifiers.key(this.name);
     }
     get quotedName() {
-        return `"${this.name.replaceAll('"', '""')}"`;
+        return quote(this.name);
     }
     get createTableSQL() {
         return `CREATE TABLE IF NOT EXISTS ${this.definition(this.quotedName)}`;

package/dist/sqlite-views.js

@@ -2,7 +2,7 @@ import { Declaration } from '@zukhruf/sqlite-drift';
 import { transaction } from '@zukhruf/sqlite-transaction';
 import { isReserved } from './reserved.js';
 import { describe } from './sqlite-descriptions.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
+import { quote } from './sqlite-identifiers.js';
 export function viewDefinition(view) {
     return `CREATE VIEW ${quote(view.name)} AS ${view.query}`;
 }

package/dist/sqlite-writer.js

@@ -6,9 +6,8 @@ import { openDestination } from './open-destination.js';
 import { describe } from './sqlite-descriptions.js';
 import { SQLiteFileStore } from './sqlite-file-store.js';
 import { SQLiteHistory, rowHash } from './sqlite-history.js';
-import { identifiers } from './sqlite-identifiers.js';
+import { identifiers, quote } from './sqlite-identifiers.js';
 import { SQLiteLoad } from './sqlite-loads.js';
-const quote = (name) => `"${name.replaceAll('"', '""')}"`;
 const writersTable = new Declaration([
     'CREATE TABLE "_elt_writers" ("target" TEXT PRIMARY KEY, "writer" TEXT NOT NULL) STRICT',
 ], { rows: 'replace' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eltjs/elt-sqlite",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "The SQLite destination of elt: each stream is a raw table in one SQLite file, with a reader view over it and a catalog of each table, view and column.",
   "license": "Apache-2.0",
   "repository": {
@@ -36,10 +36,10 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=26"
   },
   "dependencies": {
-    "@eltjs/elt": "^0.3.0",
+    "@eltjs/elt": "^0.3.2",
     "@zukhruf/mutex": "^0.8.10",
     "@zukhruf/sqlite-drift": "^0.8.10",
     "@zukhruf/sqlite-open": "^0.8.10",