@adecore/database 0.0.1 → 0.16.0-beta.0

package/src/console/StatementResultView.tsx

@@ -0,0 +1,176 @@
+import { useMemo, useState } from 'react';
+import { ChevronLeft, ChevronRight, CircleAlert, Download, PanelRight } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { Banner, IconButton, Menu, Spinner } from '@adecore/ui';
+import { formatDecimal, formatNumber } from '@adecore/ui/format';
+import { DataGrid } from '../grid/DataGrid.tsx';
+import { previewValueOf } from '../grid/focused-value.ts';
+import type { FocusedCell, GridRow } from '../grid/types.ts';
+import { ValueDock } from '../grid/ValueDock.tsx';
+import type { Engine, FileFormat, StatementResult } from '../protocol/index.ts';
+import type { SqlTarget } from '../sql.ts';
+import { ValuePanel } from '../value/ValuePanel.tsx';
+
+/* What "Copy as SQL INSERT" names the table of a result that comes from no table. */
+const RESULT_TABLE = 'result';
+
+const EXPORT_FORMATS: readonly FileFormat[] = ['csv', 'tsv', 'json', 'sql'];
+
+/* Paging through the rows of a statement that reads, one page at a time. */
+export interface ResultPager {
+    /* Counted from 1. */
+    readonly page: number;
+    readonly loading: boolean;
+    onPrevious(): void;
+    onNext(): void;
+}
+
+export interface StatementResultViewProps {
+    result: StatementResult;
+    /* The rows before the first one shown, so a later page counts on from the page before it. */
+    offset?: number;
+    /* Draws the controls of the page under the grid, in place of the note that more rows exist. */
+    pager?: ResultPager;
+    /* Offers the export menu in the footer of a result set; told the format chosen. */
+    onExport?(format: FileFormat): void;
+    exporting?: boolean;
+    /* The engine the statement ran on, which decides how "Copy as SQL INSERT" quotes. Without it that format is not offered. */
+    engine?: Engine;
+    valuePanelOpen?: boolean;
+    /* Offers the toggle of the value panel in the footer of a result set. */
+    onValuePanelOpenChange?(open: boolean): void;
+}
+
+/* One statement's outcome: a result set in a read-only grid, a count of affected rows, or the error the server gave. */
+export function StatementResultView({
+    result,
+    offset = 0,
+    pager,
+    onExport,
+    exporting = false,
+    engine,
+    valuePanelOpen = false,
+    onValuePanelOpenChange
+}: StatementResultViewProps) {
+    const { t } = useTranslation('database');
+    const [focus, setFocus] = useState<FocusedCell | null>(null);
+    const rows = useMemo(
+        () => (result.kind === 'rows' ? result.rows.map((cells, index): GridRow => ({ key: `row:${index}`, number: offset + index + 1, cells })) : []),
+        [result, offset]
+    );
+    const sqlTarget = useMemo((): SqlTarget | undefined => (engine === undefined ? undefined : { engine, table: RESULT_TABLE }), [engine]);
+    const elapsed = t('console.elapsed', { value: formatDecimal(result.elapsedMs) });
+
+    if (result.kind === 'error') {
+        return (
+            <div className="flex min-h-0 flex-1 flex-col gap-3 p-3">
+                <Banner
+                    icon={CircleAlert}
+                    tone="error"
+                    className="min-w-0"
+                    message={
+                        <>
+                            {result.error.message}
+                            {result.error.sqlState !== undefined && (
+                                <span className="ml-2 font-mono text-xs text-text-muted">{t('console.sqlState', { state: result.error.sqlState })}</span>
+                            )}
+                        </>
+                    }
+                />
+                <p className="px-1 text-xs text-text-muted tabular-nums">{elapsed}</p>
+            </div>
+        );
+    }
+
+    if (result.kind === 'done') {
+        return (
+            <div className="flex flex-col gap-1 p-4 text-sm text-text">
+                <p>{t('console.affected', { count: result.affected, formatted: formatNumber(result.affected) })}</p>
+                {result.lastInsertId !== null && <p className="text-xs text-text-muted">{t('console.lastInsertId', { id: String(result.lastInsertId) })}</p>}
+                <p className="text-xs text-text-muted tabular-nums">{elapsed}</p>
+            </div>
+        );
+    }
+
+    const focusedRow = valuePanelOpen && focus !== null ? rows.find((row) => row.key === focus.rowKey) : undefined;
+    const focusedCell = focus === null ? undefined : focusedRow?.cells[focus.column];
+
+    return (
+        <>
+            <ValueDock
+                open={valuePanelOpen}
+                panel={
+                    <ValuePanel
+                        column={focus === null ? null : (result.columns[focus.column] ?? null)}
+                        value={focusedCell === undefined ? undefined : previewValueOf(focusedCell)}
+                        loading={false}
+                        editable={false}
+                        onClose={() => onValuePanelOpenChange?.(false)}
+                        className="min-w-0 flex-1"
+                    />
+                }
+            >
+                <DataGrid
+                    label={t('console.result')}
+                    columns={result.columns}
+                    rows={rows}
+                    empty={t('console.noRows')}
+                    sqlTarget={sqlTarget}
+                    onFocusedCellChange={setFocus}
+                />
+            </ValueDock>
+            <footer className="flex h-10 shrink-0 items-center gap-4 border-t border-border px-3 text-xs text-text-muted">
+                <span className="text-text tabular-nums">
+                    {offset > 0 || pager !== undefined
+                        ? t('console.rowRange', { from: formatNumber(offset + Math.min(1, rows.length)), to: formatNumber(offset + rows.length) })
+                        : t('console.rows', { rows: formatNumber(result.rows.length) })}
+                </span>
+                {pager === undefined && result.hasMore && <span>{t('console.hasMore')}</span>}
+                <span className="tabular-nums">{elapsed}</span>
+                <span className="ml-auto flex items-center gap-1">
+                    {pager !== undefined && (
+                        <>
+                            {pager.loading && <Spinner size={14} label={t('console.loading')} />}
+                            <IconButton
+                                icon={ChevronLeft}
+                                size="sm"
+                                label={t('console.previousPage')}
+                                disabled={pager.page <= 1 || pager.loading}
+                                onClick={pager.onPrevious}
+                            />
+                            <span className="min-w-12 text-center tabular-nums">{t('console.page', { page: formatNumber(pager.page) })}</span>
+                            <IconButton
+                                icon={ChevronRight}
+                                size="sm"
+                                label={t('console.nextPage')}
+                                disabled={!result.hasMore || pager.loading}
+                                onClick={pager.onNext}
+                            />
+                        </>
+                    )}
+                    {onExport !== undefined && (
+                        <Menu.Root>
+                            <IconButton icon={Download} size="sm" label={t('console.export')} disabled={exporting} render={<Menu.Trigger />} />
+                            <Menu.Popup>
+                                {EXPORT_FORMATS.map((format) => (
+                                    <Menu.Item key={format} onClick={() => onExport(format)}>
+                                        {t('console.exportAs', { format: format.toUpperCase() })}
+                                    </Menu.Item>
+                                ))}
+                            </Menu.Popup>
+                        </Menu.Root>
+                    )}
+                    {onValuePanelOpenChange !== undefined && (
+                        <IconButton
+                            icon={PanelRight}
+                            size="sm"
+                            label={t('console.valuePanel')}
+                            aria-pressed={valuePanelOpen}
+                            onClick={() => onValuePanelOpenChange(!valuePanelOpen)}
+                        />
+                    )}
+                </span>
+            </footer>
+        </>
+    );
+}

