@eltjs/elt-sqlite 0.1.3 → 0.3.0

package/dist/sqlite-writer.js

@@ -5,13 +5,18 @@ import { FileContent, TargetOwnedError, Writer, describeTarget, errorMessage, re
 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 { 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' });
 export const seq = '"_elt_seq"';
 export const op = '"_elt_op"';
+export const version = '"_elt_row_hash"';
+// The id SQLite gives each row of a table; no column takes the name.
+const rowid = '_rowid_';
 // One stream's load. Operations, and the chunks of their files, wait in
 // connection-private TEMP tables, so another stream's commit never publishes
 // them and a crash leaves nothing behind. As in Postgres, no transaction stays
@@ -20,14 +25,17 @@ export const op = '"_elt_op"';
 // operations one at a time, the first also creating the target.
 export class SQLiteWriter extends Writer {
     configuration;
-    path;
+    destination;
     table;
+    // Where the target keeps the rows that its commits replace or remove.
+    history;
     #description;
-    constructor(configuration, path, table) {
+    constructor(configuration, destination, table) {
         super(configuration.stream);
         this.configuration = configuration;
-        this.path = path;
+        this.destination = destination;
         this.table = table;
+        this.history = new SQLiteHistory(table);
         this.#description = describeTarget(configuration, table.columns, (column) => `Integer reference to the source file's original bytes. Join ${quote(SQLiteFileStore.tableName(table, column))} on file = this value and concatenate bytes in order of n. NULL when the source file is unavailable.`);
         if (table.readerView === undefined)
             return;
@@ -35,8 +43,10 @@ export class SQLiteWriter extends Writer {
         if (missing.length > 0)
             throw new TypeError(`Reader view ${table.readerView} needs JSON Schema descriptions for ${missing.join(', ')} of stream ${this.stream.name}`);
     }
-    // What the target needs at its first commit, before its first merge.
-    // replacing: that commit replaces the target, so its rows are moot. A mode
+    // What the target needs before rows of its mode enter it: at its first
+    // commit, once it evolves, and once a difference removed the rows that
+    // leave. replacing: the first commit replaces the rows by difference, so
+    // the index of the mode waits until the rows that leave are gone. A mode
     // without a key releases the index a deduplicating mode made.
     initialize(database, _replacing) {
         this.dropDedupIndexes(database, null);
@@ -57,28 +67,72 @@ export class SQLiteWriter extends Writer {
     build(_database, _into) { }
     adopt(_database) { }
     // Inserts each staged record, in order.
-    append(database, stage, loadedAt, into) {
+    append(database, stage, { loadedAt, committedIn }, into) {
         database
-            .prepare(`INSERT INTO ${into} (${this.fields.join(', ')}) SELECT ${this.table.columns.map((column) => column.quotedName).join(', ')}, ? FROM ${stage} WHERE ${op} = 'R' ORDER BY ${seq}`)
-            .run(loadedAt);
+            .prepare(`INSERT INTO ${into} (${this.written.join(', ')}) SELECT ${this.table.columns.map((column) => column.quotedName).join(', ')}, ?, ?, ${version} FROM ${stage} WHERE ${op} = 'R' ORDER BY ${seq}`)
+            .run(loadedAt, committedIn);
     }
-    // An overwrite replaces the target at its first commit.
+    // An overwrite replaces the rows of the target at its first commit.
     get replaces() {
         return false;
     }
-    // Empties the target a replacing commit is about to fill.
-    replace(database) {
-        database.exec(`DELETE FROM ${this.table.quotedName}`);
+    // Which rows of the stage a merge into an empty table keeps, as a
+    // condition on them.
+    kept(_stage) {
+        return `${op} = 'R'`;
+    }
+    // The ids of the rows of left that no row of right matches, as multisets:
+    // the k-th copy of some values on one side matches the k-th copy of the
+    // same values on the other, so no key is needed.
+    #unmatched(left, right) {
+        const numbered = ({ table, id, rows }) => `SELECT ${id} AS "row", ${version} AS "hash", row_number() OVER (PARTITION BY ${version} ORDER BY ${id}) AS "copy" FROM ${table}${rows === undefined ? '' : ` WHERE ${rows}`}`;
+        return `SELECT "mine"."row" FROM (${numbered(left)}) AS "mine" LEFT JOIN (${numbered(right)}) AS "theirs" ON "theirs"."hash" = "mine"."hash" AND "theirs"."copy" = "mine"."copy" WHERE "theirs"."row" IS NULL`;
+    }
+    get #target() {
+        return { table: this.table.quotedName, id: rowid };
+    }
+    // The first half of replacing the rows of the target with the rows of
+    // next: the history keeps each row of the target that no row of next
+    // matches, and the row goes. A row with a match stays as it is, with its
+    // commit and its loaded_at. What remains matches rows of next, so it fits
+    // the index of the mode, which the rows that enter then fit too.
+    #removeUnmatched(database, next, committedIn) {
+        const { table, id } = this.#target;
+        const leaving = this.#unmatched(this.#target, next);
+        this.history.keep(database, committedIn, `FROM ${table} AS "_elt_old" WHERE "_elt_old".${id} IN (${leaving})`);
+        database.exec(`DELETE FROM ${table} WHERE ${id} IN (${leaving})`);
+        this.initialize(database, false);
+    }
+    // Replaces the rows of the target with the records that the stage keeps,
+    // by difference: each record that no row matches enters with this commit.
+    #replace(database, stage, { loadedAt, committedIn }) {
+        const staged = { table: stage, id: seq, rows: this.kept(stage) };
+        this.#removeUnmatched(database, staged, committedIn);
+        database
+            .prepare(`INSERT INTO ${this.table.quotedName} (${this.written.join(', ')}) SELECT ${this.table.columns.map((column) => column.quotedName).join(', ')}, ?, ?, ${version} FROM ${stage} WHERE ${seq} IN (${this.#unmatched(staged, this.#target)}) ORDER BY ${seq}`)
+            .run(loadedAt, committedIn);
+    }
+    // Copies each row of the target into its history, as replaced in commit
+    // replacedIn.
+    #keepRows(database, replacedIn) {
+        this.history.keep(database, replacedIn, `FROM ${this.table.quotedName} AS "_elt_old"`);
     }
     get hash() {
         return hash('sha256', this.table.location);
     }
+    // What a reader reads of each row.
     get fields() {
         return [
             ...this.table.columns.map((column) => column.quotedName),
             '"loaded_at"',
+            '"committed_in"',
         ];
     }
+    // What a commit writes into each row: its fields, and the hash of its
+    // values.
+    get written() {
+        return [...this.fields, version];
+    }
     encode(record) {
         return this.table.columns.map((column) => column.encode(record));
     }
@@ -116,29 +170,24 @@ export class SQLiteWriter extends Writer {
             .prepare(`SELECT 1 FROM sqlite_schema WHERE "type" = 'table' AND lower("name") = ?`)
             .get(location) !== undefined);
     }
-    // The field's values in each of the tables, which while a reload is open
-    // are the target and its hidden target: both rows still refer to files.
+    // The field's values that a row of the tables or of the history holds:
+    // while a reload is open, the rows of the target and of its hidden target
+    // both still refer to files.
     values(database, tables) {
         const { table } = this;
+        const referenced = (column) => this.#referenced(database, column, tables());
         return async function* (field) {
             const column = table.columns.find((column) => column.field === field);
             if (column === undefined)
                 throw new TypeError(`Unknown target field: ${field}`);
-            for (const name of tables()) {
-                // clear also accepts a target or a declared column that was never loaded.
-                if (!database
-                    .prepare('SELECT 1 FROM pragma_table_info(?) WHERE name = ? COLLATE NOCASE')
-                    .get(name, column.name))
-                    continue;
-                for (const row of database
-                    .prepare(`SELECT ${column.quotedName} AS value FROM ${quote(name)}`)
-                    .iterate())
-                    yield row.value;
-            }
+            for (const row of database.prepare(referenced(column)).iterate())
+                yield row.value;
         };
     }
-    async clear(writer, committed) {
-        using database = openDestination(this.path);
+    // A clear that empties a table is a change readers see, so it is a load of
+    // one numbered commit, and the history keeps the rows it removes.
+    async clear({ writer, clock, connection }, committed) {
+        using database = openDestination(this.destination.path);
         database.exec('BEGIN IMMEDIATE');
         try {
             this.writers(database);
@@ -148,9 +197,13 @@ export class SQLiteWriter extends Writer {
             if (owner !== undefined && owner !== writer)
                 throw new TargetOwnedError(this.table.name, String(owner), writer);
             // Emptied, not dropped: views built on the table keep working. With no
-            // rows left, no stored chunk is referenced, including those a failed
-            // stream left behind that the file triggers never see.
+            // rows left, only the history refers to stored files.
             if (this.exists(database, this.table.location)) {
+                this.history.create(database, this.written);
+                this.#keepRows(database, SQLiteLoad.once(database, connection, {
+                    clock,
+                    retention: this.destination.retention,
+                }));
                 database.exec(`DELETE FROM ${this.table.quotedName}`);
                 // Clearing a copy also abandons the reload it left open.
                 database.exec(`DROP TABLE IF EXISTS ${quote(this.#hiddenName)}`);
@@ -158,7 +211,7 @@ export class SQLiteWriter extends Writer {
                 for (const column of this.table.columns) {
                     const chunks = SQLiteFileStore.tableName(this.table, column);
                     if (column.storesFile && this.exists(database, chunks))
-                        database.exec(`DELETE FROM ${quote(chunks)}`);
+                        database.exec(`DELETE FROM ${quote(chunks)} WHERE "file" NOT IN (${this.#referenced(database, column, [])})`);
                 }
             }
             database
@@ -181,8 +234,13 @@ export class SQLiteWriter extends Writer {
         const dataTypes = new Map([
             ...this.table.columns.map(({ name, dataType }) => [name, dataType]),
             ['loaded_at', 'timestamp'],
+            ['committed_in', 'integer'],
         ]);
-        const columns = Object.fromEntries(Object.entries(this.#description.columns).map(([name, description]) => [
+        const columns = Object.fromEntries(Object.entries({
+            ...this.#description.columns,
+            loaded_at: 'Start time of the load that wrote these values of the row. A deduplicating load, an overwrite or a reload that brings the same values leaves the row, and its loaded_at, as they are. Not the source modification time or the most recent successful sync.',
+            committed_in: 'Number of the commit that last wrote this row: the row of _elt_commits with this number tells when, and in which load.',
+        }).map(([name, description]) => [
             name,
             { description, dataType: dataTypes.get(name) },
         ]));
@@ -219,11 +277,12 @@ export class SQLiteWriter extends Writer {
             .get(view) === undefined)
             database.exec(this.#viewDefinition(view));
     }
-    // The target as its first commit makes it: its owner, the table and the
-    // index its mode owns, its reader view and its descriptions.
+    // The target as its first commit makes it: its owner, the table, its
+    // history, the index its mode owns, its reader view and its descriptions.
     #create(database, writer, replacing) {
         this.own(database, writer);
         database.exec(this.table.createTableSQL);
+        this.history.create(database, this.written);
         this.initialize(database, replacing);
         if (this.table.readerView !== undefined)
             this.installReaderView(database, this.table.readerView);
@@ -255,9 +314,27 @@ export class SQLiteWriter extends Writer {
     #declaration(name) {
         return new Declaration([`CREATE TABLE ${this.table.definition(quote(name))}`], { rows: 'keep' });
     }
+    // Every stored file of the column that a row of the tables or of the
+    // history refers to, as a SELECT of "value". A row of the history keeps its
+    // file for a reading as of a position before the commit that replaced the
+    // row. A table without the column refers to none of its files: the target
+    // while a reload adds the column, a history that has kept no row since, or
+    // a target that a clear finds never loaded.
+    #referenced(database, column, tables) {
+        const selects = [...tables, this.history.name]
+            .filter((table) => database
+            .prepare('SELECT 1 FROM pragma_table_info(?) WHERE name = ? COLLATE NOCASE')
+            .get(table, column.name) !== undefined)
+            .map((table) => `SELECT ${column.quotedName} AS "value" FROM ${quote(table)} WHERE ${column.quotedName} IS NOT NULL`);
+        // With no such table yet, no row refers to a file: a query of no rows.
+        return selects.length === 0
+            ? 'SELECT NULL AS "value" WHERE 0'
+            : selects.join(' UNION ');
+    }
     // Drops the chunks of every stored column that is no longer one of the
-    // target's file columns, and the triggers that delete them, before the table
-    // is replaced: no row of the table that takes its place refers to them.
+    // target's file columns, before the table is replaced: no row of the table
+    // that takes its place refers to them, and a reading as of a position reads
+    // only the target's columns.
     #dropRetiredChunks(database) {
         const files = new Set(this.table.columns
             .filter(({ storesFile }) => storesFile)
@@ -270,10 +347,37 @@ export class SQLiteWriter extends Writer {
                     name: String(name),
                 });
                 database.exec(`DROP TABLE IF EXISTS ${quote(chunks)}`);
-                for (const trigger of ['delete', 'update'])
-                    database.exec(`DROP TRIGGER IF EXISTS ${quote(`${chunks}_${trigger}`)}`);
             }
     }
+    // Keeps in the history, in a commit of its own, each row with a value in a
+    // stored column that the new shape drops or stores as another type: the
+    // row loses or changes the value, so it is a new version. Its row hash
+    // counted the old value, so evolve sets the hash to NULL, which matches no
+    // record until a commit writes the row again. A column that the shape adds
+    // is NULL in each row, which a row hash does not count, so it makes no new
+    // version. Gives the number of the commit, if any.
+    #keepChanged(database, load) {
+        const declared = new Map([
+            ...this.table.columns.map((column) => [identifiers.key(column.name), column.storageType]),
+            ['loaded_at', 'TEXT'],
+            ['committed_in', 'INTEGER'],
+            ['_elt_row_hash', 'TEXT'],
+        ]);
+        const changed = database
+            .prepare('SELECT "name", "type" FROM pragma_table_info(?)')
+            .all(this.table.name)
+            .filter(({ name, type }) => declared.get(identifiers.key(String(name))) !== String(type))
+            .map(({ name }) => `${quote(String(name))} IS NOT NULL`);
+        if (changed.length === 0)
+            return undefined;
+        const rows = changed.join(' OR ');
+        const committedIn = load.commit();
+        this.history.keep(database, committedIn, `FROM ${this.table.quotedName} AS "_elt_old" WHERE ${rows}`);
+        database
+            .prepare(`UPDATE ${this.table.quotedName} SET "committed_in" = ?, "loaded_at" = ? WHERE ${rows}`)
+            .run(committedIn, load.loadedAt);
+        return committedIn;
+    }
     // Brings a stored table the stream no longer fits to its shape, keeping
     // every row: drift rebuilds it from the new definition and copies the
     // columns both have, by name, a column the stream added taking its default
@@ -281,10 +385,11 @@ export class SQLiteWriter extends Writer {
     // fails the load, naming the column, and the transaction leaves the table as
     // it was. The reader view selects the stored columns, and the mode index
     // can cover a dropped key, so both are made again for the new shape.
-    #evolve(database) {
+    #evolve(database, load) {
         if (this.table.readerView !== undefined)
             database.exec(`DROP VIEW IF EXISTS ${quote(this.table.readerView)}`);
         this.dropDedupIndexes(database, null);
+        const changedIn = this.#keepChanged(database, load);
         this.#dropRetiredChunks(database);
         try {
             this.#declaration(this.table.name).apply(database);
@@ -292,19 +397,50 @@ export class SQLiteWriter extends Writer {
         catch (cause) {
             throw new TypeError(`The rows stored in ${this.table.quotedName} do not fit the new shape of stream ${this.stream.name}: ${errorMessage(cause)}. Clear the copy to load it again, or change the stream so they fit.`, { cause });
         }
+        if (changedIn !== undefined)
+            database
+                .prepare(`UPDATE ${this.table.quotedName} SET ${version} = NULL WHERE "committed_in" = ?`)
+                .run(changedIn);
         this.initialize(database, false);
         if (this.table.readerView !== undefined)
             this.installReaderView(database, this.table.readerView);
         this.describe(database);
     }
+    // Replaces the rows of the target with the rows of the hidden target, by
+    // difference, in place: the table keeps its indexes, triggers and reader
+    // view. Each row of the hidden target that no row matches enters with this
+    // commit, and the loaded_at of the load that wrote it.
+    #reloadInPlace(database, hidden, committedIn) {
+        const reloaded = { table: hidden, id: rowid };
+        this.#removeUnmatched(database, reloaded, committedIn);
+        database
+            .prepare(`INSERT INTO ${this.table.quotedName} (${this.written.join(', ')}) SELECT ${this.table.columns.map((column) => column.quotedName).join(', ')}, "loaded_at", ?, ${version} FROM ${hidden} WHERE ${rowid} IN (${this.#unmatched(reloaded, this.#target)}) ORDER BY ${rowid}`)
+            .run(committedIn);
+        database.exec(`DROP TABLE ${hidden}`);
+    }
+    // Replaces the target with the hidden target, whose rows readers see from
+    // this commit on, once the history keeps every row of the target.
+    #swap(database, hidden, committedIn) {
+        database
+            .prepare(`UPDATE ${hidden} SET "committed_in" = ?`)
+            .run(committedIn);
+        if (this.table.readerView !== undefined)
+            database.exec(`DROP VIEW IF EXISTS ${quote(this.table.readerView)}`);
+        if (this.exists(database, this.table.location))
+            this.#keepRows(database, committedIn);
+        database.exec(`DROP TABLE IF EXISTS ${this.table.quotedName}`);
+        database.exec(`ALTER TABLE ${hidden} RENAME TO ${this.table.quotedName}`);
+        this.adopt(database);
+    }
     // Refuses, in one short transaction, a target another writer owns, a
     // reader view not its own and stored rows it cannot keep, evolves a stored
     // table the stream no longer fits unless the load overwrites it, and stages
     // in TEMP. Nothing else reaches the database until a commit. A load into the
     // target creates it, or adopts the stored one, at its first commit; a reload
     // leaves it to readers as it is, merges into a hidden target from its first
-    // commit, and swaps that in at complete().
-    prepare(database, { writer, reloading }, loadedAt) {
+    // commit, and gives its rows to the target at complete().
+    prepare(load, { writer, reloading }) {
+        const { database, loadedAt } = load;
         const name = quote(`_elt_stage_${this.hash}`);
         const stage = `temp.${name}`;
         const hidden = quote(this.#hiddenName);
@@ -318,19 +454,12 @@ export class SQLiteWriter extends Writer {
         const open = (at) => at === 'reload' || at === 'continue';
         const into = () => (open(mode) ? hidden : this.table.quotedName);
         const tables = () => [this.table.name, ...(open(mode) ? [this.#hiddenName] : [])].filter((table) => this.exists(database, identifiers.key(table)));
-        // Every stored file a row of the tables refers to.
-        // With no table yet, no row refers to a file: a query of no rows.
-        const referenced = (column) => {
-            const selects = tables().map((table) => `SELECT ${column.quotedName} FROM ${quote(table)} WHERE ${column.quotedName} IS NOT NULL`);
-            return selects.length === 0
-                ? 'SELECT NULL WHERE 0'
-                : selects.join(' UNION ');
-        };
-        // Drops the chunks of files no row of the tables refers to.
+        // Drops the chunks of files that no row of the tables or of the history
+        // refers to.
         const prune = () => {
             for (const { column, store } of stores)
                 if (store.published)
-                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" NOT IN (${referenced(column)})`);
+                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" NOT IN (${this.#referenced(database, column, tables())})`);
         };
         mode = transaction(database, () => {
             this.#refuse(database, writer);
@@ -347,20 +476,20 @@ export class SQLiteWriter extends Writer {
             if (!open(next) && this.table.readerView !== undefined)
                 this.#refuseReaderView(database, this.table.readerView, target === 'stale');
             if (next === 'evolve') {
-                this.#evolve(database);
+                this.#evolve(database, load);
                 next = 'load';
             }
             if (next === 'load' && !this.replaces)
                 this.inspect(database);
             database.exec(`DROP TABLE IF EXISTS ${stage}`);
-            database.exec(`CREATE TEMP TABLE ${name} (${seq} INTEGER PRIMARY KEY, ${op} TEXT NOT NULL, ${this.table.columns.map((column) => `${column.quotedName} ${column.storageType}`).join(', ')})`);
+            database.exec(`CREATE TEMP TABLE ${name} (${seq} INTEGER PRIMARY KEY, ${op} TEXT NOT NULL, ${this.table.columns.map((column) => `${column.quotedName} ${column.storageType}`).join(', ')}, ${version} TEXT)`);
             for (const { store } of stores)
                 store.stage();
             return next;
         }, { mode: 'immediate' });
         const fresh = mode === 'create' || mode === 'reload';
         const columns = this.table.columns.map((column) => column.quotedName);
-        const record = database.prepare(`INSERT INTO ${stage} (${op}, ${columns.join(', ')}) VALUES ('R', ${columns.map(() => '?').join(', ')})`);
+        const record = database.prepare(`INSERT INTO ${stage} (${op}, ${columns.join(', ')}, ${version}) VALUES ('R', ${columns.map(() => '?').join(', ')}, ?)`);
         const staged = (column) => `SELECT ${column.quotedName} FROM ${stage} WHERE ${column.quotedName} IS NOT NULL`;
         // Partitions the stage dropped, which the next commit empties in the
         // table it merges into.
@@ -369,7 +498,7 @@ export class SQLiteWriter extends Writer {
         const drop = () => {
             for (const { column, store } of stores) {
                 if (store.published)
-                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" IN (${staged(column)}) AND "file" NOT IN (${referenced(column)})`);
+                    database.exec(`DELETE FROM ${quote(store.name)} WHERE "file" IN (${staged(column)}) AND "file" NOT IN (${this.#referenced(database, column, tables())})`);
                 store.discard();
             }
             database.exec(`DELETE FROM ${stage}`);
@@ -377,16 +506,17 @@ export class SQLiteWriter extends Writer {
         };
         // The first commit claims the target: it owns the hidden target of a
         // reload, or creates or adopts the table. Later commits find it claimed.
+        // Returns whether the commit replaces the rows of the target with the
+        // stage's.
         const claimTarget = () => {
             if (open(mode)) {
                 this.own(database, writer);
-                return;
+                return false;
             }
             this.#create(database, writer, this.replaces);
-            if (this.replaces)
-                this.replace(database);
+            return this.replaces;
         };
-        const claimed = () => { };
+        const claimed = () => false;
         let claim = claimTarget;
         return {
             fresh,
@@ -415,35 +545,48 @@ export class SQLiteWriter extends Writer {
                         .run(...values);
                     return;
                 }
-                // Each file is read here, before the source advances past it.
+                // Each file is read here, before the source advances past it. The
+                // row keeps its id, and the row hash its content: each load gives a
+                // file a new id, so a row whose file is the same matches.
                 let data = operation.data;
+                const contents = new Map();
                 for (const { column, store } of stores) {
                     const content = Reflect.get(Object(data), column.field);
-                    if (content instanceof FileContent)
-                        data = {
-                            ...Object(data),
-                            [column.field]: await store.save(content),
-                        };
+                    if (content instanceof FileContent) {
+                        const { id, sha256 } = await store.save(content);
+                        data = { ...Object(data), [column.field]: id };
+                        contents.set(column, sha256);
+                    }
                 }
-                record.run(...this.encode(data));
+                const values = this.encode(data);
+                const hashed = this.table.columns.map((column, index) => contents.get(column) ?? values[index] ?? null);
+                record.run(...values, rowHash(this.table.columns, hashed));
             },
             // Each commit is one transaction; a failed one leaves the database as
             // the last commit left it.
             commit: async () => {
                 transaction(database, () => {
+                    const committedIn = load.commit();
                     if (mode === 'reload') {
                         database.exec(`DROP TABLE IF EXISTS ${hidden}`);
                         database.exec(`CREATE TABLE ${this.table.definition(hidden)}`);
                         this.build(database, hidden);
                     }
-                    claim();
+                    const replacing = claim();
+                    // The rows of a hidden target were never shown, so only the
+                    // target keeps the rows a commit replaces.
+                    const history = open(mode) ? null : this.history;
                     for (const partition of resets) {
                         const [rows, values] = this.#scope(partition);
+                        history?.keep(database, committedIn, `FROM ${into()} AS "_elt_old"${rows}`, values);
                         database.prepare(`DELETE FROM ${into()}${rows}`).run(...values);
                     }
                     for (const { store } of stores)
                         store.publish();
-                    this.merge(database, stage, loadedAt, into());
+                    if (replacing)
+                        this.#replace(database, stage, { loadedAt, committedIn });
+                    else
+                        this.merge(database, stage, { loadedAt, committedIn }, into(), history);
                     // Files of the rows a reset emptied, and of staged rows it dropped.
                     if (resets.length > 0)
                         prune();
@@ -458,12 +601,17 @@ export class SQLiteWriter extends Writer {
                 if (!open(mode))
                     return;
                 transaction(database, () => {
-                    if (this.table.readerView !== undefined)
-                        database.exec(`DROP VIEW IF EXISTS ${quote(this.table.readerView)}`);
+                    // Readers see the rows from this commit on, and the rows of the
+                    // target it replaces up to it.
+                    const committedIn = load.commit();
                     this.#dropRetiredChunks(database);
-                    database.exec(`DROP TABLE IF EXISTS ${this.table.quotedName}`);
-                    database.exec(`ALTER TABLE ${hidden} RENAME TO ${this.table.quotedName}`);
-                    this.adopt(database);
+                    this.history.create(database, this.written);
+                    // A target of another shape cannot take the rows of the hidden
+                    // target in place.
+                    if (this.#declaration(this.table.name).drift(database) === 'fits')
+                        this.#reloadInPlace(database, hidden, committedIn);
+                    else
+                        this.#swap(database, hidden, committedIn);
                     if (this.table.readerView !== undefined)
                         this.installReaderView(database, this.table.readerView);
                     this.describe(database);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eltjs/elt-sqlite",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "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": {
@@ -39,7 +39,7 @@
     "node": ">=24"
   },
   "dependencies": {
-    "@eltjs/elt": "^0.1.3",
+    "@eltjs/elt": "^0.3.0",
     "@zukhruf/mutex": "^0.8.10",
     "@zukhruf/sqlite-drift": "^0.8.10",
     "@zukhruf/sqlite-open": "^0.8.10",