ormbridge 0.3.0 → 0.5.0

package/dist/parsers/sqlDdl.js

@@ -0,0 +1,2302 @@
+import { basename } from 'node:path';
+import { singularize, toPascalCase, toSnakeCase } from '../naming.js';
+import { describeThrown, err, ok } from '../result.js';
+import { Cursor, detectDialect, MAX_SOURCE_CHARACTERS, sourceOf, splitStatements, splitTopLevel, tokenize, } from './sqlSyntax.js';
+import { defaultExpression, interpretDefault, mapType, parseType, } from './sqlTypes.js';
+const DEFAULT_SCHEMAS = new Set(['public', 'dbo', 'main']);
+const MAX_WARNINGS = 400;
+/** An enum with more members than this takes ALTER TYPE ... ADD VALUE ... BEFORE / AFTER at the end. */
+const MAX_POSITIONED_ENUM_VALUES = 10_000;
+function warn(ctx, message) {
+    if (ctx.warnings.length < MAX_WARNINGS) {
+        ctx.warnings.push(message);
+    }
+    else {
+        ctx.suppressedWarnings += 1;
+    }
+}
+function recordSkipped(ctx, file, kind, line) {
+    const entry = ctx.skipped.get(kind);
+    if (entry === undefined) {
+        ctx.skipped.set(kind, { count: 1, first: `${file.name}:${line}` });
+    }
+    else {
+        entry.count += 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/**
+ * Reads SQL DDL (PostgreSQL, MySQL / MariaDB, SQLite and SQL Server) into the shared model. Never throws:
+ * input it cannot read becomes a warning, or an error result when no table was found at all.
+ */
+export function parseSqlDdl(sources, options) {
+    try {
+        return parseSources(sources, options);
+    }
+    catch (thrown) {
+        return err('PARSE_FAILED', `The SQL input could not be converted: ${describeThrown(thrown)}`);
+    }
+}
+function parseSources(sources, options) {
+    const totalCharacters = sources.reduce((sum, source) => sum + source.text.length, 0);
+    if (totalCharacters > MAX_SOURCE_CHARACTERS) {
+        return err('PARSE_FAILED', `The SQL input is too large (${totalCharacters} characters; the limit is ${MAX_SOURCE_CHARACTERS}). Split it into smaller files.`);
+    }
+    const ctx = {
+        tables: [],
+        tableByKey: new Map(),
+        tablesByName: new Map(),
+        enums: [],
+        enumsByName: new Map(),
+        warnings: [],
+        suppressedWarnings: 0,
+        skipped: new Map(),
+    };
+    for (const source of sources) {
+        const dialect = options.dialect ?? detectDialect(source.text);
+        const file = {
+            name: basename(source.path),
+            text: source.text,
+            dialect,
+        };
+        const scanned = tokenize(source.text, dialect);
+        if (scanned.truncated) {
+            warn(ctx, `${file.name}: the file has too many tokens; everything after the first ${scanned.tokens.length} was ignored.`);
+        }
+        for (const statement of splitStatements(scanned.tokens)) {
+            try {
+                handleStatement(ctx, file, statement);
+            }
+            catch (thrown) {
+                warn(ctx, `${file.name}:${statement[0]?.line ?? 0}: a statement could not be read (${describeThrown(thrown)}) and was skipped.`);
+            }
+        }
+    }
+    for (const [kind, entry] of ctx.skipped) {
+        warn(ctx, `Skipped ${entry.count} ${kind} statement${entry.count === 1 ? '' : 's'} (first at ${entry.first}): ${describeSkipReason(kind)}`);
+    }
+    const liveTables = ctx.tables.filter((table) => !table.dropped);
+    if (liveTables.length === 0) {
+        return err('NO_MODELS_FOUND', 'No CREATE TABLE statements were found in the SQL input.');
+    }
+    const schema = buildSchema(ctx, liveTables, options);
+    if (ctx.suppressedWarnings > 0) {
+        schema.warnings.push(`${ctx.suppressedWarnings} more warnings were not shown.`);
+    }
+    return ok(schema);
+}
+function describeSkipReason(kind) {
+    if (kind === 'data') {
+        return 'row data is not part of the schema.';
+    }
+    if (/^CREATE (OR REPLACE )?(MATERIALIZED )?VIEW/.test(kind)) {
+        return 'views are not read.';
+    }
+    if (kind.startsWith('ALTER TABLE')) {
+        return 'the change is not replayed, so the result may differ from the final database.';
+    }
+    return 'it has no equivalent in the shared model.';
+}
+// ---------------------------------------------------------------------------
+// Statements
+// ---------------------------------------------------------------------------
+/** Statements that never matter to the schema and are skipped without a warning. */
+const QUIET_STATEMENTS = new Set([
+    'SET',
+    'USE',
+    'GRANT',
+    'REVOKE',
+    'BEGIN',
+    'START',
+    'COMMIT',
+    'END',
+    'ROLLBACK',
+    'SAVEPOINT',
+    'RELEASE',
+    'PRAGMA',
+    'LOCK',
+    'UNLOCK',
+    'COMMENT',
+    'ANALYZE',
+    'VACUUM',
+    'REINDEX',
+    'CLUSTER',
+    'RESET',
+    'PRINT',
+    'DECLARE',
+    'GO',
+    'SHOW',
+    'DO',
+    'EXEC',
+    'EXECUTE',
+    'CHECKPOINT',
+    'DISCARD',
+]);
+/** Data statements, reported together as one warning. */
+const DATA_STATEMENTS = new Set([
+    'INSERT',
+    'UPDATE',
+    'DELETE',
+    'SELECT',
+    'COPY',
+    'TRUNCATE',
+    'MERGE',
+    'REPLACE',
+    'WITH',
+    'VALUES',
+]);
+/** CREATE statements with no schema meaning for this reader and no value in warning about. */
+const QUIET_CREATES = new Set([
+    'EXTENSION',
+    'SCHEMA',
+    'DATABASE',
+    'ROLE',
+    'USER',
+    'TABLESPACE',
+    'LANGUAGE',
+    'COLLATION',
+    'SERVER',
+    'LOGIN',
+    'CAST',
+    'OPERATOR',
+    'AGGREGATE',
+    'PUBLICATION',
+    'SUBSCRIPTION',
+    'POLICY',
+    'RULE',
+]);
+function handleStatement(ctx, file, tokens) {
+    const cursor = new Cursor(tokens);
+    const head = cursor.peek();
+    const line = head.line;
+    if (head.kind !== 'word') {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    if (QUIET_STATEMENTS.has(head.up)) {
+        return;
+    }
+    if (DATA_STATEMENTS.has(head.up)) {
+        recordSkipped(ctx, file, 'data', line);
+        return;
+    }
+    switch (head.up) {
+        case 'CREATE':
+            handleCreate(ctx, file, cursor);
+            return;
+        case 'ALTER':
+            handleAlter(ctx, file, cursor);
+            return;
+        case 'DROP':
+            handleDrop(ctx, file, cursor);
+            return;
+        default:
+            recordSkipped(ctx, file, head.up, line);
+    }
+}
+function handleCreate(ctx, file, cursor) {
+    const line = cursor.peek().line;
+    cursor.next();
+    let isTemporary = false;
+    let modifiers = '';
+    for (;;) {
+        const word = cursor.peek();
+        if (word.kind !== 'word') {
+            break;
+        }
+        if (word.up === 'OR' && cursor.isKeyword('REPLACE', 1)) {
+            modifiers += 'OR REPLACE ';
+            cursor.next();
+            cursor.next();
+        }
+        else if (word.up === 'TEMP' || word.up === 'TEMPORARY') {
+            isTemporary = true;
+            cursor.next();
+        }
+        else if (word.up === 'GLOBAL' ||
+            word.up === 'LOCAL' ||
+            word.up === 'UNLOGGED' ||
+            word.up === 'MATERIALIZED') {
+            if (word.up === 'MATERIALIZED') {
+                modifiers += 'MATERIALIZED ';
+            }
+            cursor.next();
+        }
+        else {
+            break;
+        }
+    }
+    const kind = cursor.peek();
+    if (kind.kind !== 'word') {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    if (kind.up === 'TABLE') {
+        if (isTemporary) {
+            recordSkipped(ctx, file, 'CREATE TEMPORARY TABLE', line);
+            return;
+        }
+        createTable(ctx, file, cursor, line);
+        return;
+    }
+    if (kind.up === 'INDEX' ||
+        kind.up === 'UNIQUE' ||
+        kind.up === 'FULLTEXT' ||
+        kind.up === 'SPATIAL' ||
+        kind.up === 'CLUSTERED' ||
+        kind.up === 'NONCLUSTERED' ||
+        kind.up === 'COLUMNSTORE' ||
+        kind.up === 'BITMAP') {
+        createIndex(ctx, file, cursor, line);
+        return;
+    }
+    if (kind.up === 'TYPE') {
+        createType(ctx, file, cursor, line);
+        return;
+    }
+    if (QUIET_CREATES.has(kind.up)) {
+        return;
+    }
+    recordSkipped(ctx, file, `CREATE ${modifiers}${kind.up}`, line);
+}
+function parseQualifiedName(cursor) {
+    const parts = [];
+    for (;;) {
+        const token = cursor.peek();
+        if (token.kind !== 'word' && token.kind !== 'ident') {
+            break;
+        }
+        parts.push(token.value);
+        cursor.next();
+        if (cursor.isPunct('.')) {
+            cursor.next();
+            // SQL Server allows an omitted schema: db..table.
+            while (cursor.isPunct('.')) {
+                cursor.next();
+            }
+            continue;
+        }
+        break;
+    }
+    const name = parts[parts.length - 1];
+    if (name === undefined) {
+        return undefined;
+    }
+    const schema = parts[parts.length - 2];
+    return schema === undefined ? { name } : { schema, name };
+}
+/** MySQL names a database where other systems name a schema, so the qualifier is not kept. */
+function normalizedSchema(name, dialect) {
+    return dialect === 'mysql' ? undefined : name.schema;
+}
+function tableKey(schema, name) {
+    return `${(schema ?? '').toLowerCase()}.${name.toLowerCase()}`;
+}
+const CONSTRAINT_START_WORDS = new Set([
+    'NOT',
+    'NULL',
+    'DEFAULT',
+    'PRIMARY',
+    'UNIQUE',
+    'REFERENCES',
+    'CHECK',
+    'CONSTRAINT',
+    'COLLATE',
+    'GENERATED',
+    'AS',
+    'AUTOINCREMENT',
+    'AUTO_INCREMENT',
+    'IDENTITY',
+    'COMMENT',
+    'ON',
+]);
+function createTable(ctx, file, cursor, line) {
+    cursor.next();
+    const ifNotExists = cursor.acceptKeywords('IF', 'NOT', 'EXISTS');
+    const name = parseQualifiedName(cursor);
+    if (name === undefined) {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    const label = name.name;
+    if (!cursor.isPunct('(')) {
+        recordSkipped(ctx, file, cursor.isKeyword('AS')
+            ? 'CREATE TABLE ... AS SELECT'
+            : cursor.isKeyword('PARTITION')
+                ? 'CREATE TABLE ... PARTITION OF'
+                : 'CREATE TABLE without a column list', line);
+        return;
+    }
+    const group = cursor.readGroup() ?? [];
+    const table = {
+        ...(normalizedSchema(name, file.dialect) === undefined
+            ? {}
+            : { schema: normalizedSchema(name, file.dialect) }),
+        name: name.name,
+        columns: [],
+        columnIndex: new Map(),
+        uniques: [],
+        references: [],
+        indexes: [],
+        checks: [],
+        withoutRowid: false,
+        dialect: file.dialect,
+        line,
+        file: file.name,
+        dropped: false,
+    };
+    // Table options after the column list.
+    while (!cursor.atEnd) {
+        const token = cursor.next();
+        if (token.kind !== 'word') {
+            continue;
+        }
+        if (token.up === 'WITHOUT' && cursor.isKeyword('ROWID')) {
+            table.withoutRowid = true;
+        }
+        else if (token.up === 'INHERITS' && cursor.isPunct('(')) {
+            warn(ctx, `table "${label}": INHERITS is not read; the columns of the parent table are not copied.`);
+        }
+        else if (token.up === 'PARTITION' && cursor.isKeyword('BY')) {
+            warn(ctx, `table "${label}": the partitioning clause is not read; the table is read as an ordinary table.`);
+        }
+    }
+    for (const element of splitTopLevel(group)) {
+        const parser = new Cursor(element);
+        if (isConstraintStart(parser, file.dialect)) {
+            if (parser.isKeyword('LIKE')) {
+                warn(ctx, `table "${label}": LIKE copies columns from another table and is not read.`);
+                continue;
+            }
+            applyConstraint(ctx, table, parseTableConstraint(ctx, file, parser, label));
+            continue;
+        }
+        const column = parseColumn(ctx, file, parser, table, label);
+        if (column === undefined) {
+            warn(ctx, `table "${label}": ${file.name}:${element[0]?.line ?? line}: a column definition could not be read and was skipped.`);
+        }
+    }
+    registerTable(ctx, table, ifNotExists);
+}
+function registerTable(ctx, table, ifNotExists) {
+    const key = tableKey(table.schema, table.name);
+    const existing = ctx.tableByKey.get(key);
+    if (existing !== undefined && !existing.dropped) {
+        if (ifNotExists) {
+            return;
+        }
+        warn(ctx, `table "${table.name}" is created twice (${existing.file}:${existing.line} and ${table.file}:${table.line}); the later definition is used.`);
+        existing.dropped = true;
+    }
+    ctx.tables.push(table);
+    ctx.tableByKey.set(key, table);
+    const byName = ctx.tablesByName.get(table.name.toLowerCase()) ?? [];
+    byName.push(table);
+    ctx.tablesByName.set(table.name.toLowerCase(), byName);
+}
+function isConstraintStart(cursor, dialect) {
+    const head = cursor.peek();
+    if (head.kind !== 'word') {
+        return false;
+    }
+    const next = cursor.peek(1);
+    switch (head.up) {
+        case 'CONSTRAINT':
+            return true;
+        case 'PRIMARY':
+        case 'FOREIGN':
+            return cursor.isKeyword('KEY', 1);
+        case 'UNIQUE':
+            return (cursor.isPunct('(', 1) ||
+                cursor.isKeyword('KEY', 1) ||
+                cursor.isKeyword('INDEX', 1) ||
+                cursor.isKeyword('CLUSTERED', 1) ||
+                cursor.isKeyword('NONCLUSTERED', 1) ||
+                ((next.kind === 'word' || next.kind === 'ident') &&
+                    cursor.isPunct('(', 2)));
+        case 'CHECK':
+            return cursor.isPunct('(', 1);
+        case 'EXCLUDE':
+            return cursor.isKeyword('USING', 1) || cursor.isPunct('(', 1);
+        case 'LIKE':
+            return dialect === 'postgresql';
+        case 'PERIOD':
+            return cursor.isKeyword('FOR', 1);
+        case 'KEY':
+        case 'INDEX':
+        case 'FULLTEXT':
+        case 'SPATIAL':
+            return dialect === 'mysql';
+        default:
+            return false;
+    }
+}
+/** Reads the column names of `( a, b DESC, c(10) )`. */
+function readColumnList(cursor) {
+    const group = cursor.readGroup();
+    if (group === undefined) {
+        return [];
+    }
+    const names = [];
+    for (const element of splitTopLevel(group)) {
+        const first = element[0];
+        if (first !== undefined &&
+            (first.kind === 'word' || first.kind === 'ident')) {
+            names.push(first.value);
+        }
+    }
+    return names;
+}
+function readIndexElements(group) {
+    const elements = [];
+    for (const element of splitTopLevel(group)) {
+        const first = element[0];
+        if (first === undefined) {
+            continue;
+        }
+        const second = element[1];
+        const isColumnToken = first.kind === 'ident' ||
+            (first.kind === 'word' &&
+                !(second?.kind === 'punct' &&
+                    second.text === '(' &&
+                    element.length > 4));
+        const isPrefixLength = second?.kind === 'punct' &&
+            second.text === '(' &&
+            element[2]?.kind === 'number' &&
+            element[3]?.kind === 'punct' &&
+            element[3].text === ')';
+        if (!isColumnToken ||
+            (second?.kind === 'punct' && second.text === '(' && !isPrefixLength) ||
+            (second?.kind === 'punct' && second.text === '.')) {
+            elements.push({ isExpression: true, descending: false });
+            continue;
+        }
+        const parsed = {
+            column: first.value,
+            isExpression: false,
+            descending: false,
+        };
+        let at = 1;
+        if (isPrefixLength) {
+            parsed.length = Number(element[2]?.value ?? '0');
+            at = 4;
+        }
+        while (at < element.length) {
+            const token = element[at];
+            if (token === undefined) {
+                break;
+            }
+            if (token.kind === 'word' && token.up === 'DESC') {
+                parsed.descending = true;
+            }
+            else if (token.kind === 'word' && token.up === 'COLLATE') {
+                at += 1;
+            }
+            else if (token.kind === 'word' && token.up === 'NULLS') {
+                at += 1;
+            }
+            else if (token.kind === 'word' &&
+                token.up !== 'ASC' &&
+                parsed.ops === undefined) {
+                parsed.ops = token.value;
+            }
+            else if (token.kind === 'punct' && token.text === '(') {
+                let depth = 0;
+                while (at < element.length) {
+                    const inner = element[at];
+                    if (inner?.kind === 'punct' && inner.text === '(') {
+                        depth += 1;
+                    }
+                    else if (inner?.kind === 'punct' && inner.text === ')') {
+                        depth -= 1;
+                        if (depth === 0) {
+                            break;
+                        }
+                    }
+                    at += 1;
+                }
+            }
+            at += 1;
+        }
+        elements.push(parsed);
+    }
+    return elements;
+}
+const ACTIONS = {
+    CASCADE: 'cascade',
+    RESTRICT: 'restrict',
+};
+/** Reads `REFERENCES t (cols) MATCH x ON DELETE a ON UPDATE b DEFERRABLE ...` after the keyword. */
+function parseReferences(cursor, columns, name, line) {
+    const target = parseQualifiedName(cursor);
+    if (target === undefined) {
+        return undefined;
+    }
+    const refColumns = readColumnList(cursor);
+    const reference = {
+        ...(name === undefined ? {} : { name }),
+        columns,
+        ...(target.schema === undefined ? {} : { refSchema: target.schema }),
+        refTable: target.name,
+        refColumns,
+        line,
+    };
+    for (;;) {
+        if (cursor.isKeyword('MATCH')) {
+            cursor.next();
+            cursor.next();
+        }
+        else if (cursor.isKeyword('ON') &&
+            (cursor.isKeyword('DELETE', 1) || cursor.isKeyword('UPDATE', 1)) &&
+            (cursor.isKeyword('CASCADE', 2) ||
+                cursor.isKeyword('RESTRICT', 2) ||
+                cursor.isKeyword('SET', 2) ||
+                cursor.isKeyword('NO', 2))) {
+            cursor.next();
+            const which = cursor.next().up;
+            let action;
+            if (cursor.acceptKeywords('SET', 'NULL')) {
+                action = 'setNull';
+            }
+            else if (cursor.acceptKeywords('SET', 'DEFAULT')) {
+                action = 'setDefault';
+            }
+            else if (cursor.acceptKeywords('NO', 'ACTION')) {
+                action = 'noAction';
+            }
+            else {
+                action = ACTIONS[cursor.next().up] ?? 'noAction';
+            }
+            if (which === 'DELETE') {
+                reference.onDelete = action;
+            }
+            else {
+                reference.onUpdate = action;
+            }
+        }
+        else if (cursor.isKeyword('NOT') &&
+            (cursor.isKeyword('DEFERRABLE', 1) || cursor.isKeyword('ENFORCED', 1))) {
+            cursor.next();
+            cursor.next();
+        }
+        else if (cursor.isKeyword('DEFERRABLE') ||
+            cursor.isKeyword('ENFORCED') ||
+            (cursor.isKeyword('INITIALLY') &&
+                (cursor.isKeyword('DEFERRED', 1) || cursor.isKeyword('IMMEDIATE', 1)))) {
+            cursor.next();
+            if (cursor.isKeyword('DEFERRED') || cursor.isKeyword('IMMEDIATE')) {
+                cursor.next();
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return reference;
+}
+/** Reads a table constraint, or one of the MySQL `KEY` / `FULLTEXT` index forms. */
+function parseTableConstraint(ctx, file, cursor, label) {
+    const line = cursor.peek().line;
+    let name;
+    if (cursor.acceptKeyword('CONSTRAINT')) {
+        const candidate = cursor.peek();
+        if ((candidate.kind === 'word' &&
+            !['PRIMARY', 'UNIQUE', 'FOREIGN', 'CHECK', 'DEFAULT'].includes(candidate.up)) ||
+            candidate.kind === 'ident') {
+            name = cursor.next().value;
+        }
+    }
+    const head = cursor.peek();
+    if (head.kind !== 'word') {
+        return { kind: 'ignored' };
+    }
+    const skipUsing = () => {
+        if (cursor.isKeyword('USING') && !cursor.isPunct('(', 1)) {
+            cursor.next();
+            cursor.next();
+        }
+    };
+    switch (head.up) {
+        case 'PRIMARY': {
+            cursor.next();
+            cursor.next();
+            cursor.acceptKeyword('CLUSTERED');
+            cursor.acceptKeyword('NONCLUSTERED');
+            skipUsing();
+            const columns = readColumnList(cursor);
+            return {
+                kind: 'primaryKey',
+                columns,
+                ...(name === undefined ? {} : { name }),
+            };
+        }
+        case 'UNIQUE': {
+            cursor.next();
+            cursor.acceptKeyword('KEY');
+            cursor.acceptKeyword('INDEX');
+            cursor.acceptKeyword('CLUSTERED');
+            cursor.acceptKeyword('NONCLUSTERED');
+            const maybeName = cursor.peek();
+            if ((maybeName.kind === 'word' || maybeName.kind === 'ident') &&
+                !cursor.isPunct('(')) {
+                if (name === undefined) {
+                    name = maybeName.value;
+                }
+                cursor.next();
+            }
+            skipUsing();
+            const columns = readColumnList(cursor);
+            return {
+                kind: 'unique',
+                columns,
+                ...(name === undefined ? {} : { name }),
+            };
+        }
+        case 'FOREIGN': {
+            cursor.next();
+            cursor.next();
+            const maybeName = cursor.peek();
+            if ((maybeName.kind === 'word' || maybeName.kind === 'ident') &&
+                !cursor.isPunct('(')) {
+                if (name === undefined) {
+                    name = maybeName.value;
+                }
+                cursor.next();
+            }
+            const columns = readColumnList(cursor);
+            if (!cursor.acceptKeyword('REFERENCES')) {
+                warn(ctx, `table "${label}": ${file.name}:${line}: a FOREIGN KEY without REFERENCES was skipped.`);
+                return { kind: 'ignored' };
+            }
+            const reference = parseReferences(cursor, columns, name, line);
+            return reference === undefined
+                ? { kind: 'ignored' }
+                : { kind: 'reference', reference };
+        }
+        case 'CHECK': {
+            cursor.next();
+            const group = cursor.readGroup() ?? [];
+            return {
+                kind: 'check',
+                check: {
+                    ...(name === undefined ? {} : { name }),
+                    tokens: group,
+                    text: sourceOf(file.text, group),
+                },
+            };
+        }
+        case 'DEFAULT': {
+            // SQL Server: ALTER TABLE t ADD CONSTRAINT DF_x DEFAULT (0) FOR col
+            cursor.next();
+            const expression = [];
+            while (!cursor.atEnd && !cursor.isKeyword('FOR')) {
+                expression.push(cursor.next());
+            }
+            cursor.acceptKeyword('FOR');
+            const column = cursor.peek();
+            if (column.kind === 'word' || column.kind === 'ident') {
+                return {
+                    kind: 'default',
+                    column: column.value,
+                    tokens: expression,
+                    text: defaultExpression(expression, file.text),
+                };
+            }
+            return { kind: 'ignored' };
+        }
+        case 'KEY':
+        case 'INDEX':
+        case 'FULLTEXT':
+        case 'SPATIAL': {
+            cursor.next();
+            let kind;
+            if (head.up === 'FULLTEXT') {
+                kind = 'fulltext';
+            }
+            else if (head.up === 'SPATIAL') {
+                kind = 'spatial';
+            }
+            cursor.acceptKeyword('KEY');
+            cursor.acceptKeyword('INDEX');
+            const maybeName = cursor.peek();
+            let indexName = name;
+            if ((maybeName.kind === 'word' || maybeName.kind === 'ident') &&
+                !cursor.isPunct('(') &&
+                !(maybeName.kind === 'word' && maybeName.up === 'USING')) {
+                indexName = maybeName.value;
+                cursor.next();
+            }
+            skipUsing();
+            const group = cursor.readGroup() ?? [];
+            return {
+                kind: 'index',
+                index: {
+                    ...(indexName === undefined ? {} : { name: indexName }),
+                    elements: readIndexElements(group),
+                    isUnique: false,
+                    ...(kind === undefined ? {} : { kind }),
+                    isPartial: false,
+                    line,
+                },
+            };
+        }
+        case 'EXCLUDE':
+            warn(ctx, `table "${label}": an EXCLUDE constraint has no equivalent in the shared model and was skipped.`);
+            return { kind: 'ignored' };
+        default:
+            return { kind: 'ignored' };
+    }
+}
+function applyConstraint(ctx, table, result) {
+    switch (result.kind) {
+        case 'primaryKey':
+            if (result.columns.length === 0) {
+                return;
+            }
+            table.primaryKey = {
+                columns: result.columns,
+                ...(result.name === undefined ? {} : { name: result.name }),
+            };
+            return;
+        case 'unique':
+            if (result.columns.length > 0) {
+                table.uniques.push({
+                    columns: result.columns,
+                    ...(result.name === undefined ? {} : { name: result.name }),
+                });
+            }
+            return;
+        case 'reference':
+            table.references.push(result.reference);
+            return;
+        case 'check':
+            table.checks.push(result.check);
+            return;
+        case 'index':
+            table.indexes.push(result.index);
+            return;
+        case 'default': {
+            const column = findColumn(table, result.column);
+            if (column === undefined) {
+                warn(ctx, `table "${table.name}": a DEFAULT for the unknown column "${result.column}" was ignored.`);
+                return;
+            }
+            column.defaultTokens = result.tokens;
+            column.defaultText = result.text;
+            return;
+        }
+        default:
+            return;
+    }
+}
+/** Words that end a DEFAULT expression when they appear outside parentheses. */
+const DEFAULT_STOP_WORDS = new Set([
+    'NOT',
+    'NULL',
+    'PRIMARY',
+    'UNIQUE',
+    'REFERENCES',
+    'CHECK',
+    'CONSTRAINT',
+    'COLLATE',
+    'GENERATED',
+    'COMMENT',
+    'ON',
+    'AUTO_INCREMENT',
+    'AUTOINCREMENT',
+    'IDENTITY',
+]);
+function readDefault(cursor) {
+    const tokens = [];
+    let depth = 0;
+    while (!cursor.atEnd) {
+        const token = cursor.peek();
+        if (depth === 0 &&
+            tokens.length > 0 &&
+            token.kind === 'word' &&
+            DEFAULT_STOP_WORDS.has(token.up)) {
+            break;
+        }
+        if (token.kind === 'punct') {
+            if (token.text === '(') {
+                depth += 1;
+            }
+            else if (token.text === ')') {
+                depth = Math.max(0, depth - 1);
+            }
+        }
+        tokens.push(cursor.next());
+    }
+    return tokens;
+}
+/**
+ * Reads a column definition and adds it, with the constraints written inline, to the table. Returns
+ * undefined when the element does not start with a name.
+ */
+function parseColumn(ctx, file, cursor, table, label) {
+    const nameToken = cursor.peek();
+    if (nameToken.kind !== 'word' && nameToken.kind !== 'ident') {
+        return undefined;
+    }
+    cursor.next();
+    const dialect = file.dialect;
+    const afterName = cursor.peek();
+    const hasNoType = cursor.atEnd ||
+        (afterName.kind === 'word' && CONSTRAINT_START_WORDS.has(afterName.up));
+    const type = hasNoType
+        ? {
+            name: '',
+            args: [],
+            arrayDepth: 0,
+            unsigned: false,
+            text: '',
+            userName: '',
+        }
+        : parseType(cursor, file.text, dialect);
+    const column = {
+        name: nameToken.value,
+        type,
+        notNull: undefined,
+        autoIncrement: false,
+        onUpdateNow: false,
+        line: nameToken.line,
+    };
+    let pendingName;
+    let isPrimaryKey = false;
+    while (!cursor.atEnd) {
+        const token = cursor.peek();
+        if (token.kind !== 'word') {
+            // Stray punctuation, strings or a parenthesised option: skip it.
+            if (token.kind === 'punct' && token.text === '(') {
+                cursor.readGroup();
+            }
+            else {
+                cursor.next();
+            }
+            continue;
+        }
+        switch (token.up) {
+            case 'CONSTRAINT': {
+                cursor.next();
+                const candidate = cursor.peek();
+                if (candidate.kind === 'word' || candidate.kind === 'ident') {
+                    if (!(candidate.kind === 'word' &&
+                        [
+                            'NOT',
+                            'NULL',
+                            'PRIMARY',
+                            'UNIQUE',
+                            'REFERENCES',
+                            'CHECK',
+                            'DEFAULT',
+                        ].includes(candidate.up))) {
+                        pendingName = candidate.value;
+                        cursor.next();
+                    }
+                }
+                continue;
+            }
+            case 'NOT':
+                cursor.next();
+                if (cursor.acceptKeyword('NULL')) {
+                    column.notNull = true;
+                }
+                continue;
+            case 'NULL':
+                cursor.next();
+                column.notNull = false;
+                continue;
+            case 'DEFAULT': {
+                cursor.next();
+                const tokens = readDefault(cursor);
+                column.defaultTokens = tokens;
+                column.defaultText = defaultExpression(tokens, file.text);
+                continue;
+            }
+            case 'PRIMARY':
+                cursor.next();
+                cursor.acceptKeyword('KEY');
+                cursor.acceptKeyword('ASC');
+                cursor.acceptKeyword('DESC');
+                cursor.acceptKeyword('CLUSTERED');
+                cursor.acceptKeyword('NONCLUSTERED');
+                if (cursor.isKeyword('ON') && cursor.isKeyword('CONFLICT', 1)) {
+                    cursor.next();
+                    cursor.next();
+                    cursor.next();
+                }
+                isPrimaryKey = true;
+                if (pendingName !== undefined && table.primaryKey === undefined) {
+                    table.primaryKey = { columns: [], name: pendingName };
+                }
+                pendingName = undefined;
+                continue;
+            case 'KEY':
+                cursor.next();
+                isPrimaryKey = true;
+                continue;
+            case 'UNIQUE': {
+                cursor.next();
+                cursor.acceptKeyword('KEY');
+                cursor.acceptKeyword('INDEX');
+                cursor.acceptKeyword('CLUSTERED');
+                cursor.acceptKeyword('NONCLUSTERED');
+                if (cursor.isKeyword('ON') && cursor.isKeyword('CONFLICT', 1)) {
+                    cursor.next();
+                    cursor.next();
+                    cursor.next();
+                }
+                table.uniques.push({
+                    columns: [column.name],
+                    ...(pendingName === undefined ? {} : { name: pendingName }),
+                });
+                pendingName = undefined;
+                continue;
+            }
+            case 'REFERENCES': {
+                cursor.next();
+                const reference = parseReferences(cursor, [column.name], pendingName, nameToken.line);
+                if (reference !== undefined) {
+                    table.references.push(reference);
+                }
+                pendingName = undefined;
+                continue;
+            }
+            case 'CHECK': {
+                cursor.next();
+                const group = cursor.readGroup();
+                if (group !== undefined) {
+                    table.checks.push({
+                        ...(pendingName === undefined ? {} : { name: pendingName }),
+                        tokens: group,
+                        text: sourceOf(file.text, group),
+                    });
+                }
+                pendingName = undefined;
+                continue;
+            }
+            case 'AUTO_INCREMENT':
+            case 'AUTOINCREMENT':
+                cursor.next();
+                column.autoIncrement = true;
+                continue;
+            case 'IDENTITY':
+                cursor.next();
+                column.autoIncrement = true;
+                cursor.readGroup();
+                continue;
+            case 'GENERATED': {
+                cursor.next();
+                if (!cursor.acceptKeyword('ALWAYS')) {
+                    cursor.acceptKeywords('BY', 'DEFAULT');
+                }
+                if (cursor.acceptKeyword('AS')) {
+                    if (cursor.acceptKeyword('IDENTITY')) {
+                        column.autoIncrement = true;
+                        cursor.readGroup();
+                    }
+                    else {
+                        readGeneratedExpression(cursor, file, column);
+                    }
+                }
+                continue;
+            }
+            case 'AS':
+                cursor.next();
+                readGeneratedExpression(cursor, file, column);
+                continue;
+            case 'COLLATE':
+                cursor.next();
+                cursor.next();
+                continue;
+            case 'CHARACTER':
+                cursor.next();
+                cursor.acceptKeyword('SET');
+                cursor.next();
+                continue;
+            case 'CHARSET':
+                cursor.next();
+                cursor.next();
+                continue;
+            case 'COMMENT':
+                cursor.next();
+                cursor.next();
+                continue;
+            case 'ON':
+                cursor.next();
+                if (cursor.acceptKeyword('UPDATE')) {
+                    const target = cursor.next();
+                    if (target.kind === 'word' &&
+                        [
+                            'CURRENT_TIMESTAMP',
+                            'NOW',
+                            'LOCALTIMESTAMP',
+                            'LOCALTIME',
+                        ].includes(target.up)) {
+                        column.onUpdateNow = true;
+                    }
+                    cursor.readGroup();
+                }
+                else {
+                    cursor.next();
+                }
+                continue;
+            case 'STORAGE':
+            case 'COMPRESSION':
+                cursor.next();
+                cursor.next();
+                continue;
+            default:
+                cursor.next();
+        }
+    }
+    if (isPrimaryKey) {
+        if (table.primaryKey === undefined) {
+            table.primaryKey = { columns: [column.name] };
+        }
+        else if (table.primaryKey.columns.length === 0) {
+            table.primaryKey.columns = [column.name];
+        }
+        else {
+            warn(ctx, `table "${label}": more than one PRIMARY KEY is declared; "${column.name}" is ignored as a key.`);
+        }
+    }
+    table.columns.push(column);
+    if (!table.columnIndex.has(column.name.toLowerCase())) {
+        table.columnIndex.set(column.name.toLowerCase(), column);
+    }
+    return column;
+}
+function readGeneratedExpression(cursor, file, column) {
+    const group = cursor.readGroup();
+    if (group === undefined) {
+        return;
+    }
+    let isStored = false;
+    if (cursor.acceptKeyword('STORED') || cursor.acceptKeyword('PERSISTED')) {
+        isStored = true;
+    }
+    else {
+        cursor.acceptKeyword('VIRTUAL');
+    }
+    column.generated = { expression: sourceOf(file.text, group), isStored };
+}
+function createIndex(ctx, file, cursor, line) {
+    let isUnique = false;
+    let kind;
+    let clustered;
+    for (;;) {
+        if (cursor.acceptKeyword('UNIQUE')) {
+            isUnique = true;
+        }
+        else if (cursor.acceptKeyword('FULLTEXT')) {
+            kind = 'fulltext';
+        }
+        else if (cursor.acceptKeyword('SPATIAL')) {
+            kind = 'spatial';
+        }
+        else if (cursor.acceptKeyword('CLUSTERED')) {
+            clustered = true;
+        }
+        else if (cursor.acceptKeyword('NONCLUSTERED')) {
+            clustered = false;
+        }
+        else if (cursor.acceptKeyword('COLUMNSTORE') ||
+            cursor.acceptKeyword('BITMAP')) {
+            continue;
+        }
+        else {
+            break;
+        }
+    }
+    if (!cursor.acceptKeyword('INDEX')) {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    cursor.acceptKeyword('CONCURRENTLY');
+    cursor.acceptKeywords('IF', 'NOT', 'EXISTS');
+    let name;
+    if (!cursor.isKeyword('ON')) {
+        const parsed = parseQualifiedName(cursor);
+        name = parsed?.name;
+    }
+    let method;
+    // MySQL: CREATE INDEX name USING BTREE ON table (...)
+    if (cursor.isKeyword('USING') && cursor.isKeyword('ON', 2)) {
+        cursor.next();
+        method = cursor.next().value.toLowerCase();
+    }
+    if (!cursor.acceptKeyword('ON')) {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    cursor.acceptKeyword('ONLY');
+    const target = parseQualifiedName(cursor);
+    if (target === undefined) {
+        return;
+    }
+    if (cursor.isKeyword('USING') && !cursor.isPunct('(', 1)) {
+        cursor.next();
+        method = cursor.next().value.toLowerCase();
+    }
+    const group = cursor.readGroup();
+    if (group === undefined) {
+        recordSkipped(ctx, file, 'unrecognised', line);
+        return;
+    }
+    // MySQL: USING after the column list.
+    if (cursor.isKeyword('USING') && !cursor.isPunct('(', 1)) {
+        cursor.next();
+        method = cursor.next().value.toLowerCase();
+    }
+    let isPartial = false;
+    while (!cursor.atEnd) {
+        if (cursor.isKeyword('WHERE')) {
+            isPartial = true;
+            break;
+        }
+        if (cursor.isKeyword('INCLUDE') || cursor.isKeyword('WITH')) {
+            cursor.next();
+            cursor.readGroup();
+        }
+        else {
+            cursor.next();
+        }
+    }
+    const table = lookupTable(ctx, target, file.dialect);
+    if (table === undefined) {
+        warn(ctx, `${file.name}:${line}: the index${name === undefined ? '' : ` "${name}"`} is on the unknown table "${target.name}" and was skipped.`);
+        return;
+    }
+    table.indexes.push({
+        ...(name === undefined ? {} : { name }),
+        elements: readIndexElements(group),
+        isUnique,
+        ...(kind === undefined ? {} : { kind }),
+        ...(method === undefined || method === 'btree' ? {} : { method }),
+        ...(clustered === undefined ? {} : { clustered }),
+        isPartial,
+        line,
+    });
+}
+function lookupTable(ctx, name, dialect) {
+    const schema = normalizedSchema(name, dialect);
+    const exact = ctx.tableByKey.get(tableKey(schema, name.name));
+    if (exact !== undefined && !exact.dropped) {
+        return exact;
+    }
+    // An unqualified name finds a table in any schema when there is only one candidate.
+    if (schema === undefined) {
+        let only;
+        for (const candidate of ctx.tablesByName.get(name.name.toLowerCase()) ??
+            []) {
+            if (candidate.dropped) {
+                continue;
+            }
+            if (only !== undefined) {
+                // Ambiguous: the name exists in several schemas.
+                return undefined;
+            }
+            only = candidate;
+        }
+        return only;
+    }
+    else {
+        const fallback = ctx.tableByKey.get(tableKey(undefined, name.name));
+        if (fallback !== undefined &&
+            !fallback.dropped &&
+            DEFAULT_SCHEMAS.has(schema.toLowerCase())) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function createType(ctx, file, cursor, line) {
+    cursor.next();
+    const name = parseQualifiedName(cursor);
+    if (name === undefined || !cursor.acceptKeyword('AS')) {
+        recordSkipped(ctx, file, 'CREATE TYPE', line);
+        return;
+    }
+    if (!cursor.acceptKeyword('ENUM')) {
+        recordSkipped(ctx, file, 'CREATE TYPE (not an enum)', line);
+        return;
+    }
+    const group = cursor.readGroup() ?? [];
+    const values = group
+        .filter((token) => token.kind === 'string')
+        .map((token) => token.value);
+    const created = {
+        ...(name.schema === undefined ? {} : { schema: name.schema }),
+        name: name.name,
+        values,
+        seen: new Set(values),
+        dropped: false,
+    };
+    ctx.enums.push(created);
+    ctx.enumsByName.set(name.name.toLowerCase(), created);
+}
+function findEnum(ctx, name) {
+    const found = ctx.enumsByName.get((typeof name === 'string' ? name : name.name).toLowerCase());
+    return found === undefined || found.dropped ? undefined : found;
+}
+function handleAlter(ctx, file, cursor) {
+    const line = cursor.peek().line;
+    cursor.next();
+    if (cursor.isKeyword('TYPE')) {
+        cursor.next();
+        const name = parseQualifiedName(cursor);
+        const target = name === undefined ? undefined : findEnum(ctx, name);
+        if (target !== undefined && cursor.acceptKeywords('ADD', 'VALUE')) {
+            cursor.acceptKeywords('IF', 'NOT', 'EXISTS');
+            const value = cursor.next();
+            if (value.kind === 'string' && !target.seen.has(value.value)) {
+                let position = target.values.length;
+                if (cursor.isKeyword('BEFORE') || cursor.isKeyword('AFTER')) {
+                    const after = cursor.next().up === 'AFTER';
+                    const anchor = cursor.next();
+                    // Looking the anchor up is linear; a huge enum is appended to instead.
+                    const anchorAt = target.values.length > MAX_POSITIONED_ENUM_VALUES
+                        ? -1
+                        : target.values.indexOf(anchor.value);
+                    if (anchorAt !== -1) {
+                        position = after ? anchorAt + 1 : anchorAt;
+                    }
+                }
+                target.values.splice(position, 0, value.value);
+                target.seen.add(value.value);
+            }
+        }
+        return;
+    }
+    if (!cursor.acceptKeyword('TABLE')) {
+        // ALTER SEQUENCE, ALTER VIEW, ALTER DATABASE and similar change nothing the model holds.
+        return;
+    }
+    cursor.acceptKeywords('IF', 'EXISTS');
+    cursor.acceptKeyword('ONLY');
+    const name = parseQualifiedName(cursor);
+    if (name === undefined) {
+        return;
+    }
+    if (cursor.isKeyword('WITH') &&
+        (cursor.isKeyword('CHECK', 1) || cursor.isKeyword('NOCHECK', 1))) {
+        cursor.next();
+        cursor.next();
+    }
+    const rest = [];
+    while (!cursor.atEnd) {
+        rest.push(cursor.next());
+    }
+    const table = lookupTable(ctx, name, file.dialect);
+    if (table === undefined) {
+        warn(ctx, `${file.name}:${line}: ALTER TABLE on the unknown table "${name.name}" was skipped.`);
+        return;
+    }
+    for (const action of splitTopLevel(rest)) {
+        handleAlterAction(ctx, file, table, new Cursor(action), line);
+    }
+}
+const QUIET_ALTER_ACTIONS = new Set([
+    'OWNER',
+    'ENABLE',
+    'DISABLE',
+    'FORCE',
+    'NO',
+    'CLUSTER',
+    'SET',
+    'RESET',
+    'REPLICA',
+    'CHECK',
+    'NOCHECK',
+    'ATTACH',
+    'DETACH',
+    'AUTO_INCREMENT',
+    'ENGINE',
+    'ROW_FORMAT',
+    'COMMENT',
+    'CHARACTER',
+    'COLLATE',
+    'CONVERT',
+    'ALGORITHM',
+    'LOCK',
+    'TRIGGER',
+    'VALIDATE',
+    'INHERIT',
+    'OF',
+    'NOT',
+    'UNION',
+    'WITH',
+]);
+function handleAlterAction(ctx, file, table, cursor, line) {
+    const head = cursor.peek();
+    if (head.kind !== 'word') {
+        return;
+    }
+    if (head.up === 'ADD') {
+        cursor.next();
+        cursor.acceptKeyword('COLUMN');
+        cursor.acceptKeywords('IF', 'NOT', 'EXISTS');
+        if (isConstraintStart(cursor, file.dialect)) {
+            applyConstraint(ctx, table, parseTableConstraint(ctx, file, cursor, table.name));
+            return;
+        }
+        if (cursor.isKeyword('GENERATED') || cursor.isPunct('(') || cursor.atEnd) {
+            return;
+        }
+        const column = parseColumn(ctx, file, cursor, table, table.name);
+        if (column === undefined) {
+            warn(ctx, `${file.name}:${line}: ALTER TABLE "${table.name}" ADD could not be read and was skipped.`);
+        }
+        return;
+    }
+    if (head.up === 'ALTER') {
+        cursor.next();
+        cursor.acceptKeyword('COLUMN');
+        const columnToken = cursor.next();
+        const column = findColumn(table, columnToken.value);
+        if (column === undefined) {
+            return;
+        }
+        if (cursor.acceptKeywords('SET', 'NOT', 'NULL')) {
+            column.notNull = true;
+        }
+        else if (cursor.acceptKeywords('DROP', 'NOT', 'NULL')) {
+            column.notNull = false;
+        }
+        else if (cursor.acceptKeywords('SET', 'DEFAULT')) {
+            const tokens = readDefault(cursor);
+            column.defaultTokens = tokens;
+            column.defaultText = defaultExpression(tokens, file.text);
+        }
+        else if (cursor.acceptKeywords('DROP', 'DEFAULT')) {
+            delete column.defaultTokens;
+            delete column.defaultText;
+        }
+        else if (cursor.acceptKeyword('ADD') && cursor.isKeyword('GENERATED')) {
+            column.autoIncrement = true;
+        }
+        else {
+            recordSkipped(ctx, file, 'ALTER TABLE ... ALTER COLUMN (type or option change)', line);
+        }
+        return;
+    }
+    if (QUIET_ALTER_ACTIONS.has(head.up)) {
+        return;
+    }
+    recordSkipped(ctx, file, `ALTER TABLE ... ${head.up}`, line);
+}
+function handleDrop(ctx, file, cursor) {
+    cursor.next();
+    const kind = cursor.next();
+    if (kind.up === 'TABLE') {
+        cursor.acceptKeywords('IF', 'EXISTS');
+        for (;;) {
+            const name = parseQualifiedName(cursor);
+            if (name === undefined) {
+                break;
+            }
+            const table = lookupTable(ctx, name, file.dialect);
+            if (table !== undefined) {
+                table.dropped = true;
+                ctx.tableByKey.delete(tableKey(table.schema, table.name));
+            }
+            if (!cursor.acceptPunct(',')) {
+                break;
+            }
+        }
+    }
+    else if (kind.up === 'TYPE') {
+        cursor.acceptKeywords('IF', 'EXISTS');
+        const name = parseQualifiedName(cursor);
+        const target = name === undefined ? undefined : findEnum(ctx, name);
+        if (target !== undefined) {
+            target.dropped = true;
+        }
+    }
+}
+function sanitizeIdentifier(value) {
+    let result = value.replace(/[^A-Za-z0-9_]+/g, '_');
+    result = result.replace(/^_+(?=.)/, (match) => value.startsWith('_') ? match : '');
+    if (result === '' || result === '_') {
+        result = 'column';
+    }
+    if (/^\d/.test(result)) {
+        result = `c_${result}`;
+    }
+    return result;
+}
+/** The next suffix to try per base name, per set of used names, so many clashes stay linear. */
+const NEXT_SUFFIX = new WeakMap();
+function nextFree(base, used, separator) {
+    let counters = NEXT_SUFFIX.get(used);
+    if (counters === undefined) {
+        counters = new Map();
+        NEXT_SUFFIX.set(used, counters);
+    }
+    let suffix = counters.get(base) ?? 2;
+    for (;;) {
+        const candidate = `${base}${separator}${suffix}`;
+        suffix += 1;
+        if (!used.has(candidate)) {
+            counters.set(base, suffix);
+            used.add(candidate);
+            return candidate;
+        }
+    }
+}
+function uniqueName(base, used) {
+    if (!used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    return nextFree(base, used, '_');
+}
+function pluralize(snake) {
+    const parts = snake.split('_');
+    const word = parts.pop() ?? '';
+    const lower = word.toLowerCase();
+    let plural;
+    if (['data', 'news', 'series', 'species', 'media', 'metadata'].includes(lower)) {
+        plural = `${word}_set`;
+    }
+    else if (/[^aeiou]y$/.test(lower)) {
+        plural = `${word.slice(0, -1)}ies`;
+    }
+    else if (/(s|x|z|ch|sh)$/.test(lower)) {
+        plural = `${word}es`;
+    }
+    else {
+        plural = `${word}s`;
+    }
+    parts.push(plural);
+    return parts.join('_');
+}
+function modelNameFor(table, taken) {
+    let base = toPascalCase(singularize(toSnakeCase(table.name)));
+    if (base === '') {
+        base = 'Model';
+    }
+    if (/^\d/.test(base)) {
+        base = `T${base}`;
+    }
+    if (taken.has(base) && table.schema !== undefined) {
+        base = `${toPascalCase(table.schema)}${base}`;
+    }
+    if (!taken.has(base)) {
+        taken.add(base);
+        return base;
+    }
+    return nextFree(base, taken, '');
+}
+function enumMembers(values) {
+    const used = new Set();
+    return values.map((value, position) => {
+        let base = toSnakeCase(value).toUpperCase();
+        if (base === '') {
+            base = `VALUE_${position + 1}`;
+        }
+        if (/^\d/.test(base)) {
+            base = `V_${base}`;
+        }
+        return { name: uniqueName(base, used), dbValue: value };
+    });
+}
+function findColumn(table, name) {
+    return table.columnIndex.get(name.toLowerCase());
+}
+/** Reads `col IN ('a', 'b')`, `col = 'a' OR col = 'b'` and PostgreSQL's `col = ANY (ARRAY[...])` checks. */
+function extractEnumCheck(check, table) {
+    const kept = [];
+    const tokens = check.tokens;
+    for (let at = 0; at < tokens.length; at += 1) {
+        const token = tokens[at];
+        if (token === undefined) {
+            continue;
+        }
+        if (token.kind === 'punct' && token.text === '::') {
+            // Drop the cast: ::text, ::character varying(20), ::text[]
+            at += 1;
+            while (at < tokens.length) {
+                const castPart = tokens[at];
+                if (castPart?.kind === 'word' &&
+                    [
+                        'TEXT',
+                        'VARCHAR',
+                        'CHARACTER',
+                        'VARYING',
+                        'CHAR',
+                        'BPCHAR',
+                        'NAME',
+                    ].includes(castPart.up)) {
+                    at += 1;
+                }
+                else if (castPart?.kind === 'punct' && castPart.text === '[') {
+                    at += 1;
+                }
+                else if (castPart?.kind === 'punct' && castPart.text === ']') {
+                    at += 1;
+                }
+                else {
+                    break;
+                }
+            }
+            at -= 1;
+            continue;
+        }
+        kept.push(token);
+    }
+    let column;
+    const values = [];
+    const seenValues = new Set();
+    let sawMembership = false;
+    for (const token of kept) {
+        if (token.kind === 'string') {
+            if (!seenValues.has(token.value)) {
+                seenValues.add(token.value);
+                values.push(token.value);
+            }
+        }
+        else if (token.kind === 'word' || token.kind === 'ident') {
+            const upper = token.value.toUpperCase();
+            if (token.kind === 'word' && (upper === 'IN' || upper === 'ANY')) {
+                sawMembership = true;
+            }
+            else if (token.kind === 'word' &&
+                (upper === 'OR' || upper === 'ARRAY')) {
+                continue;
+            }
+            else {
+                const candidate = findColumn(table, token.value);
+                if (candidate === undefined) {
+                    return undefined;
+                }
+                if (column !== undefined && column !== candidate) {
+                    return undefined;
+                }
+                column = candidate;
+            }
+        }
+        else if (token.kind === 'number') {
+            return undefined;
+        }
+        else if (token.kind === 'punct' &&
+            !['(', ')', ',', '=', '[', ']'].includes(token.text)) {
+            return undefined;
+        }
+        else if (token.kind === 'punct' && token.text === '=') {
+            sawMembership = true;
+        }
+    }
+    if (column === undefined || !sawMembership || values.length === 0) {
+        return undefined;
+    }
+    return { column, values };
+}
+function referenceCoversExactly(columns, candidate) {
+    if (columns.length !== candidate.length) {
+        return false;
+    }
+    const wanted = new Set(candidate.map((name) => name.toLowerCase()));
+    return columns.every((name) => wanted.has(name.toLowerCase()));
+}
+function targetKeyColumns(target) {
+    const names = target.primaryKey?.columns ?? [];
+    const found = [];
+    for (const name of names) {
+        const column = findColumn(target, name);
+        if (column !== undefined) {
+            found.push(column);
+        }
+    }
+    return found;
+}
+function buildSchema(ctx, tables, options) {
+    const warnings = {
+        push: (message) => warn(ctx, message),
+    };
+    const modelNames = new Set();
+    const builds = new Map();
+    for (const table of tables) {
+        builds.set(table, {
+            table,
+            name: modelNameFor(table, modelNames),
+            used: new Set(),
+            fieldNames: new Map(),
+            consumed: new Set(),
+            references: [],
+            single: new Map(),
+            composite: [],
+            relationNames: new Map(),
+            enumByColumn: new Map(),
+            fields: [],
+            relations: [],
+            compositeForeignKeys: [],
+            indexes: [],
+            isCollapsed: false,
+        });
+    }
+    // Enums: CREATE TYPE ... AS ENUM first, then inline and CHECK-derived ones.
+    const enums = [];
+    const enumByType = new Map();
+    const enumNames = new Set(modelNames);
+    for (const raw of ctx.enums) {
+        if (raw.dropped) {
+            continue;
+        }
+        const name = uniqueName(toPascalCase(raw.name) || 'Enum', enumNames);
+        const created = {
+            name,
+            values: enumMembers(raw.values),
+            ...(name === raw.name ? {} : { dbName: raw.name }),
+            ...(raw.schema === undefined || DEFAULT_SCHEMAS.has(raw.schema)
+                ? {}
+                : { schema: raw.schema }),
+        };
+        enums.push(created);
+        enumByType.set(raw.name.toLowerCase(), created);
+    }
+    for (const table of tables) {
+        const build = builds.get(table);
+        for (const column of table.columns) {
+            if (column.type.enumValues !== undefined) {
+                const created = {
+                    name: uniqueName(toPascalCase(`${singularize(toSnakeCase(table.name))}_${column.name}`) || 'Enum', enumNames),
+                    values: enumMembers(column.type.enumValues),
+                };
+                enums.push(created);
+                build.enumByColumn.set(column.name.toLowerCase(), created);
+            }
+        }
+        let droppedChecks = 0;
+        for (const check of table.checks) {
+            const found = extractEnumCheck(check, table);
+            if (found !== undefined) {
+                const mapped = mapType(found.column.type, table.dialect);
+                const key = found.column.name.toLowerCase();
+                if ((mapped.type === 'string' || mapped.type === 'text') &&
+                    !build.enumByColumn.has(key) &&
+                    found.column.type.enumValues === undefined &&
+                    found.column.type.arrayDepth === 0) {
+                    const created = {
+                        name: uniqueName(toPascalCase(`${singularize(toSnakeCase(table.name))}_${found.column.name}`) || 'Enum', enumNames),
+                        values: enumMembers(found.values),
+                    };
+                    enums.push(created);
+                    build.enumByColumn.set(key, created);
+                    continue;
+                }
+            }
+            droppedChecks += 1;
+        }
+        if (droppedChecks > 0) {
+            warnings.push(`table "${table.name}": ${droppedChecks} CHECK constraint${droppedChecks === 1 ? ' has' : 's have'} no equivalent in the shared model and ${droppedChecks === 1 ? 'was' : 'were'} dropped.`);
+        }
+    }
+    // Foreign keys: which target does each one point at, and is it usable?
+    const referencedTables = new Set();
+    for (const table of tables) {
+        const build = builds.get(table);
+        for (const raw of table.references) {
+            const target = lookupTable(ctx, {
+                ...(raw.refSchema === undefined ? {} : { schema: raw.refSchema }),
+                name: raw.refTable,
+            }, table.dialect);
+            if (target === undefined || builds.get(target) === undefined) {
+                warnings.push(`table "${table.name}": the foreign key on (${raw.columns.join(', ')}) points at the unknown table "${raw.refSchema === undefined ? '' : `${raw.refSchema}.`}${raw.refTable}"; the column stays an ordinary field.`);
+                continue;
+            }
+            const columns = [];
+            for (const name of raw.columns) {
+                const found = findColumn(table, name);
+                if (found !== undefined) {
+                    columns.push(found);
+                }
+            }
+            let targetColumns = [];
+            if (raw.refColumns.length === 0) {
+                targetColumns = targetKeyColumns(target);
+            }
+            else {
+                for (const name of raw.refColumns) {
+                    const found = findColumn(target, name);
+                    if (found !== undefined) {
+                        targetColumns.push(found);
+                    }
+                }
+            }
+            if (columns.length === 0 ||
+                columns.length !== raw.columns.length ||
+                targetColumns.length === 0 ||
+                targetColumns.length !== columns.length ||
+                (raw.refColumns.length > 0 &&
+                    raw.refColumns.length !== targetColumns.length)) {
+                warnings.push(`table "${table.name}": the foreign key on (${raw.columns.join(', ')}) does not match the columns of "${target.name}"; it was skipped.`);
+                continue;
+            }
+            build.references.push({ raw, target, columns, targetColumns });
+            referencedTables.add(target);
+        }
+    }
+    // Join tables: exactly two foreign-key columns that together are the primary key.
+    const collapsed = new Map();
+    for (const table of tables) {
+        const build = builds.get(table);
+        const key = table.primaryKey?.columns ?? [];
+        if (table.columns.length !== 2 ||
+            key.length !== 2 ||
+            build.references.length !== 2 ||
+            table.uniques.length > 0 ||
+            table.indexes.length > 0 ||
+            table.checks.length > 0 ||
+            referencedTables.has(table)) {
+            continue;
+        }
+        const [first, second] = build.references;
+        if (first === undefined || second === undefined) {
+            continue;
+        }
+        const columnNames = table.columns.map((column) => column.name);
+        if (first.columns.length !== 1 ||
+            second.columns.length !== 1 ||
+            !referenceCoversExactly(key, columnNames) ||
+            !referenceCoversExactly([first.columns[0]?.name ?? '', second.columns[0]?.name ?? ''], columnNames)) {
+            continue;
+        }
+        const isKeyTarget = (reference) => {
+            const expected = targetKeyColumns(reference.target);
+            return (expected.length === 1 &&
+                expected[0]?.name.toLowerCase() ===
+                    reference.targetColumns[0]?.name.toLowerCase());
+        };
+        if (!isKeyTarget(first) ||
+            !isKeyTarget(second) ||
+            first.target === table ||
+            second.target === table) {
+            continue;
+        }
+        // Keep the order of the primary key, so the first key column owns the relation by default.
+        const ordered = [first, second].sort((left, right) => key.findIndex((name) => name.toLowerCase() === left.columns[0]?.name.toLowerCase()) -
+            key.findIndex((name) => name.toLowerCase() === right.columns[0]?.name.toLowerCase()));
+        const left = ordered[0];
+        const right = ordered[1];
+        if (left === undefined || right === undefined) {
+            continue;
+        }
+        collapsed.set(table, { first: left, second: right });
+        build.isCollapsed = true;
+    }
+    // A join table whose target is itself a join table stays a model.
+    for (const [table, pair] of [...collapsed]) {
+        if (collapsed.has(pair.first.target) || collapsed.has(pair.second.target)) {
+            collapsed.delete(table);
+            builds.get(table).isCollapsed = false;
+        }
+    }
+    const keptTables = tables.filter((table) => !collapsed.has(table));
+    // Drop references to collapsed tables (cannot happen: referenced tables are never collapsed).
+    // Column names, then relation names.
+    for (const table of keptTables) {
+        const build = builds.get(table);
+        const usedColumns = new Set();
+        // Single-column foreign keys replace their column; composite ones leave the columns as fields.
+        const consumedBy = new Map();
+        for (const reference of build.references) {
+            if (reference.columns.length !== 1) {
+                continue;
+            }
+            const column = reference.columns[0];
+            const key = column.name.toLowerCase();
+            if (consumedBy.has(key)) {
+                warnings.push(`table "${table.name}": the column "${column.name}" has more than one foreign key; only the first is read as a relation.`);
+                continue;
+            }
+            consumedBy.set(key, reference);
+            build.single.set(key, reference);
+            build.consumed.add(key);
+        }
+        for (const column of table.columns) {
+            const key = column.name.toLowerCase();
+            if (build.consumed.has(key)) {
+                continue;
+            }
+            const fieldName = uniqueName(sanitizeIdentifier(column.name), usedColumns);
+            build.fieldNames.set(key, fieldName);
+            build.used.add(fieldName);
+        }
+        for (const reference of build.references) {
+            if (reference.columns.length === 1) {
+                if (build.single.get(reference.columns[0]?.name.toLowerCase() ?? '') !==
+                    reference) {
+                    continue;
+                }
+                const column = reference.columns[0];
+                let stripped = stripKeySuffix(column.name);
+                if (stripped === column.name) {
+                    // order_no -> orders: no key suffix, but the column starts with the name of its target.
+                    const targetName = toSnakeCase(builds.get(reference.target).name);
+                    if (column.name.toLowerCase().startsWith(`${targetName}_`)) {
+                        stripped = targetName;
+                    }
+                }
+                const base = sanitizeIdentifier(stripped === ''
+                    ? toSnakeCase(builds.get(reference.target).name)
+                    : stripped);
+                const name = uniqueName(base, build.used);
+                build.relationNames.set(reference, name);
+                build.fieldNames.set(column.name.toLowerCase(), name);
+            }
+            else {
+                const unconsumed = reference.columns.every((column) => !build.consumed.has(column.name.toLowerCase()));
+                if (!unconsumed) {
+                    warnings.push(`table "${table.name}": the composite foreign key on (${reference.columns.map((column) => column.name).join(', ')}) shares a column with a single-column foreign key and was skipped.`);
+                    continue;
+                }
+                const name = uniqueName(sanitizeIdentifier(toSnakeCase(builds.get(reference.target).name)), build.used);
+                build.composite.push(reference);
+                build.relationNames.set(reference, name);
+            }
+        }
+    }
+    const manyToMany = [];
+    for (const [table, pair] of collapsed) {
+        const first = builds.get(pair.first.target);
+        const second = builds.get(pair.second.target);
+        const joinName = table.name.toLowerCase();
+        const prefixOf = (build) => joinName.startsWith(`${build.table.name.toLowerCase()}_`) &&
+            joinName.length > build.table.name.length + 1;
+        let owner = first;
+        let other = second;
+        if (!prefixOf(first) && prefixOf(second)) {
+            owner = second;
+            other = first;
+        }
+        let relationName;
+        let relatedBase;
+        if (first === second) {
+            // A self-referencing join table (follower_id, followee_id): the columns name both directions.
+            const firstColumn = stripKeySuffix(pair.first.columns[0]?.name ?? '');
+            const secondColumn = stripKeySuffix(pair.second.columns[0]?.name ?? '');
+            relationName = pluralize(sanitizeIdentifier(secondColumn === '' ? toSnakeCase(other.name) : secondColumn));
+            relatedBase =
+                firstColumn === ''
+                    ? undefined
+                    : pluralize(sanitizeIdentifier(firstColumn));
+        }
+        else if (prefixOf(owner)) {
+            relationName = sanitizeIdentifier(table.name.slice(owner.table.name.length + 1));
+        }
+        else {
+            relationName = pluralize(toSnakeCase(other.name));
+            warnings.push(`table "${table.name}": read as the many-to-many relation "${owner.name}.${relationName}"; writers name the join table "${owner.table.name}_${relationName}".`);
+        }
+        manyToMany.push({
+            owner,
+            other,
+            name: uniqueName(relationName, owner.used),
+            relatedBase,
+        });
+    }
+    for (const entry of manyToMany) {
+        entry.relatedName = uniqueName(entry.relatedBase ?? pluralize(toSnakeCase(entry.owner.name)), entry.other.used);
+    }
+    // Reverse accessor names of foreign keys.
+    const relatedNames = new Map();
+    for (const table of keptTables) {
+        const build = builds.get(table);
+        for (const reference of build.references) {
+            const name = build.relationNames.get(reference);
+            if (name === undefined) {
+                continue;
+            }
+            const targetBuild = builds.get(reference.target);
+            const sources = namedPerTarget(build).get(reference.target) ?? 0;
+            const isUnique = isOneToOne(table, reference);
+            const source = toSnakeCase(build.name);
+            const base = isUnique ? source : pluralize(source);
+            const preferred = sources > 1 ? `${name}_${base}` : base;
+            relatedNames.set(reference, uniqueName(preferred, targetBuild.used));
+        }
+    }
+    // Models.
+    const models = [];
+    const modelSchemaOf = (table) => table.schema !== undefined &&
+        !DEFAULT_SCHEMAS.has(table.schema.toLowerCase())
+        ? table.schema
+        : undefined;
+    for (const table of keptTables) {
+        const build = builds.get(table);
+        buildFields(build, enumByType, warnings);
+        const primaryKey = table.primaryKey?.columns ?? [];
+        const primaryKeyNames = new Set(primaryKey.map((name) => name.toLowerCase()));
+        for (const reference of build.references) {
+            const name = build.relationNames.get(reference);
+            if (name === undefined) {
+                continue;
+            }
+            const targetBuild = builds.get(reference.target);
+            const targetKey = targetKeyColumns(reference.target);
+            const oneToOne = isOneToOne(table, reference);
+            const nullable = reference.columns.some((column) => column.notNull !== true &&
+                !primaryKeyNames.has(column.name.toLowerCase()));
+            const onDelete = reference.raw.onDelete ?? 'noAction';
+            const onUpdate = reference.raw.onUpdate === undefined ||
+                reference.raw.onUpdate === 'noAction'
+                ? undefined
+                : reference.raw.onUpdate;
+            const relatedName = relatedNames.get(reference);
+            if (reference.columns.length === 1) {
+                const column = reference.columns[0];
+                const referenced = reference.targetColumns[0];
+                const pointsAtKey = targetKey.length === 1 &&
+                    targetKey[0]?.name.toLowerCase() === referenced.name.toLowerCase();
+                const isKey = primaryKey.length === 1 &&
+                    primaryKey[0]?.toLowerCase() === column.name.toLowerCase();
+                build.relations.push({
+                    name,
+                    kind: oneToOne ? 'oneToOne' : 'foreignKey',
+                    targetModel: targetBuild.name,
+                    columnName: column.name,
+                    isNullable: nullable && !isKey,
+                    onDelete,
+                    ...(relatedName === undefined ? {} : { relatedName }),
+                    ...(pointsAtKey
+                        ? {}
+                        : {
+                            toField: targetBuild.fieldNames.get(referenced.name.toLowerCase()) ??
+                                sanitizeIdentifier(referenced.name),
+                        }),
+                    ...(isKey ? { isPrimaryKey: true } : {}),
+                    ...(onUpdate === undefined ? {} : { onUpdate }),
+                    ...(reference.raw.name === undefined
+                        ? {}
+                        : { constraintName: reference.raw.name }),
+                });
+            }
+            else {
+                build.compositeForeignKeys.push({
+                    name,
+                    targetModel: targetBuild.name,
+                    fields: reference.columns.map((column) => build.fieldNames.get(column.name.toLowerCase()) ??
+                        sanitizeIdentifier(column.name)),
+                    references: reference.targetColumns.map((column) => targetBuild.fieldNames.get(column.name.toLowerCase()) ??
+                        sanitizeIdentifier(column.name)),
+                    kind: oneToOne ? 'oneToOne' : 'foreignKey',
+                    isNullable: nullable,
+                    onDelete,
+                    ...(onUpdate === undefined ? {} : { onUpdate }),
+                    ...(relatedName === undefined ? {} : { relatedName }),
+                    ...(reference.raw.name === undefined
+                        ? {}
+                        : { constraintName: reference.raw.name }),
+                });
+            }
+        }
+        for (const entry of manyToMany) {
+            if (entry.owner === build) {
+                build.relations.push({
+                    name: entry.name,
+                    kind: 'manyToMany',
+                    targetModel: entry.other.name,
+                    columnName: '',
+                    isNullable: false,
+                    onDelete: 'cascade',
+                    ...(entry.relatedName === undefined
+                        ? {}
+                        : { relatedName: entry.relatedName }),
+                });
+            }
+        }
+        buildIndexes(build, warnings);
+        const keyNames = primaryKey.map((name) => build.fieldNames.get(name.toLowerCase()) ?? sanitizeIdentifier(name));
+        const model = {
+            name: build.name,
+            tableName: table.name,
+            appLabel: options.appLabel,
+            fields: build.fields,
+            relations: build.relations,
+            indexes: build.indexes,
+            ...(keyNames.length > 1 ? { compositePrimaryKey: keyNames } : {}),
+            ...(modelSchemaOf(table) === undefined
+                ? {}
+                : { schema: modelSchemaOf(table) }),
+            ...(table.primaryKey?.name === undefined
+                ? {}
+                : { primaryKeyName: table.primaryKey.name }),
+            ...(build.compositeForeignKeys.length === 0
+                ? {}
+                : { compositeForeignKeys: build.compositeForeignKeys }),
+        };
+        if (primaryKey.length === 0) {
+            warnings.push(`table "${table.name}": the table has no primary key; most ORMs need one.`);
+        }
+        models.push(model);
+    }
+    return { models, enums, warnings: ctx.warnings };
+}
+/** A set of column names as a comparable key. */
+function columnSetKey(names) {
+    return names
+        .map((name) => name.toLowerCase())
+        .sort()
+        .join('\u0000');
+}
+const UNIQUE_COLUMN_SETS = new WeakMap();
+/** The column sets of a table that hold unique values: the primary key, unique constraints and unique indexes. */
+function uniqueColumnSets(table) {
+    const cached = UNIQUE_COLUMN_SETS.get(table);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const sets = new Set();
+    if (table.primaryKey !== undefined) {
+        sets.add(columnSetKey(table.primaryKey.columns));
+    }
+    for (const unique of table.uniques) {
+        sets.add(columnSetKey(unique.columns));
+    }
+    for (const index of table.indexes) {
+        if (index.isUnique &&
+            !index.isPartial &&
+            index.kind === undefined &&
+            index.elements.every((element) => element.column !== undefined)) {
+            sets.add(columnSetKey(index.elements.map((element) => element.column)));
+        }
+    }
+    UNIQUE_COLUMN_SETS.set(table, sets);
+    return sets;
+}
+/** A foreign key is one-to-one when its columns are the primary key or carry a unique constraint or index. */
+const NAMED_PER_TARGET = new WeakMap();
+/** How many named relations of a model point at each target table. */
+function namedPerTarget(build) {
+    const cached = NAMED_PER_TARGET.get(build);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const counts = new Map();
+    for (const reference of build.references) {
+        if (build.relationNames.has(reference)) {
+            counts.set(reference.target, (counts.get(reference.target) ?? 0) + 1);
+        }
+    }
+    NAMED_PER_TARGET.set(build, counts);
+    return counts;
+}
+function isOneToOne(table, reference) {
+    return uniqueColumnSets(table).has(columnSetKey(reference.columns.map((column) => column.name)));
+}
+function stripKeySuffix(column) {
+    const match = /^(.*?)(?:_(?:id|uuid|fk|pk|ref|key)|(?<=[a-z0-9])(?:Id|ID|Uuid))$/.exec(column);
+    if (match === null) {
+        return /^(?:id|uuid)$/i.test(column) ? '' : column;
+    }
+    return match[1] ?? '';
+}
+function buildFields(build, enumByType, warnings) {
+    const table = build.table;
+    const keyColumns = new Set((table.primaryKey?.columns ?? []).map((name) => name.toLowerCase()));
+    const singleKey = keyColumns.size === 1;
+    const uniqueNames = new Map();
+    for (const unique of table.uniques) {
+        if (unique.columns.length === 1) {
+            uniqueNames.set(unique.columns[0]?.toLowerCase() ?? '', unique.name);
+        }
+    }
+    for (const column of table.columns) {
+        const key = column.name.toLowerCase();
+        if (build.consumed.has(key)) {
+            continue;
+        }
+        const fieldName = build.fieldNames.get(key) ?? sanitizeIdentifier(column.name);
+        if (column.type.name === '' && table.dialect !== 'sqlite') {
+            warnings.push(`table "${table.name}", column "${column.name}": the column has no declared type (a computed column?) and was skipped.`);
+            build.fieldNames.delete(key);
+            continue;
+        }
+        const mapped = mapType(column.type, table.dialect);
+        let type = mapped.type;
+        let enumType = build.enumByColumn.get(key);
+        let unsupportedType;
+        if (enumType === undefined && mapped.isUserType === true) {
+            enumType = enumByType.get(column.type.userName.toLowerCase());
+        }
+        if (enumType !== undefined) {
+            type = 'string';
+        }
+        else if (mapped.unsupported === true) {
+            unsupportedType =
+                table.dialect === 'sqlserver' && column.type.name === 'timestamp'
+                    ? 'rowversion'
+                    : column.type.text;
+            if (mapped.isUserType === true) {
+                warnings.push(`table "${table.name}", column "${column.name}": the type "${column.type.text}" is unknown; it is kept as an unsupported column.`);
+            }
+        }
+        if (column.type.setValues !== undefined) {
+            warnings.push(`table "${table.name}", column "${column.name}": a SET column is read as text; the member list is dropped.`);
+        }
+        const inKey = keyColumns.has(key);
+        const isPrimaryKey = singleKey && inKey;
+        const isInteger = type === 'int' || type === 'bigInt';
+        const implicitRowId = table.dialect === 'sqlite' &&
+            !table.withoutRowid &&
+            isPrimaryKey &&
+            column.type.name === 'integer' &&
+            column.type.arrayDepth === 0;
+        const autoIncrement = isInteger &&
+            column.type.arrayDepth === 0 &&
+            (column.autoIncrement || mapped.autoIncrement === true || implicitRowId);
+        const nullable = column.notNull !== true && !inKey && !autoIncrement;
+        let columnDefault;
+        if (column.generated === undefined) {
+            if (column.defaultTokens !== undefined) {
+                const interpreted = interpretDefault(column.defaultTokens, {
+                    type,
+                    ...(enumType === undefined ? {} : { enumType }),
+                    isArray: column.type.arrayDepth > 0,
+                }, table.dialect);
+                if (interpreted === undefined) {
+                    const expression = column.defaultText ?? '';
+                    if (expression !== '') {
+                        columnDefault = { kind: 'dbExpression', expression };
+                    }
+                }
+                else if (interpreted !== null) {
+                    columnDefault = interpreted;
+                }
+            }
+            if (autoIncrement && columnDefault === undefined) {
+                columnDefault = { kind: 'autoIncrement' };
+            }
+        }
+        const field = {
+            name: fieldName,
+            columnName: column.name,
+            type,
+            isPrimaryKey,
+            isUnique: !isPrimaryKey && uniqueNames.has(key),
+            isNullable: nullable,
+            isAutoUpdated: column.onUpdateNow,
+            ...(columnDefault === undefined ? {} : { default: columnDefault }),
+            ...(mapped.maxLength === undefined
+                ? {}
+                : { maxLength: mapped.maxLength }),
+            ...(mapped.maxDigits === undefined
+                ? {}
+                : { maxDigits: mapped.maxDigits }),
+            ...(mapped.decimalPlaces === undefined
+                ? {}
+                : { decimalPlaces: mapped.decimalPlaces }),
+            ...(enumType === undefined ? {} : { enumName: enumType.name }),
+            ...(column.type.arrayDepth > 0
+                ? { arrayDepth: column.type.arrayDepth }
+                : {}),
+            ...(mapped.rangeOf === undefined ? {} : { rangeOf: mapped.rangeOf }),
+            ...(column.generated === undefined
+                ? {}
+                : { generated: column.generated }),
+            ...(unsupportedType === undefined ? {} : { unsupportedType }),
+            ...(!isPrimaryKey && uniqueNames.get(key) !== undefined
+                ? { uniqueName: uniqueNames.get(key) }
+                : {}),
+        };
+        build.fields.push(field);
+    }
+}
+function buildIndexes(build, warnings) {
+    const table = build.table;
+    const nameOf = (column) => build.fieldNames.get(column.toLowerCase());
+    for (const unique of table.uniques) {
+        if (unique.columns.length === 1) {
+            continue;
+        }
+        const names = unique.columns.map((column) => nameOf(column) ?? '');
+        if (names.some((name) => name === '')) {
+            warnings.push(`table "${table.name}": a unique constraint refers to an unknown column and was skipped.`);
+            continue;
+        }
+        build.indexes.push({
+            fields: names,
+            isUnique: true,
+            ...(unique.name === undefined ? {} : { name: unique.name }),
+        });
+    }
+    // The column lists (in order) of the foreign keys, to recognise the indexes MySQL adds for them.
+    const foreignKeyColumnLists = new Set(table.dialect === 'mysql'
+        ? build.references.map((reference) => reference.columns
+            .map((column) => nameOf(column.name) ?? '')
+            .join('\u0000'))
+        : []);
+    for (const index of table.indexes) {
+        const label = index.name === undefined ? '' : ` "${index.name}"`;
+        if (index.elements.some((element) => element.isExpression)) {
+            warnings.push(`table "${table.name}": the index${label} is on an expression, which the shared model cannot hold, and was skipped.`);
+            continue;
+        }
+        const names = index.elements.map((element) => nameOf(element.column ?? '') ?? '');
+        if (names.length === 0 || names.some((name) => name === '')) {
+            warnings.push(`table "${table.name}": the index${label} refers to an unknown column and was skipped.`);
+            continue;
+        }
+        // MySQL builds an index for every foreign key, so a plain index over exactly the key columns
+        // is the one the database added (or one that duplicates it), not a separate declaration.
+        if (table.dialect === 'mysql' &&
+            !index.isUnique &&
+            index.kind === undefined &&
+            !index.isPartial &&
+            index.method === undefined &&
+            foreignKeyColumnLists.has(names.join('\u0000'))) {
+            continue;
+        }
+        if (index.isPartial) {
+            if (index.isUnique) {
+                warnings.push(`table "${table.name}": the partial unique index${label} would become unconditionally unique and was skipped.`);
+                continue;
+            }
+            warnings.push(`table "${table.name}": the WHERE condition of the index${label} was dropped.`);
+        }
+        const fieldOptions = {};
+        index.elements.forEach((element, position) => {
+            const name = names[position];
+            const options = {
+                ...(element.descending ? { sort: 'desc' } : {}),
+                ...(element.length === undefined ? {} : { length: element.length }),
+                ...(element.ops === undefined
+                    ? {}
+                    : { ops: `raw("${element.ops}")` }),
+            };
+            if (Object.keys(options).length > 0) {
+                fieldOptions[name] = options;
+            }
+        });
+        build.indexes.push({
+            fields: names,
+            isUnique: index.isUnique,
+            ...(index.name === undefined ? {} : { name: index.name }),
+            ...(index.kind === 'fulltext' ? { kind: 'fulltext' } : {}),
+            ...(index.method === undefined
+                ? {}
+                : { method: indexMethod(index.method) }),
+            ...(index.clustered === undefined ? {} : { clustered: index.clustered }),
+            ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+        });
+        if (index.kind === 'spatial') {
+            warnings.push(`table "${table.name}": the spatial index${label} is read as an ordinary index.`);
+        }
+    }
+}
+const INDEX_METHODS = {
+    hash: 'Hash',
+    gin: 'Gin',
+    gist: 'Gist',
+    spgist: 'SpGist',
+    brin: 'Brin',
+    btree: 'BTree',
+};
+function indexMethod(method) {
+    return INDEX_METHODS[method.toLowerCase()] ?? toPascalCase(method);
+}
+//# sourceMappingURL=sqlDdl.js.map