@adecore/database 0.0.1 → 0.16.0-beta.0

package/dist/console/outcome.d.ts

@@ -0,0 +1,6 @@
+import type { Engine, StatementResult } from '../protocol/index.ts';
+export declare const outcomeOf: (results: readonly StatementResult[]) => {
+    readonly ok: boolean;
+    readonly rows: number;
+};
+export declare const isPageable: (sql: string, engine: Engine) => boolean;

package/dist/console/outcome.js

@@ -0,0 +1,11 @@
+import { firstKeyword } from '../sql-split.js';
+/* How a run ended, for the history: whether every statement worked, and how many rows they read or changed. */
+export const outcomeOf = (results) => ({
+    ok: results.every((result) => result.kind !== 'error'),
+    rows: results.reduce((sum, result) => sum + (result.kind === 'rows' ? result.rows.length : result.kind === 'done' ? result.affected : 0), 0)
+});
+/* Whether the helper can wrap the statement to fetch a page of it: a read that starts with `SELECT` or `WITH`. */
+export const isPageable = (sql, engine) => {
+    const keyword = firstKeyword(sql, engine);
+    return keyword === 'SELECT' || keyword === 'WITH';
+};

package/dist/console/schemas.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaInfo } from '../protocol/index.ts';
+export declare const orderSchemas: (schemas: readonly SchemaInfo[]) => SchemaInfo[];

package/dist/console/schemas.js

@@ -0,0 +1,5 @@
+/* The schemas a person works in first, the ones the server keeps for itself last. */
+export const orderSchemas = (schemas) => [
+    ...schemas.filter((schema) => !schema.system),
+    ...schemas.filter((schema) => schema.system)
+];

package/dist/console/shortcuts.d.ts

@@ -0,0 +1,2 @@
+export declare const RUN_SHORTCUT: import("@adecore/ui").Shortcut;
+export declare const RUN_ALL_SHORTCUT: import("@adecore/ui").Shortcut;

package/dist/console/shortcuts.js

@@ -0,0 +1,3 @@
+import { shortcut } from '@adecore/ui';
+export const RUN_SHORTCUT = shortcut('Mod+Enter');
+export const RUN_ALL_SHORTCUT = shortcut('Mod+Shift+Enter');

package/dist/console/useConsoleHistory.d.ts

@@ -0,0 +1,7 @@
+import { type HistoryEntry } from './history.ts';
+export interface ConsoleHistory {
+    readonly entries: readonly HistoryEntry[];
+    record(entry: HistoryEntry): void;
+    clear(): void;
+}
+export declare function useConsoleHistory(connectionId: string): ConsoleHistory;

package/dist/console/useConsoleHistory.js

@@ -0,0 +1,22 @@
+import { useEffect, useState } from 'react';
+import { useDatabaseStorage } from '../client-context.js';
+import { addEntry, historyKey, parseHistory, serializeHistory } from './history.js';
+/* The runs of one connection, kept in the app's storage when it has one and for the life of the console when it has not. */
+export function useConsoleHistory(connectionId) {
+    const storage = useDatabaseStorage();
+    const key = historyKey(connectionId);
+    const [state, setState] = useState(() => ({ key, entries: parseHistory(storage?.get(key) ?? null), changed: false }));
+    if (state.key !== key) {
+        setState({ key, entries: parseHistory(storage?.get(key) ?? null), changed: false });
+    }
+    useEffect(() => {
+        if (state.changed) {
+            storage?.set(state.key, state.entries.length === 0 ? null : serializeHistory(state.entries));
+        }
+    }, [state, storage]);
+    return {
+        entries: state.entries,
+        record: (entry) => setState((current) => ({ ...current, entries: addEntry(current.entries, entry), changed: true })),
+        clear: () => setState((current) => ({ ...current, entries: [], changed: true }))
+    };
+}

package/dist/ddl/alter-mysql.d.ts

@@ -0,0 +1,4 @@
+import { type Dialect } from './dialect.ts';
+import type { TableDiff } from './diff.ts';
+import type { TableDraft } from './draft.ts';
+export declare const mysqlAlterSql: (dialect: Dialect, schema: string, original: TableDraft, draft: TableDraft, diff: TableDiff) => string[];

package/dist/ddl/alter-mysql.js

