mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 19:16:08 +00:00
69e791206e
The move read unique indexes by joining indkey to pg_attribute. An expression key such as lower(email) has attnum 0 there, so idx_users_email_lower was missing from the plan. The catalog query now reads each index's key as Postgres prints it, whether any part of it is an expression, and the columns it reads: the plain key columns and the Var nodes of indexprs, without INCLUDE columns or the predicate. A broken unique key no longer names --drop-nul as its cause. The refusal names the key and the shared value from Postgres's detail. It explains that the SQLite file held the two rows apart, and the hint about SQLite's lower() appears only for an expression key. Values --drop-nul changed in the key's columns are listed as rows to check first, and only when the duplicate value holds their text. An unrelated value that lost a NUL is no longer named. A plain key over a quoted column is named by its column, not as an expression. A row that breaks a constraint (SQLSTATE class 23) is now a MoveRefusal that says what to correct, in the SQLite file or in a plugin's plugin.db. Before, it was a bare error with a stack. A value Postgres refuses by its type (class 22) stays a failure: it names no row, and values.ts should have refused it first, so the message asks for a bug report. MoveRefusal and the remedy text move to refusal.ts so copy.ts can use them without an import cycle. The usage text of --drop-nul and the wiki's move section describe NUL in JSON, the key listing and these refusals.
294 lines
11 KiB
TypeScript
294 lines
11 KiB
TypeScript
import type { AnyOrm } from '../../src/db/orm';
|
|
|
|
import type { CompiledQuery, Kysely } from 'kysely';
|
|
import { vi } from 'vitest';
|
|
|
|
/**
|
|
* A stand-in for the Postgres side of the SQLite move
|
|
* (`src/db/engine/postgres/sqlite-move/`), for the unit tests in the SQLite
|
|
* lane: it answers exactly the statements the move sends, keeps the rows it
|
|
* is given in memory and reads them back as Postgres's `::text` would. The
|
|
* real database is the Postgres lane's (`tests/postgres/sqlite-move.test.ts`).
|
|
*/
|
|
|
|
interface FakeColumn {
|
|
name: string;
|
|
dataType: string;
|
|
nullable?: boolean;
|
|
}
|
|
|
|
export interface FakeTableDef {
|
|
name: string;
|
|
columns: FakeColumn[];
|
|
primaryKey: string[];
|
|
/** Foreign keys: `columns` of this table point at `references`. */
|
|
foreignKeys?: Array<{ columns: string[]; references: string }>;
|
|
/** Columns a sequence fills. */
|
|
serial?: string[];
|
|
/**
|
|
* Unique indexes besides the primary key's (`<table>_pkey`): the columns the
|
|
* key reads, and for an expression index its key as Postgres spells it and
|
|
* `expression`.
|
|
*/
|
|
unique?: Array<{ name: string; columns: string[]; keys?: string[]; expression?: boolean }>;
|
|
}
|
|
|
|
interface FakeTable {
|
|
columns: string[];
|
|
rows: unknown[][];
|
|
}
|
|
|
|
const QUOTED = /"((?:[^"]|"")*)"/g;
|
|
|
|
function unquote(text: string): string[] {
|
|
return [...text.matchAll(QUOTED)].map((match) => match[1].replaceAll('""', '"'));
|
|
}
|
|
|
|
/** A value as Postgres would print it with `::text` and `bytea_output = hex`. */
|
|
function asText(value: unknown): string | null {
|
|
if (value === null || value === undefined) return null;
|
|
if (Buffer.isBuffer(value)) return `\\x${value.toString('hex')}`;
|
|
return String(value);
|
|
}
|
|
|
|
export class FakePostgres {
|
|
/** Every statement, in order. */
|
|
readonly statements: string[] = [];
|
|
readonly tables = new Map<string, FakeTable>();
|
|
readonly sequences = new Map<string, { value: string; called: boolean }>();
|
|
/** Tables the database holds before anything runs (the move refuses them). */
|
|
existing: string[] = [];
|
|
pluginSchemas: string[] = [];
|
|
/** A statement matching this fails, as Postgres would refuse it. */
|
|
failOn: RegExp | null = null;
|
|
/** What the refusal of `failOn` carries besides its message: by default a broken key without a SQLSTATE. */
|
|
failWith: Record<string, unknown> = { detail: 'Key (id)=(1)', constraint: 'fake_key' };
|
|
/** Rows the read-back answers in place of the stored ones, by table: a copy that came out wrong. */
|
|
tamper = new Map<string, (rows: unknown[][]) => unknown[][]>();
|
|
private cursor: Array<Record<string, string | null>> = [];
|
|
private bootstrapped = false;
|
|
|
|
constructor(readonly schema: FakeTableDef[]) {}
|
|
|
|
/** What the engine's bootstrap leaves: every table of the schema, with a seeded row or two. */
|
|
bootstrap(): void {
|
|
this.bootstrapped = true;
|
|
for (const table of this.schema) {
|
|
this.tables.set(`"${table.name}"`, { columns: table.columns.map((column) => column.name), rows: [] });
|
|
}
|
|
const first = this.schema[0];
|
|
this.tables.get(`"${first.name}"`)?.rows.push(first.columns.map(() => null));
|
|
}
|
|
|
|
rowsOf(target: string): unknown[][] {
|
|
return this.tables.get(target)?.rows ?? [];
|
|
}
|
|
|
|
async executeQuery<R>(query: CompiledQuery): Promise<{ rows: R[] }> {
|
|
const sql = query.sql;
|
|
const params = [...query.parameters];
|
|
this.statements.push(sql);
|
|
if (this.failOn?.test(sql)) {
|
|
throw Object.assign(new Error('refused by the fake'), this.failWith);
|
|
}
|
|
return { rows: this.answer(sql, params) as R[] };
|
|
}
|
|
|
|
/** `db.transaction().execute(fn)`: the fake has no isolation, only the order of statements. */
|
|
transaction() {
|
|
return { execute: <T>(work: (trx: Kysely<object>) => Promise<T>) => work(this.asKysely()) };
|
|
}
|
|
|
|
asKysely(): Kysely<object> {
|
|
return this as unknown as Kysely<object>;
|
|
}
|
|
|
|
private answer(sql: string, params: unknown[]): unknown[] {
|
|
if (sql.startsWith('select table_name from information_schema.tables')) {
|
|
return [...this.existing, ...(this.bootstrapped ? this.schema.map((table) => table.name) : [])].map(
|
|
(table_name) => ({ table_name }),
|
|
);
|
|
}
|
|
if (sql.startsWith('select nspname from pg_namespace')) return this.pluginSchemas.map((nspname) => ({ nspname }));
|
|
if (sql.includes('from information_schema.columns c')) {
|
|
return this.schema.flatMap((table) =>
|
|
table.columns.map((column) => ({
|
|
table_name: table.name,
|
|
column_name: column.name,
|
|
data_type: column.dataType,
|
|
is_nullable: column.nullable === false ? 'NO' : 'YES',
|
|
})),
|
|
);
|
|
}
|
|
if (sql.includes('from pg_constraint')) {
|
|
return this.schema.flatMap((table) => [
|
|
{ kind: 'p', table_name: table.name, target_name: null, columns: table.primaryKey },
|
|
...(table.foreignKeys ?? []).map((fk) => ({
|
|
kind: 'f',
|
|
table_name: table.name,
|
|
target_name: fk.references,
|
|
columns: fk.columns,
|
|
})),
|
|
]);
|
|
}
|
|
if (sql.includes('from pg_index')) {
|
|
return this.schema.flatMap((table) => [
|
|
...(table.primaryKey.length > 0
|
|
? [
|
|
{
|
|
table_name: table.name,
|
|
index_name: `${table.name}_pkey`,
|
|
keys: table.primaryKey,
|
|
columns: table.primaryKey,
|
|
expression: false,
|
|
},
|
|
]
|
|
: []),
|
|
...(table.unique ?? []).map((key) => ({
|
|
table_name: table.name,
|
|
index_name: key.name,
|
|
keys: key.keys ?? key.columns,
|
|
columns: key.columns,
|
|
expression: key.expression ?? false,
|
|
})),
|
|
]);
|
|
}
|
|
if (sql.includes("pg_get_serial_sequence(format('%I'")) {
|
|
return this.schema.flatMap((table) =>
|
|
(table.serial ?? []).map((column) => ({
|
|
table_name: table.name,
|
|
column_name: column,
|
|
sequence: `public.${table.name}_${column}_seq`,
|
|
})),
|
|
);
|
|
}
|
|
if (sql.startsWith('DO $clear$')) {
|
|
// The current schema is emptied: the database is as the move found it.
|
|
this.bootstrapped = false;
|
|
this.tables.clear();
|
|
return [];
|
|
}
|
|
if (sql.startsWith('select pg_get_serial_sequence($1, $2)')) return [{ sequence: `${String(params[0])}_seq` }];
|
|
if (sql.startsWith('truncate table ')) {
|
|
for (const target of sql.slice('truncate table '.length).split(', ')) this.tableOf(target).rows = [];
|
|
return [];
|
|
}
|
|
if (sql.startsWith('insert into ')) return this.insert(sql, params);
|
|
if (sql.startsWith('update ')) return this.update(sql, params);
|
|
if (sql.startsWith('create table ')) return this.createTable(sql);
|
|
if (sql.startsWith('declare trek_move_verify')) return this.declare(sql);
|
|
if (sql.startsWith('fetch forward ')) {
|
|
const size = Number(/fetch forward (\d+)/.exec(sql)?.[1]);
|
|
return this.cursor.splice(0, size);
|
|
}
|
|
if (sql.startsWith('select max(')) {
|
|
const [column] = unquote(sql.slice(0, sql.indexOf(')')));
|
|
const table = this.tableOf(sql.slice(sql.indexOf(' from ') + 6));
|
|
const index = table.columns.indexOf(column);
|
|
const values = table.rows
|
|
.map((row) => row[index])
|
|
.filter((value) => value !== null)
|
|
.map((value) => BigInt(String(value)));
|
|
const max = values.reduce<bigint | null>((best, value) => (best === null || value > best ? value : best), null);
|
|
return [{ max: max === null ? null : max.toString() }];
|
|
}
|
|
if (sql.startsWith('select setval(')) {
|
|
this.sequences.set(String(params[0]), { value: String(params[1]), called: Boolean(params[2]) });
|
|
return [];
|
|
}
|
|
return [];
|
|
}
|
|
|
|
private tableOf(target: string): FakeTable {
|
|
const table = this.tables.get(target.trim());
|
|
if (!table) throw new Error(`relation ${target} does not exist`);
|
|
return table;
|
|
}
|
|
|
|
private insert(sql: string, params: unknown[]): unknown[] {
|
|
const match = /^insert into (.+?) \((.+?)\) values /.exec(sql);
|
|
if (!match) throw new Error(`unparsed insert: ${sql}`);
|
|
const table = this.tableOf(match[1]);
|
|
const columns = unquote(match[2]);
|
|
for (let at = 0; at < params.length; at += columns.length) {
|
|
const values = params.slice(at, at + columns.length);
|
|
table.rows.push(table.columns.map((name) => values[columns.indexOf(name)] ?? null));
|
|
}
|
|
return [];
|
|
}
|
|
|
|
private update(sql: string, params: unknown[]): unknown[] {
|
|
const match = /^update (.+?) set (.+) where (.+)$/.exec(sql);
|
|
if (!match) throw new Error(`unparsed update: ${sql}`);
|
|
const table = this.tableOf(match[1]);
|
|
const sets = unquote(match[2]);
|
|
const keys = unquote(match[3]);
|
|
const keyValues = params.slice(sets.length);
|
|
const row = table.rows.find((candidate) =>
|
|
keys.every((key, index) => String(candidate[table.columns.indexOf(key)]) === String(keyValues[index])),
|
|
);
|
|
if (!row) throw new Error(`no row in ${match[1]} to update`);
|
|
sets.forEach((column, index) => {
|
|
row[table.columns.indexOf(column)] = params[index];
|
|
});
|
|
return [];
|
|
}
|
|
|
|
private createTable(sql: string): unknown[] {
|
|
const match = /^create table (\S+?\.\S+?|\S+) \((.*)\)$/s.exec(sql);
|
|
if (!match) throw new Error(`unparsed create table: ${sql}`);
|
|
const definitions = match[2].split(/, (?![^(]*\))/).filter((part) => !part.startsWith('primary key'));
|
|
const columns = definitions.map((part) => (part.startsWith('"') ? unquote(part)[0] : part.split(' ')[0]));
|
|
const target = match[1].replace(/\._plugin_migrations$/, '."_plugin_migrations"');
|
|
this.tables.set(target, { columns, rows: [] });
|
|
return [];
|
|
}
|
|
|
|
private declare(sql: string): unknown[] {
|
|
const target = sql.slice(sql.lastIndexOf(' from ') + 6);
|
|
const table = this.tableOf(target);
|
|
const selected = [...sql.matchAll(/"((?:[^"]|"")*)"::text/g)].map((match) => match[1]);
|
|
const tamper = this.tamper.get(target) ?? ((rows: unknown[][]) => rows);
|
|
this.cursor = tamper(table.rows).map((row) =>
|
|
Object.fromEntries(selected.map((name, index) => [`c${index}`, asText(row[table.columns.indexOf(name)])])),
|
|
);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* An ORM whose connection is the fake: enough for the engine's bootstrap
|
|
* (`schema-bootstrap.ts`) to run its empty-database path, and for the move to
|
|
* reach the fake through `getClient()`.
|
|
*/
|
|
export function fakeMoveOrm(pg: FakePostgres, options: { pending?: string[]; known: string[] }): AnyOrm {
|
|
const executed: string[] = [];
|
|
const connection = {
|
|
execute: vi.fn(async (sql: string) => {
|
|
if (sql.includes('server_version_num')) return [{ schema: 'public', version: '170004', privileged: false }];
|
|
const answer = await pg.executeQuery({ sql, parameters: [], query: undefined } as unknown as CompiledQuery);
|
|
if (sql.startsWith('create table "baseline"')) pg.bootstrap();
|
|
return answer.rows;
|
|
}),
|
|
transactional: vi.fn(async (work: (ctx: unknown) => Promise<void>) => work({})),
|
|
getClient: () => pg.asKysely(),
|
|
};
|
|
const migrator = {
|
|
getStorage: () => ({
|
|
ensureTable: vi.fn(async () => undefined),
|
|
setMasterMigration: vi.fn(),
|
|
unsetMasterMigration: vi.fn(),
|
|
logMigration: vi.fn(async ({ name }: { name: string }) => {
|
|
executed.push(name);
|
|
}),
|
|
}),
|
|
getExecuted: vi.fn(async () => executed.map((name) => ({ name }))),
|
|
getPending: vi.fn(async () => (options.pending ?? []).map((name) => ({ name }))),
|
|
up: vi.fn(async () => undefined),
|
|
};
|
|
return {
|
|
config: { getExtension: () => migrator, get: () => ({ tableName: 'mikro_orm_migrations' }) },
|
|
em: { getConnection: () => connection },
|
|
} as unknown as AnyOrm;
|
|
}
|