package/src/console/TransactionControls.tsx

@@ -0,0 +1,53 @@
+import type { Ref } from 'react';
+import clsx from 'clsx';
+import { useTranslation } from 'react-i18next';
+import { Button, Pill, Segmented, Tooltip } from '@adecore/ui';
+
+export type TransactionMode = 'auto' | 'manual';
+
+export interface TransactionControlsProps {
+    mode: TransactionMode;
+    onModeChange(mode: TransactionMode): void;
+    /* Whether a transaction is open on the session, whichever mode began it. */
+    open: boolean;
+    /* The console is running a statement or settling a transaction. */
+    busy: boolean;
+    onCommit(): void;
+    onRollback(): void;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+
+/* Auto or manual commits, and while a transaction is open, the way to end it. */
+export function TransactionControls({ mode, onModeChange, open, busy, onCommit, onRollback, className, ref }: TransactionControlsProps) {
+    const { t } = useTranslation('database');
+    return (
+        <div ref={ref} className={clsx('flex items-center gap-2', className)}>
+            <Tooltip label={t('console.transaction.hint')}>
+                <div className="flex">
+                    <Segmented
+                        value={mode}
+                        onValueChange={onModeChange}
+                        disabled={busy}
+                        label={t('console.transaction.mode')}
+                        options={[
+                            { id: 'auto', label: t('console.transaction.auto') },
+                            { id: 'manual', label: t('console.transaction.manual') }
+                        ]}
+                    />
+                </div>
+            </Tooltip>
+            {open && (
+                <>
+                    <Pill tone="needsYou">{t('console.transaction.open')}</Pill>
+                    <Button size="xs" variant="secondary" disabled={busy} onClick={onCommit}>
+                        {t('console.transaction.commit')}
+                    </Button>
+                    <Button size="xs" variant="danger-outline" disabled={busy} onClick={onRollback}>
+                        {t('console.transaction.rollback')}
+                    </Button>
+                </>
+            )}
+        </div>
+    );
+}

package/src/console/destructive.ts

@@ -0,0 +1,60 @@
+import type { Engine } from '../protocol/index.ts';
+import { splitStatements, tokenize } from '../sql-split.ts';
+
+export type DestructiveKind = 'drop' | 'truncate' | 'delete' | 'update' | 'alterDrop';
+
+/* A statement that takes data or structure away with no way back, and why it counts. */
+export interface DestructiveStatement {
+    readonly sql: string;
+    readonly kind: DestructiveKind;
+}
+
+interface Word {
+    readonly word: string;
+    /* How many parentheses are open at the word. */
+    readonly depth: number;
+}
+
+const wordsOf = (sql: string, engine: Engine): Word[] => {
+    const words: Word[] = [];
+    let depth = 0;
+    for (const token of tokenize(sql, engine)) {
+        const text = sql.slice(token.start, token.end);
+        if (token.kind === 'word') {
+            words.push({ word: text.toUpperCase(), depth });
+        } else if (token.kind === 'punct' && text === '(') {
+            depth += 1;
+        } else if (token.kind === 'punct' && text === ')') {
+            depth = Math.max(0, depth - 1);
+        }
+    }
+    return words;
+};
+
+const kindOf = (sql: string, engine: Engine): DestructiveKind | null => {
+    const words = wordsOf(sql, engine);
+    const first = words[0]?.word;
+    if (first === 'DROP') {
+        return 'drop';
+    }
+    if (first === 'TRUNCATE') {
+        return 'truncate';
+    }
+    if (first === 'ALTER') {
+        return words.some(({ word }) => word === 'DROP') ? 'alterDrop' : null;
+    }
+    // A statement behind a `WITH` is the first DELETE or UPDATE outside any parentheses.
+    const writer = first === 'WITH' ? words.find(({ word, depth }) => depth === 0 && (word === 'DELETE' || word === 'UPDATE')) : words[0];
+    if (writer?.word !== 'DELETE' && writer?.word !== 'UPDATE') {
+        return null;
+    }
+    const filtered = words.some(({ word, depth }) => word === 'WHERE' && depth === 0);
+    return filtered ? null : writer.word === 'DELETE' ? 'delete' : 'update';
+};
+
+/* The statements of a script that drop, truncate, or delete or update without a `WHERE`. */
+export const findDestructive = (sql: string, engine: Engine): DestructiveStatement[] =>
+    splitStatements(sql, engine).flatMap((statement) => {
+        const kind = kindOf(statement.text, engine);
+        return kind === null ? [] : [{ sql: statement.text, kind }];
+    });

package/src/console/editing.ts

@@ -0,0 +1,77 @@
+/* One text change: the range replaced, what replaces it, and where the selection lands in the new text. */
+export interface TextEdit {
+    readonly from: number;
+    readonly to: number;
+    readonly insert: string;
+    readonly selectionStart: number;
+    readonly selectionEnd: number;
+}
+
+export const INDENT = '    ';
+
+export const applyEdit = (value: string, edit: TextEdit): string => value.slice(0, edit.from) + edit.insert + value.slice(edit.to);
+
+const lineStartOf = (value: string, at: number): number => value.lastIndexOf('\n', at - 1) + 1;
+
+const lineEndOf = (value: string, at: number): number => {
+    const newline = value.indexOf('\n', at);
+    return newline === -1 ? value.length : newline;
+};
+
+/* The whitespace a line begins with. */
+const indentOf = (line: string): string => /^[ \t]*/.exec(line)![0];
+
+/* The lines a selection touches. A selection that ends at the start of a line leaves that line out. */
+const touchedLines = (value: string, start: number, end: number): { from: number; to: number } => {
+    const from = lineStartOf(value, start);
+    const last = end > start && value[end - 1] === '\n' ? end - 1 : end;
+    return { from, to: lineEndOf(value, last) };
+};
+
+/* Tab: four spaces at the caret, or one indent level on every touched line when the selection spans lines. */
+export const indentEdit = (value: string, start: number, end: number): TextEdit => {
+    if (!value.slice(start, end).includes('\n')) {
+        return { from: start, to: end, insert: INDENT, selectionStart: start + INDENT.length, selectionEnd: start + INDENT.length };
+    }
+    const { from, to } = touchedLines(value, start, end);
+    const lines = value.slice(from, to).split('\n');
+    return {
+        from,
+        to,
+        insert: lines.map((line) => (line === '' ? line : INDENT + line)).join('\n'),
+        selectionStart: start + (lines[0] === '' ? 0 : INDENT.length),
+        selectionEnd: end + lines.filter((line) => line !== '').length * INDENT.length
+    };
+};
+
+/* Shift+Tab: takes one level of indentation off every touched line, four spaces or one tab. */
+export const outdentEdit = (value: string, start: number, end: number): TextEdit | null => {
+    const { from, to } = touchedLines(value, start, end);
+    const lines = value.slice(from, to).split('\n');
+    const removed = lines.map((line) => {
+        if (line.startsWith('\t')) {
+            return 1;
+        }
+        return Math.min(INDENT.length, /^ */.exec(line)![0].length);
+    });
+    const total = removed.reduce((sum, count) => sum + count, 0);
+    if (total === 0) {
+        return null;
+    }
+    const firstLineStart = from;
+    return {
+        from,
+        to,
+        insert: lines.map((line, index) => line.slice(removed[index]!)).join('\n'),
+        selectionStart: Math.max(firstLineStart, start - removed[0]!),
+        selectionEnd: Math.max(firstLineStart, end - total)
+    };
+};
+
+/* Enter: a new line that starts with the indentation of the line the caret is on, up to the caret. */
+export const newlineEdit = (value: string, start: number, end: number): TextEdit => {
+    const lineStart = lineStartOf(value, start);
+    const indent = indentOf(value.slice(lineStart, start));
+    const insert = `\n${indent}`;
+    return { from: start, to: end, insert, selectionStart: start + insert.length, selectionEnd: start + insert.length };
+};

package/src/console/history.ts

@@ -0,0 +1,62 @@
+/* One run of the console, as the history list keeps it. */
+export interface HistoryEntry {
+    readonly sql: string;
+    /* Milliseconds since the epoch. */
+    readonly at: number;
+    /* The name the connection had at the time. */
+    readonly connection: string;
+    readonly ok: boolean;
+    /* Rows read or affected, summed over the statements; `null` when the run failed before any count. */
+    readonly rows: number | null;
+}
+
+export const HISTORY_LIMIT = 200;
+
+export const historyKey = (connectionId: string): string => `database:console-history:${connectionId}`;
+
+const isEntry = (value: unknown): value is HistoryEntry => {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const entry = value as Record<string, unknown>;
+    return (
+        typeof entry.sql === 'string' &&
+        typeof entry.at === 'number' &&
+        typeof entry.connection === 'string' &&
+        typeof entry.ok === 'boolean' &&
+        (entry.rows === null || typeof entry.rows === 'number')
+    );
+};
+
+/* Reads what `serializeHistory` wrote. Anything that does not fit gives an empty list, or leaves out the entries that do not fit. */
+export const parseHistory = (raw: string | null): HistoryEntry[] => {
+    if (raw === null) {
+        return [];
+    }
+    try {
+        const parsed: unknown = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter(isEntry).slice(0, HISTORY_LIMIT) : [];
+    } catch {
+        return [];
+    }
+};
+
+export const serializeHistory = (entries: readonly HistoryEntry[]): string => JSON.stringify(entries);
+
+/* The list with the run in front. A run of the same SQL as the latest one replaces it. */
+export const addEntry = (entries: readonly HistoryEntry[], entry: HistoryEntry): HistoryEntry[] => {
+    const rest = entries[0]?.sql.trim() === entry.sql.trim() ? entries.slice(1) : entries;
+    return [entry, ...rest].slice(0, HISTORY_LIMIT);
+};
+
+/* The entries whose SQL holds every word of the query, in any case. */
+export const searchHistory = (entries: readonly HistoryEntry[], query: string): readonly HistoryEntry[] => {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+        return entries;
+    }
+    return entries.filter((entry) => {
+        const sql = entry.sql.toLowerCase();
+        return words.every((word) => sql.includes(word));
+    });
+};