@@ -0,0 +1,79 @@
+import { columnSpecSql } from './column.js';
+import { foreignKeySql, mysqlOptionsSql } from './create.js';
+import { columnList, quote, tableName } from './dialect.js';
+const positionSql = (dialect, after) => (after === null ? 'FIRST' : `AFTER ${quote(dialect, after)}`);
+const indexSql = (dialect, index) => [
+    'ADD',
+    index.unique ? 'UNIQUE INDEX' : 'INDEX',
+    ...(index.name === '' ? [] : [quote(dialect, index.name)]),
+    `(${columnList(dialect, index.columns)})`
+].join(' ');
+const withPosition = (clause, position) => (position === null ? clause : `${clause} ${position}`);
+/*
+ * One `ALTER TABLE`, or two when it has to be. A position clause names the columns as they are
+ * called after a rename, and a foreign key cannot be dropped and added again under the same name
+ * in one statement, so both put the drops and renames in a statement of their own, first.
+ */
+export const mysqlAlterSql = (dialect, schema, original, draft, diff) => {
+    const early = [];
+    const late = [];
+    const column = (verb, target, previous, position) => {
+        const spec = columnSpecSql(dialect, target);
+        const named = verb === 'CHANGE' ? `${quote(dialect, previous)} ${quote(dialect, target.name)}` : quote(dialect, target.name);
+        return withPosition(`${verb} COLUMN ${named} ${spec}`, position);
+    };
+    const positioned = diff.keptColumns.some((kept) => kept.moved) || diff.addedColumns.some((added) => added.placed);
+    const reusesName = diff.droppedForeignKeys.some((dropped) => dropped.name !== '' && diff.addedForeignKeys.some((added) => added.name === dropped.name));
+    const split = (positioned && diff.keptColumns.some((kept) => kept.renamed)) || reusesName;
+    for (const foreignKey of diff.droppedForeignKeys) {
+        early.push(`DROP FOREIGN KEY ${quote(dialect, foreignKey.name)}`);
+    }
+    for (const index of diff.droppedIndexes) {
+        early.push(`DROP INDEX ${quote(dialect, index.name)}`);
+    }
+    for (const { from, to } of diff.renamedIndexes) {
+        early.push(`RENAME INDEX ${quote(dialect, from.name)} TO ${quote(dialect, to.name)}`);
+    }
+    if (diff.primaryKeyChanged && original.primaryKey.length > 0) {
+        early.push('DROP PRIMARY KEY');
+    }
+    for (const dropped of diff.droppedColumns) {
+        early.push(`DROP COLUMN ${quote(dialect, dropped.name)}`);
+    }
+    for (const kept of diff.keptColumns) {
+        const verb = kept.renamed ? 'CHANGE' : 'MODIFY';
+        if (split) {
+            if (kept.renamed || kept.redefined) {
+                early.push(column(verb, kept.column, kept.original.name, null));
+            }
+            if (kept.moved) {
+                late.push(column('MODIFY', kept.column, null, positionSql(dialect, kept.after)));
+            }
+        }
+        else if (kept.renamed || kept.redefined || kept.moved) {
+            early.push(column(verb, kept.column, kept.original.name, kept.moved ? positionSql(dialect, kept.after) : null));
+        }
+    }
+    for (const added of diff.addedColumns) {
+        late.push(column('ADD', added.column, null, added.placed ? positionSql(dialect, added.after) : null));
+    }
+    if (diff.primaryKeyChanged && draft.primaryKey.length > 0) {
+        late.push(`ADD PRIMARY KEY (${columnList(dialect, draft.primaryKey)})`);
+    }
+    for (const index of diff.addedIndexes) {
+        late.push(indexSql(dialect, index));
+    }
+    for (const foreignKey of diff.addedForeignKeys) {
+        late.push(`ADD ${foreignKeySql(dialect, schema, foreignKey)}`);
+    }
+    const options = diff.optionsChanged ? mysqlOptionsSql(draft.options, original.options).join(' ') : '';
+    if (options !== '') {
+        late.push(options);
+    }
+    if (diff.renamed) {
+        late.push(`RENAME TO ${quote(dialect, draft.name)}`);
+    }
+    const target = tableName(dialect, schema, original.name);
+    const statement = (clauses) => (clauses.length === 0 ? [] : [`ALTER TABLE ${target}\n    ${clauses.join(',\n    ')}`]);
+    return split ? [...statement(early), ...statement(late)] : statement([...early, ...late]);
+};

package/dist/ddl/alter-sqlite.d.ts

@@ -0,0 +1,4 @@
+import { type Dialect } from './dialect.ts';
+import type { TableDiff } from './diff.ts';
+import { type TableDraft } from './draft.ts';
+export declare const sqliteAlterSql: (dialect: Dialect, schema: string, original: TableDraft, draft: TableDraft, diff: TableDiff) => string[];

package/dist/ddl/alter-sqlite.js

@@ -0,0 +1,80 @@
+import { columnSql, defaultClause } from './column.js';
+import { createIndexSql, createTableParts } from './create.js';
+import { atLeast, quote, tableName } from './dialect.js';
+import { isAutoIndex } from './draft.js';
+import { dropIndexSql } from './statements.js';
+const RENAME_COLUMN = [3, 25];
+const DROP_COLUMN = [3, 35];
+/* The clauses `ALTER TABLE .. ADD COLUMN` refuses: a key, a computed value, or a NOT NULL column with nothing to fill the rows with. */
+const addable = (column) => {
+    if (column.autoIncrement || (column.generated && column.generatedClause !== null && /\bSTORED\b/i.test(column.generatedClause))) {
+        return false;
+    }
+    const expression = column.defaultValue?.trim() ?? '';
+    if (expression === '') {
+        return column.nullable;
+    }
+    // Only a constant may fill existing rows: not an expression, not the clock.
+    const clause = defaultClause(expression);
+    return !clause.startsWith('(') && !/^CURRENT_|^LOCALTIME|^NOW/i.test(clause) && (column.nullable || !/^NULL$/i.test(clause));
+};
+const needsRebuild = (dialect, original, diff) => {
+    if (diff.optionsChanged || diff.primaryKeyChanged || diff.droppedForeignKeys.length > 0 || diff.addedForeignKeys.length > 0) {
+        return true;
+    }
+    if (diff.keptColumns.some((kept) => kept.redefined || kept.moved || (kept.renamed && !atLeast(dialect, ...RENAME_COLUMN)))) {
+        return true;
+    }
+    if (diff.addedColumns.some((added) => added.placed || !addable(added.column))) {
+        return true;
+    }
+    if (diff.droppedColumns.length > 0 && !atLeast(dialect, ...DROP_COLUMN)) {
+        return true;
+    }
+    const autoIndexed = new Set(original.indexes.filter((index) => isAutoIndex(index.name)).flatMap((index) => index.columns));
+    if (diff.droppedColumns.some((dropped) => autoIndexed.has(dropped.name))) {
+        return true;
+    }
+    return [...diff.droppedIndexes, ...diff.renamedIndexes.map(({ from }) => from)].some((index) => isAutoIndex(index.name));
+};
+/* The steps of https://www.sqlite.org/lang_altertable.html under "Making Other Kinds Of Table Schema Changes", which keep the rows, the indexes and the foreign keys of other tables intact. */
+const rebuildSql = (dialect, schema, original, draft, diff) => {
+    const temporary = `new_${draft.name}`;
+    const { table, indexes } = createTableParts(dialect, schema, draft, temporary);
+    const copied = diff.keptColumns.filter((kept) => !kept.column.generated);
+    const statements = ['PRAGMA foreign_keys=OFF', 'BEGIN', table];
+    if (copied.length > 0) {
+        const into = copied.map((kept) => quote(dialect, kept.column.name)).join(', ');
+        const from = copied.map((kept) => quote(dialect, kept.original.name)).join(', ');
+        statements.push(`INSERT INTO ${tableName(dialect, schema, temporary)} (${into}) SELECT ${from} FROM ${tableName(dialect, schema, original.name)}`);
+    }
+    statements.push(`DROP TABLE ${tableName(dialect, schema, original.name)}`, `ALTER TABLE ${tableName(dialect, schema, temporary)} RENAME TO ${quote(dialect, draft.name)}`, ...indexes.map((index) => createIndexSql(dialect, schema, draft.name, index)), 'PRAGMA foreign_key_check', 'COMMIT', 'PRAGMA foreign_keys=ON');
+    return statements;
+};
+/* `ALTER TABLE` where SQLite has one, a rebuild of the table for every other change. */
+export const sqliteAlterSql = (dialect, schema, original, draft, diff) => {
+    if (needsRebuild(dialect, original, diff)) {
+        return rebuildSql(dialect, schema, original, draft, diff);
+    }
+    const target = tableName(dialect, schema, original.name);
+    const statements = [];
+    for (const index of [...diff.droppedIndexes, ...diff.renamedIndexes.map(({ from }) => from)]) {
+        statements.push(dropIndexSql(dialect, schema, original.name, index.name));
+    }
+    for (const dropped of diff.droppedColumns) {
+        statements.push(`ALTER TABLE ${target} DROP COLUMN ${quote(dialect, dropped.name)}`);
+    }
+    for (const kept of diff.keptColumns.filter((candidate) => candidate.renamed)) {
+        statements.push(`ALTER TABLE ${target} RENAME COLUMN ${quote(dialect, kept.original.name)} TO ${quote(dialect, kept.column.name)}`);
+    }
+    for (const added of diff.addedColumns) {
+        statements.push(`ALTER TABLE ${target} ADD COLUMN ${columnSql(dialect, added.column)}`);
+    }
+    for (const index of [...diff.addedIndexes, ...diff.renamedIndexes.map(({ to }) => to)]) {
+        statements.push(createIndexSql(dialect, schema, original.name, index));
+    }
+    if (diff.renamed) {
+        statements.push(`ALTER TABLE ${target} RENAME TO ${quote(dialect, draft.name)}`);
+    }
+    return statements;
+};