package/src/console/labels.ts

@@ -0,0 +1,7 @@
+const LABEL_LENGTH = 32;
+
+/* The tab of a statement: its SQL on one line, cut where it gets long. */
+export const statementLabel = (sql: string): string => {
+    const line = sql.replace(/\s+/g, ' ').trim();
+    return line.length > LABEL_LENGTH ? `${line.slice(0, LABEL_LENGTH - 1).trimEnd()}…` : line;
+};

package/src/console/outcome.ts

@@ -0,0 +1,14 @@
+import type { Engine, StatementResult } from '../protocol/index.ts';
+import { firstKeyword } from '../sql-split.ts';
+
+/* How a run ended, for the history: whether every statement worked, and how many rows they read or changed. */
+export const outcomeOf = (results: readonly StatementResult[]): { readonly ok: boolean; readonly rows: number } => ({
+    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: string, engine: Engine): boolean => {
+    const keyword = firstKeyword(sql, engine);
+    return keyword === 'SELECT' || keyword === 'WITH';
+};

package/src/console/schemas.ts

@@ -0,0 +1,7 @@
+import type { SchemaInfo } from '../protocol/index.ts';
+
+/* The schemas a person works in first, the ones the server keeps for itself last. */
+export const orderSchemas = (schemas: readonly SchemaInfo[]): SchemaInfo[] => [
+    ...schemas.filter((schema) => !schema.system),
+    ...schemas.filter((schema) => schema.system)
+];

package/src/console/shortcuts.ts

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

package/src/console/useConsoleHistory.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+import { useDatabaseStorage } from '../client-context.ts';
+import { addEntry, historyKey, parseHistory, serializeHistory, type HistoryEntry } from './history.ts';
+
+interface Loaded {
+    readonly key: string;
+    readonly entries: readonly HistoryEntry[];
+    /* Whether the list differs from what the storage holds. */
+    readonly changed: boolean;
+}
+
+export interface ConsoleHistory {
+    readonly entries: readonly HistoryEntry[];
+    record(entry: HistoryEntry): void;
+    clear(): void;
+}
+
+/* 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: string): ConsoleHistory {
+    const storage = useDatabaseStorage();
+    const key = historyKey(connectionId);
+    const [state, setState] = useState<Loaded>(() => ({ 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/src/ddl/alter-mysql.ts

@@ -0,0 +1,90 @@
+import { columnSpecSql } from './column.ts';
+import { foreignKeySql, mysqlOptionsSql } from './create.ts';
+import { columnList, quote, tableName, type Dialect } from './dialect.ts';
+import type { TableDiff } from './diff.ts';
+import type { ColumnDraft, IndexDraft, TableDraft } from './draft.ts';
+
+const positionSql = (dialect: Dialect, after: string | null): string => (after === null ? 'FIRST' : `AFTER ${quote(dialect, after)}`);
+
+const indexSql = (dialect: Dialect, index: IndexDraft): string =>
+    [
+        'ADD',
+        index.unique ? 'UNIQUE INDEX' : 'INDEX',
+        ...(index.name === '' ? [] : [quote(dialect, index.name)]),
+        `(${columnList(dialect, index.columns)})`
+    ].join(' ');
+
+const withPosition = (clause: string, position: string | null): string => (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: Dialect, schema: string, original: TableDraft, draft: TableDraft, diff: TableDiff): string[] => {
+    const early: string[] = [];
+    const late: string[] = [];
+    const column = (verb: 'CHANGE' | 'MODIFY' | 'ADD', target: ColumnDraft, previous: string | null, position: string | null): string => {
+        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: readonly string[]): string[] => (clauses.length === 0 ? [] : [`ALTER TABLE ${target}\n    ${clauses.join(',\n    ')}`]);
+    return split ? [...statement(early), ...statement(late)] : statement([...early, ...late]);
+};