package/dist/ddl/alter.d.ts

@@ -0,0 +1,4 @@
+import type { TableStructure } from '../protocol/index.ts';
+import type { Dialect } from './dialect.ts';
+import { type TableDraft } from './draft.ts';
+export declare const alterTableSql: (dialect: Dialect, schema: string, structure: TableStructure, draft: TableDraft) => string[];

package/dist/ddl/alter.js

@@ -0,0 +1,24 @@
+import { mysqlAlterSql } from './alter-mysql.js';
+import { sqliteAlterSql } from './alter-sqlite.js';
+import { diffOf } from './diff.js';
+import { draftOf } from './draft.js';
+const unchanged = (diff) => !diff.renamed &&
+    !diff.optionsChanged &&
+    !diff.primaryKeyChanged &&
+    diff.droppedColumns.length === 0 &&
+    diff.addedColumns.length === 0 &&
+    diff.keptColumns.every((kept) => !kept.renamed && !kept.redefined && !kept.moved) &&
+    diff.droppedIndexes.length === 0 &&
+    diff.addedIndexes.length === 0 &&
+    diff.renamedIndexes.length === 0 &&
+    diff.droppedForeignKeys.length === 0 &&
+    diff.addedForeignKeys.length === 0;
+/* The fewest statements that turn the table of `structure` into the draft; none when the draft changes nothing. */
+export const alterTableSql = (dialect, schema, structure, draft) => {
+    const original = draftOf(structure);
+    const diff = diffOf(dialect, original, draft);
+    if (unchanged(diff)) {
+        return [];
+    }
+    return dialect.engine === 'sqlite' ? sqliteAlterSql(dialect, schema, original, draft, diff) : mysqlAlterSql(dialect, schema, original, draft, diff);
+};

package/dist/ddl/column.d.ts

@@ -0,0 +1,9 @@
+import { type Dialect } from './dialect.ts';
+import type { ColumnDraft } from './draft.ts';
+export declare const defaultClause: (expression: string) => string;
+export interface ColumnSqlOptions {
+    readonly inlinePrimaryKey?: boolean;
+}
+export declare const columnSpecSql: (dialect: Dialect, column: ColumnDraft, { inlinePrimaryKey }?: ColumnSqlOptions) => string;
+export declare const columnSql: (dialect: Dialect, column: ColumnDraft, options?: ColumnSqlOptions) => string;
+export declare const sameDefinition: (dialect: Dialect, left: ColumnDraft, right: ColumnDraft) => boolean;

package/dist/ddl/column.js

@@ -0,0 +1,62 @@
+import { sqlLiteral } from '../sql.js';
+import { quote } from './dialect.js';
+const NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const STRING = /^'(?:[^']|'')*'$/;
+const KEYWORD = /^(?:NULL|TRUE|FALSE|CURRENT_DATE|CURRENT_TIME(?:\(\d*\))?|CURRENT_TIMESTAMP(?:\(\d*\))?|LOCALTIME(?:STAMP)?(?:\(\d*\))?|NOW\(\d*\))$/i;
+/*
+ * The text after `DEFAULT`. A literal and the few keywords both engines take stand as written; any
+ * other expression goes in parentheses, which SQLite and MySQL 8 need for one that is not constant.
+ */
+export const defaultClause = (expression) => {
+    const text = expression.trim();
+    if (NUMBER.test(text) || STRING.test(text) || KEYWORD.test(text)) {
+        return text;
+    }
+    return text.startsWith('(') && text.endsWith(')') ? text : `(${text})`;
+};
+/* A column's definition without its name: `varchar(255) NOT NULL DEFAULT 'x'`. */
+export const columnSpecSql = (dialect, column, { inlinePrimaryKey = false } = {}) => {
+    const mysql = dialect.engine === 'mysql';
+    const parts = [];
+    if (column.type !== '') {
+        parts.push(column.type);
+    }
+    if (column.generated && column.generatedClause !== null) {
+        parts.push(column.generatedClause);
+    }
+    if (inlinePrimaryKey) {
+        parts.push(column.autoIncrement ? 'PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY');
+    }
+    // MariaDB takes neither NULL nor NOT NULL after the expression of a computed column.
+    if (column.generated && dialect.flavor === 'mariadb') {
+        // The expression says everything.
+    }
+    else if (!column.nullable) {
+        parts.push('NOT NULL');
+    }
+    else if (mysql) {
+        // MySQL gives a TIMESTAMP column NOT NULL unless it is told otherwise.
+        parts.push('NULL');
+    }
+    if (!column.generated) {
+        if (column.defaultValue !== null && column.defaultValue.trim() !== '') {
+            parts.push(`DEFAULT ${defaultClause(column.defaultValue)}`);
+        }
+        if (mysql && column.autoIncrement) {
+            parts.push('AUTO_INCREMENT');
+        }
+    }
+    if (mysql && column.comment !== '') {
+        parts.push(`COMMENT ${sqlLiteral('mysql', column.comment)}`);
+    }
+    return parts.join(' ');
+};
+export const columnSql = (dialect, column, options) => `${quote(dialect, column.name)} ${columnSpecSql(dialect, column, options)}`.trimEnd();
+const typeKey = (type) => type.toLowerCase().replace(/\s+/g, ' ').trim();
+/* Whether two columns are defined alike, whatever their names. SQLite keeps no comments, so they never differ there. */
+export const sameDefinition = (dialect, left, right) => typeKey(left.type) === typeKey(right.type) &&
+    left.nullable === right.nullable &&
+    (left.defaultValue ?? '').trim() === (right.defaultValue ?? '').trim() &&
+    left.autoIncrement === right.autoIncrement &&
+    (dialect.engine === 'sqlite' || left.comment === right.comment) &&
+    left.generatedClause === right.generatedClause;

package/dist/ddl/create.d.ts

@@ -0,0 +1,12 @@
+import { type Dialect } from './dialect.ts';
+import { type ForeignKeyDraft, type IndexDraft, type TableDraft } from './draft.ts';
+import type { TableOptions } from './parse.ts';
+export declare const foreignKeySql: (dialect: Dialect, schema: string, foreignKey: ForeignKeyDraft) => string;
+export declare const mysqlOptionsSql: (options: TableOptions, against?: TableOptions) => string[];
+export declare const createIndexSql: (dialect: Dialect, schema: string, table: string, index: Pick<IndexDraft, 'name' | 'columns' | 'unique'>) => string;
+export interface CreateParts {
+    readonly table: string;
+    readonly indexes: readonly IndexDraft[];
+}
+export declare const createTableParts: (dialect: Dialect, schema: string, draft: TableDraft, name: string) => CreateParts;
+export declare const createTableSql: (dialect: Dialect, schema: string, draft: TableDraft) => string[];

package/dist/ddl/create.js

@@ -0,0 +1,74 @@
+import { sqlLiteral } from '../sql.js';
+import { columnSql } from './column.js';
+import { columnList, quote, sqliteSchemaPrefix, tableName } from './dialect.js';
+import { isAutoIndex } from './draft.js';
+const INDENT = '    ';
+/* `CONSTRAINT name FOREIGN KEY (...) REFERENCES t (...) ON UPDATE .. ON DELETE ..`, shared by a create and an `ADD`. */
+export const foreignKeySql = (dialect, schema, foreignKey) => {
+    const sqlite = dialect.engine === 'sqlite';
+    // SQLite cannot name another schema in a reference, and MySQL needs one only for another database.
+    const target = sqlite || foreignKey.referencedSchema === '' || foreignKey.referencedSchema === schema
+        ? quote(dialect, foreignKey.referencedTable)
+        : `${quote(dialect, foreignKey.referencedSchema)}.${quote(dialect, foreignKey.referencedTable)}`;
+    const parts = [
+        ...(foreignKey.name === '' ? [] : [`CONSTRAINT ${quote(dialect, foreignKey.name)}`]),
+        `FOREIGN KEY (${columnList(dialect, foreignKey.columns)})`,
+        `REFERENCES ${target} (${columnList(dialect, foreignKey.referencedColumns)})`
+    ];
+    if (foreignKey.onUpdate !== null) {
+        parts.push(`ON UPDATE ${foreignKey.onUpdate}`);
+    }
+    if (foreignKey.onDelete !== null) {
+        parts.push(`ON DELETE ${foreignKey.onDelete}`);
+    }
+    return parts.join(' ');
+};
+/* `ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ...`: the options that say something, and with `against` only those that differ from it. */
+export const mysqlOptionsSql = (options, against) => {
+    // Only a comment can be emptied; an engine, a character set or a collation has no empty value to ask for.
+    const changed = (field) => options[field] !== against?.[field] && (options[field] !== '' || (field === 'comment' && against !== undefined));
+    return [
+        ...(changed('engine') ? [`ENGINE=${options.engine}`] : []),
+        ...(changed('charset') ? [`DEFAULT CHARSET=${options.charset}`] : []),
+        ...(changed('collation') ? [`COLLATE=${options.collation}`] : []),
+        ...(changed('comment') ? [`COMMENT=${sqlLiteral('mysql', options.comment)}`] : [])
+    ];
+};
+const sqliteOptionsSql = (options) => [...(options.strict ? ['STRICT'] : []), ...(options.withoutRowid ? ['WITHOUT ROWID'] : [])];
+const inlineIndexSql = (dialect, index) => [index.unique ? 'UNIQUE INDEX' : 'INDEX', ...(index.name === '' ? [] : [quote(dialect, index.name)]), `(${columnList(dialect, index.columns)})`].join(' ');
+/* `CREATE [UNIQUE] INDEX name ON table (columns)`. */
+export const createIndexSql = (dialect, schema, table, index) => `CREATE ${index.unique ? 'UNIQUE ' : ''}INDEX ${dialect.engine === 'sqlite' ? sqliteSchemaPrefix(dialect, schema) : ''}${quote(dialect, index.name)} ON ${tableName(dialect, dialect.engine === 'sqlite' ? '' : schema, table)} (${columnList(dialect, index.columns)})`;
+/* The `CREATE TABLE` of a draft under a name of the caller's choosing, which a rebuild uses for the table it fills before the swap. */
+export const createTableParts = (dialect, schema, draft, name) => {
+    const sqlite = dialect.engine === 'sqlite';
+    // SQLite declares AUTOINCREMENT on the column itself, which then is the whole primary key; a WITHOUT ROWID table has no rowid to count.
+    const autoColumn = sqlite && draft.primaryKey.length === 1 && !draft.options.withoutRowid
+        ? draft.columns.find((column) => column.name === draft.primaryKey[0] && column.autoIncrement)?.name
+        : undefined;
+    const lines = draft.columns.map((column) => columnSql(dialect, column, { inlinePrimaryKey: column.name === autoColumn }));
+    if (draft.primaryKey.length > 0 && autoColumn === undefined) {
+        lines.push(`PRIMARY KEY (${columnList(dialect, draft.primaryKey)})`);
+    }
+    const separate = [];
+    for (const index of draft.indexes) {
+        if (!sqlite) {
+            lines.push(inlineIndexSql(dialect, index));
+        }
+        else if (isAutoIndex(index.name) && index.unique) {
+            lines.push(`UNIQUE (${columnList(dialect, index.columns)})`);
+        }
+        else if (!isAutoIndex(index.name)) {
+            separate.push(index);
+        }
+    }
+    for (const foreignKey of draft.foreignKeys) {
+        lines.push(foreignKeySql(dialect, schema, foreignKey));
+    }
+    const options = sqlite ? sqliteOptionsSql(draft.options).join(', ') : mysqlOptionsSql(draft.options).join(' ');
+    const head = `CREATE TABLE ${tableName(dialect, schema, name)} (\n${lines.map((line) => INDENT + line).join(',\n')}\n)`;
+    return { table: options === '' ? head : `${head} ${options}`, indexes: separate };
+};
+export const createTableSql = (dialect, schema, draft) => {
+    const { table, indexes } = createTableParts(dialect, schema, draft, draft.name);
+    return [table, ...indexes.map((index) => createIndexSql(dialect, schema, draft.name, index))];
+};

package/dist/ddl/dialect.d.ts

@@ -0,0 +1,12 @@
+import type { Engine, ServerInfo } from '../protocol/index.ts';
+export interface Dialect {
+    readonly flavor: ServerInfo['flavor'];
+    readonly engine: Engine;
+    readonly version: readonly number[];
+}
+export declare const dialectOf: (server: ServerInfo) => Dialect;
+export declare const atLeast: (dialect: Dialect, ...wanted: number[]) => boolean;
+export declare const quote: (dialect: Dialect, name: string) => string;
+export declare const tableName: (dialect: Dialect, schema: string, table: string) => string;
+export declare const sqliteSchemaPrefix: (dialect: Dialect, schema: string) => string;
+export declare const columnList: (dialect: Dialect, columns: readonly string[]) => string;

package/dist/ddl/dialect.js

@@ -0,0 +1,34 @@
+import { qualifiedName, quoteIdentifier } from '../sql.js';
+const VERSION = /(\d+(?:\.\d+)*)/;
+export const dialectOf = (server) => ({
+    flavor: server.flavor,
+    engine: server.flavor === 'sqlite' ? 'sqlite' : 'mysql',
+    version: (VERSION.exec(server.version)?.[1] ?? '')
+        .split('.')
+        .filter((part) => part !== '')
+        .map(Number)
+});
+/* Whether the server is at least this version. A version nobody could read counts as new enough. */
+export const atLeast = (dialect, ...wanted) => {
+    if (dialect.version.length === 0) {
+        return true;
+    }
+    for (let i = 0; i < wanted.length; i++) {
+        const have = dialect.version[i] ?? 0;
+        if (have !== wanted[i]) {
+            return have > wanted[i];
+        }
+    }
+    return true;
+};
+export const quote = (dialect, name) => quoteIdentifier(dialect.engine, name);
+/* SQLite reads an unqualified name as `main`, so only an attached schema is spelled out. */
+const schemaOf = (dialect, schema) => schema === '' || (dialect.engine === 'sqlite' && schema === 'main') ? undefined : schema;
+/* A table with its schema in front, when the statement needs one. */
+export const tableName = (dialect, schema, table) => qualifiedName({ engine: dialect.engine, table, schema: schemaOf(dialect, schema) });
+/* SQLite puts the schema in front of the name of an index, where MySQL names the table it is on. */
+export const sqliteSchemaPrefix = (dialect, schema) => {
+    const named = schemaOf(dialect, schema);
+    return named === undefined ? '' : `${quote(dialect, named)}.`;
+};
+export const columnList = (dialect, columns) => columns.map((column) => quote(dialect, column)).join(', ');

package/dist/ddl/diff.d.ts

@@ -0,0 +1,34 @@
+import type { Dialect } from './dialect.ts';
+import type { ColumnDraft, ForeignKeyDraft, IndexDraft, TableDraft } from './draft.ts';
+export interface KeptColumn {
+    readonly original: ColumnDraft;
+    readonly column: ColumnDraft;
+    readonly renamed: boolean;
+    readonly redefined: boolean;
+    readonly moved: boolean;
+    readonly after: string | null;
+}
+export interface AddedColumn {
+    readonly column: ColumnDraft;
+    readonly placed: boolean;
+    readonly after: string | null;
+}
+export interface RenamedIndex {
+    readonly from: IndexDraft;
+    readonly to: IndexDraft;
+}
+export interface TableDiff {
+    readonly renamed: boolean;
+    readonly droppedColumns: readonly ColumnDraft[];
+    readonly keptColumns: readonly KeptColumn[];
+    readonly addedColumns: readonly AddedColumn[];
+    readonly primaryKeyChanged: boolean;
+    readonly droppedIndexes: readonly IndexDraft[];
+    readonly addedIndexes: readonly IndexDraft[];
+    readonly renamedIndexes: readonly RenamedIndex[];
+    readonly droppedForeignKeys: readonly ForeignKeyDraft[];
+    readonly addedForeignKeys: readonly ForeignKeyDraft[];
+    readonly optionsChanged: boolean;
+}
+export declare const diffOf: (dialect: Dialect, original: TableDraft, draft: TableDraft) => TableDiff;
+export declare const dropsColumns: (original: TableDraft, draft: TableDraft) => boolean;

package/dist/ddl/diff.js

@@ -0,0 +1,111 @@
+import { sameDefinition } from './column.js';
+const sameList = (left, right) => left.length === right.length && left.every((name, at) => name === right[at]);
+/* The positions of a longest run that already is in order: those columns can stay where they are. */
+const longestRun = (positions) => {
+    const length = [];
+    const previous = [];
+    let best = -1;
+    for (let i = 0; i < positions.length; i++) {
+        length[i] = 1;
+        previous[i] = -1;
+        for (let before = 0; before < i; before++) {
+            if (positions[before] < positions[i] && length[before] + 1 > length[i]) {
+                length[i] = length[before] + 1;
+                previous[i] = before;
+            }
+        }
+        if (best < 0 || length[i] > length[best]) {
+            best = i;
+        }
+    }
+    const run = new Set();
+    for (let at = best; at >= 0; at = previous[at]) {
+        run.add(at);
+    }
+    return run;
+};
+const OPTION_FIELDS = ['engine', 'charset', 'collation', 'comment', 'withoutRowid', 'strict'];
+const matches = (original, draft) => draft.originalName !== null && (original.name === '' ? draft.key === original.key : draft.originalName === original.name);
+/* What a draft changes in the table it came from, told apart by the names items kept. */
+export const diffOf = (dialect, original, draft) => {
+    const survivors = draft.columns.filter((column) => column.originalName !== null);
+    const renames = new Map(survivors.map((column) => [column.originalName, column.name]));
+    const project = (names) => names.map((name) => renames.get(name) ?? name);
+    const originalOf = (name) => original.columns.find((column) => column.name === name);
+    const positions = survivors.map((column) => original.columns.findIndex((candidate) => candidate.name === column.originalName));
+    const staying = longestRun(positions);
+    let survivor = 0;
+    const keptColumns = [];
+    const addedColumns = [];
+    draft.columns.forEach((column, at) => {
+        const after = at === 0 ? null : draft.columns[at - 1].name;
+        if (column.originalName === null) {
+            addedColumns.push({ column, placed: draft.columns.slice(at + 1).some((later) => later.originalName !== null), after });
+            return;
+        }
+        const rank = survivor++;
+        const before = originalOf(column.originalName);
+        if (before === undefined) {
+            return;
+        }
+        keptColumns.push({
+            original: before,
+            column,
+            renamed: before.name !== column.name,
+            redefined: !sameDefinition(dialect, before, column),
+            moved: !staying.has(rank),
+            after
+        });
+    });
+    const droppedColumns = original.columns.filter((column) => !survivors.some((kept) => kept.originalName === column.name));
+    const droppedIndexes = [];
+    const addedIndexes = draft.indexes.filter((index) => index.originalName === null);
+    const renamedIndexes = [];
+    for (const before of original.indexes) {
+        const after = draft.indexes.find((index) => matches(before, index));
+        if (after === undefined) {
+            droppedIndexes.push(before);
+        }
+        else if (!sameList(project(before.columns), after.columns) || before.unique !== after.unique) {
+            droppedIndexes.push(before);
+            addedIndexes.push(after);
+        }
+        else if (before.name !== after.name) {
+            renamedIndexes.push({ from: before, to: after });
+        }
+    }
+    const droppedForeignKeys = [];
+    const addedForeignKeys = draft.foreignKeys.filter((key) => key.originalName === null);
+    for (const before of original.foreignKeys) {
+        const after = draft.foreignKeys.find((key) => matches(before, key));
+        const same = after !== undefined &&
+            before.name === after.name &&
+            sameList(project(before.columns), after.columns) &&
+            before.referencedSchema === after.referencedSchema &&
+            before.referencedTable === after.referencedTable &&
+            sameList(before.referencedColumns, after.referencedColumns) &&
+            before.onUpdate === after.onUpdate &&
+            before.onDelete === after.onDelete;
+        if (!same) {
+            droppedForeignKeys.push(before);
+            if (after !== undefined) {
+                addedForeignKeys.push(after);
+            }
+        }
+    }
+    return {
+        renamed: original.name !== draft.name,
+        droppedColumns,
+        keptColumns,
+        addedColumns,
+        primaryKeyChanged: !sameList(project(original.primaryKey), draft.primaryKey),
+        droppedIndexes,
+        addedIndexes,
+        renamedIndexes,
+        droppedForeignKeys,
+        addedForeignKeys,
+        optionsChanged: OPTION_FIELDS.some((field) => original.options[field] !== draft.options[field])
+    };
+};
+/* Whether applying the draft removes a column, and with it the data in it. */
+export const dropsColumns = (original, draft) => original.columns.some((column) => !draft.columns.some((kept) => kept.originalName === column.name));