uql-orm 0.79.0 → 0.81.0

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -1,3 +1,4 @@
+import type { IndexFacet } from '../../schema/indexDifferences.js';
 import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
 import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
@@ -6,6 +7,7 @@ import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowR
  */
 export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     protected readonly defaultSchemaExpr = "DATABASE()";
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: {
@@ -16,11 +18,7 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
     protected getForeignKeysQuery(_tableName: string): string;
     protected getPrimaryKeyQuery(_tableName: string): string;
     protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
-    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
-        index_name: string;
-        columns: string;
-        is_unique: number;
-    }[]): Promise<IndexSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: MysqlIndexRow[]): Promise<IndexSchema[]>;
     protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: JoinedForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     /**
      * MariaDB prints a string default as the literal it is (`'it''s'`). MySQL prints one bare, save an
@@ -51,6 +49,19 @@ type MysqlColumnRow = {
  * JSON, got LONGTEXT", flagged as data loss) on a table uql created itself.
  */
 export declare class MariadbSchemaIntrospector extends MysqlSchemaIntrospector {
+    /** Whether an index is MariaDB's vector index, and the distance it was built for. */
+    readonly indexFacets: ReadonlySet<IndexFacet>;
+    /**
+     * A vector index's distance is kept only in the table's own definition, ``VECTOR KEY `ix` (`vec`)
+     * `DISTANCE`='cosine'``, and left out there for MariaDB's default, euclidean.
+     */
+    protected mapIndexesResult(read: TableRowReader, tableName: string, results: MysqlIndexRow[]): Promise<IndexSchema[]>;
     protected mapColumnsResult(read: TableRowReader, tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
 }
+type MysqlIndexRow = {
+    index_name: string;
+    columns: string;
+    is_unique: number;
+    method: string;
+};
 export {};

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -7,6 +7,15 @@ import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.
 export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     // A MySQL "schema" is a database, so the connection's own is what `DATABASE()` reports.
     defaultSchemaExpr = 'DATABASE()';
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT TRIGGER_NAME AS name,
+        CONCAT('CREATE TRIGGER \`', TRIGGER_SCHEMA, '\`.\`', TRIGGER_NAME, '\` ', ACTION_TIMING, ' ', EVENT_MANIPULATION,
+          ' ON \`', EVENT_OBJECT_SCHEMA, '\`.\`', EVENT_OBJECT_TABLE, '\` FOR EACH ROW ', ACTION_STATEMENT) AS definition
+      FROM information_schema.TRIGGERS
+      WHERE TRIGGER_SCHEMA = ${this.schemaExpr} AND EVENT_OBJECT_TABLE = ${this.dialect.placeholder(1)}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT TABLE_NAME as table_name
@@ -53,7 +62,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       SELECT
         INDEX_NAME as index_name,
         GROUP_CONCAT(COALESCE(COLUMN_NAME, '') ORDER BY SEQ_IN_INDEX) as columns,
-        NOT NON_UNIQUE as is_unique
+        NOT NON_UNIQUE as is_unique,
+        MAX(INDEX_TYPE) as method
       FROM information_schema.STATISTICS
       WHERE TABLE_SCHEMA = ${this.schemaExpr}
         AND TABLE_NAME = ?
@@ -101,7 +111,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             isPrimaryKey: row.column_key === 'PRI',
             isAutoIncrement: row.extra.toLowerCase().includes('auto_increment'),
             isUnique: row.column_key === 'UNI',
-            length: this.toNumber(row.character_maximum_length),
+            // A `VECTOR`'s is its bytes, four a dimension, which `column_type` already states as dimensions.
+            length: /^vector/i.test(row.column_type) ? undefined : this.toNumber(row.character_maximum_length),
             precision: this.toNumber(row.numeric_precision),
             scale: this.toNumber(row.numeric_scale),
             comment: row.column_comment || undefined,
@@ -111,6 +122,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapIndexesResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.index_name,
+            ...(row.method === 'VECTOR' && { type: 'vector' }),
             // A functional or multi-valued key part has no `COLUMN_NAME` - the `COALESCE` above keeps its
             // place in the list, and it is reported as the expression it is, which is what stops diffing
             // from comparing an entry list the server cannot state against the entity's own.
@@ -155,6 +167,31 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
  * JSON, got LONGTEXT", flagged as data loss) on a table uql created itself.
  */
 export class MariadbSchemaIntrospector extends MysqlSchemaIntrospector {
+    /** Whether an index is MariaDB's vector index, and the distance it was built for. */
+    indexFacets = new Set(['vector', 'distance']);
+    /**
+     * A vector index's distance is kept only in the table's own definition, ``VECTOR KEY `ix` (`vec`)
+     * `DISTANCE`='cosine'``, and left out there for MariaDB's default, euclidean.
+     */
+    async mapIndexesResult(read, tableName, results) {
+        const indexes = await super.mapIndexesResult(read, tableName, results);
+        if (!indexes.some((index) => index.type === 'vector')) {
+            return indexes;
+        }
+        const qualified = [this.schema, tableName]
+            .filter((name) => name !== undefined)
+            .map((name) => this.dialect.escapeId(name));
+        const [row] = await read(/*sql*/ `SHOW CREATE TABLE ${qualified.join('.')}`);
+        const lines = row['Create Table'].split('\n');
+        return indexes.map((index) => {
+            if (index.type !== 'vector') {
+                return index;
+            }
+            const line = lines.find((it) => it.includes(`VECTOR KEY \`${index.name}\``));
+            const metric = line?.match(/`DISTANCE`='(\w+)'/)?.[1] ?? 'euclidean';
+            return { ...index, distance: this.dialect.indexedDistance(metric) };
+        });
+    }
     async mapColumnsResult(read, tableName, results) {
         const columns = await super.mapColumnsResult(read, tableName, results);
         const checks = await read(

package/dist/migrate/introspection/postgresIntrospector.d.ts

@@ -11,6 +11,7 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
      * database reprints in its own words, so they are not comparable and are not claimed here.
      */
     readonly indexFacets: ReadonlySet<IndexFacet>;
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: RawRow[]): boolean;
@@ -21,7 +22,11 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
      * database scans meet that table every time something else is migrating.
      *
      * `attgenerated` rather than `is_generated`, which cannot part a stored generated column from the
-     * virtual one Postgres 18 added and uql never declares. CockroachDB states it too.
+     * virtual one Postgres 18 added and uql never declares. CockroachDB states it too. `format_type` for an
+     * extension type's modifier, which `information_schema` drops: a `vector(256)` read back as `vector`.
+     * CockroachDB names that type `vector` where Postgres says `USER-DEFINED`.
+     *
+     * A column is unique by a unique index over it alone, a constraint's or its own, as every engine reads it.
      */
     protected getColumnsQuery(_tableName: string): string;
     /**
@@ -31,24 +36,27 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
      * while `pg_get_indexdef` reprints an identifier *quoted*, so a camelCase column came back as
      * `"tenantId"` and matched no column of the table. Prisma and drizzle-kit both split it this way.
      *
-     * Indexes backing a constraint are left out, primary keys among them: `@Field({ unique })` emits a
-     * `UNIQUE` constraint and no index, so reporting the index Postgres builds underneath it told every
-     * project it had an index its entities never asked for.
+     * The key's index and an `EXCLUDE`'s are left out. A `UNIQUE` constraint's index stays, as SQL Server
+     * and the MySQL family report theirs: the diff reads one over a single column as that column's
+     * uniqueness, and one over several as the unique `@Index` it is.
      */
     protected getIndexesQuery(_tableName: string): string;
-    /**
-     * Constraint kinds whose backing index is the constraint itself rather than an index anyone asked
-     * for. Postgres builds one for `PRIMARY KEY`, `UNIQUE` and `EXCLUDE`, and only for those: a plain
-     * `CREATE UNIQUE INDEX` has no `pg_constraint` row at all, so it survives.
-     *
-     * Nothing to do with {@link indexFacets}, which says which *attributes* of an index diffing may
-     * compare. This one decides which indexes are reported at all.
-     */
-    protected readonly constraintIndexTypes: readonly string[];
+    /** Whether an entry sorts nulls first, which Postgres states on every entry. */
+    protected readonly nullsFirstSql: string;
+    /** An index's access method, which is the type it declares. */
+    protected readonly indexMethodSql: string;
+    /** An entry's operator class, where it is not the default for its type. */
+    protected readonly opsClassSql: string;
     /** From `pg_constraint`, whose key arrays keep each column paired with the one it references. */
     protected getForeignKeysQuery(_tableName: string): string;
     protected getPrimaryKeyQuery(_tableName: string): string;
     protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: PostgresColumnRow[]): Promise<ColumnSchema[]>;
+    /**
+     * A vector index keeps its distance as its vector column's operator class, `{type}_{metric}_ops`, which
+     * is how `PgIndexDdl` writes the entity's `distance`; read back as that `distance`, so the two compare.
+     * No class named is the engine's default, L2.
+     */
+    private withVectorDistance;
     protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: PostgresIndexRow[]): Promise<IndexSchema[]>;
     protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: PostgresForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     protected normalizeType(dataType: string, udtName: string): string;
@@ -72,18 +80,18 @@ declare const FOREIGN_KEY_ACTION_CODES: {
  * CockroachDB answers the same catalogue queries and differs only in what it can express: v26.2.5
  * still rejects `NULLS FIRST/LAST` and operator classes as "unimplemented", and it sorts nulls first
  * on an ASC column where Postgres sorts them last. Reading a nulls order back would therefore report
- * every ascending index as drifted, against an entity that could not have asked for one. Its access
- * method, `prefix`, needs nothing: a method that is not a known index type is reported as no type.
+ * every ascending index as drifted, against an entity that could not have asked for one.
  */
 export declare class CockroachSchemaIntrospector extends PostgresSchemaIntrospector {
     readonly indexFacets: ReadonlySet<IndexFacet>;
+    /** None: it rejects a stated nulls order, so reading one back gives an index it would refuse to rebuild. */
+    protected readonly nullsFirstSql = "NULL::BOOL";
     /**
-     * `'u'` is missing on purpose. CockroachDB registers a `UNIQUE` constraint for a plain `CREATE
-     * UNIQUE INDEX` too, naming it after the index, so filtering on it would hide every unique index a
-     * user asked for and report it missing forever. It leaves no way to tell the two apart, so the
-     * index a `@Field({ unique })` builds underneath itself stays visible there.
+     * Every index reports the access method `prefix` and no operator class, so a vector index is read off
+     * its definition, `USING cspann (vec vector_cosine_ops)`: its type, and its last key's class.
      */
-    protected readonly constraintIndexTypes: readonly string[];
+    protected readonly indexMethodSql = "CASE WHEN pg_get_indexdef(ix.indexrelid) LIKE '% USING cspann %' THEN 'vector' ELSE am.amname END";
+    protected readonly opsClassSql = "CASE WHEN k.n = ix.indnkeyatts THEN substring(pg_get_indexdef(ix.indexrelid) from '(\\w+_ops)\\)') END";
 }
 type PostgresForeignKeyRow = {
     constraint_name: string;
@@ -103,13 +111,14 @@ type PostgresIndexRow = {
     is_expression: boolean;
     entry: string;
     descending: boolean;
-    nulls_first: boolean;
+    nulls_first: boolean | null;
     ops_class: string | null;
 };
 type PostgresColumnRow = {
     column_name: string;
     data_type: string;
     udt_name: string;
+    formatted_type: string | null;
     is_nullable: string;
     column_default: string | null;
     is_primary_key: boolean;

package/dist/migrate/introspection/postgresIntrospector.js

@@ -1,4 +1,5 @@
 import { INDEX_TYPES } from '../../schema/types.js';
+import { isVectorIndexType } from '../../type/vector.js';
 import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
 /**
  * PostgreSQL schema introspector
@@ -15,7 +16,17 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         'opsClass',
         'accessMethod',
         'include',
+        'distance',
     ]);
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT t.tgname AS name, pg_get_triggerdef(t.oid) AS definition, pg_get_functiondef(t.tgfoid) AS requires
+      FROM pg_trigger t
+      JOIN pg_class c ON c.oid = t.tgrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE NOT t.tgisinternal AND n.nspname = ${this.schemaExpr} AND c.relname = ${this.dialect.placeholder(1)}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT table_name
@@ -44,7 +55,11 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
      * database scans meet that table every time something else is migrating.
      *
      * `attgenerated` rather than `is_generated`, which cannot part a stored generated column from the
-     * virtual one Postgres 18 added and uql never declares. CockroachDB states it too.
+     * virtual one Postgres 18 added and uql never declares. CockroachDB states it too. `format_type` for an
+     * extension type's modifier, which `information_schema` drops: a `vector(256)` read back as `vector`.
+     * CockroachDB names that type `vector` where Postgres says `USER-DEFINED`.
+     *
+     * A column is unique by a unique index over it alone, a constraint's or its own, as every engine reads it.
      */
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -59,11 +74,9 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         c.numeric_scale,
         c.is_identity,
         c.identity_generation,
-        CASE WHEN (
-          SELECT a.attgenerated FROM pg_catalog.pg_attribute a
-          WHERE a.attrelid = to_regclass(quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))
-            AND a.attname = c.column_name
-        ) = 's' THEN c.generation_expression END AS generated_as,
+        CASE WHEN a.attgenerated = 's' THEN c.generation_expression END AS generated_as,
+        CASE WHEN c.data_type IN ('USER-DEFINED', 'vector') AND a.atttypmod > -1
+          THEN format_type(a.atttypid, a.atttypmod) END AS formatted_type,
         EXISTS (
           SELECT 1 FROM information_schema.table_constraints tc
           JOIN information_schema.key_column_usage kcu USING (constraint_schema, constraint_name)
@@ -73,19 +86,19 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             AND kcu.column_name = c.column_name
         ) AS is_primary_key,
         EXISTS (
-          SELECT 1 FROM information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu USING (constraint_schema, constraint_name)
-          WHERE tc.table_schema = c.table_schema
-            AND tc.table_name = c.table_name
-            AND tc.constraint_type = 'UNIQUE'
-          GROUP BY tc.constraint_name
-          HAVING COUNT(*) = 1 AND MIN(kcu.column_name) = c.column_name
+          SELECT 1 FROM pg_catalog.pg_index ix
+          WHERE ix.indrelid = a.attrelid AND ix.indisunique AND NOT ix.indisprimary
+            AND ix.indnkeyatts = 1 AND ix.indkey[0] = a.attnum
+            AND ix.indpred IS NULL AND ix.indexprs IS NULL
         ) AS is_unique,
         pg_catalog.col_description(
           to_regclass(quote_ident(c.table_schema) || '.' || quote_ident(c.table_name)),
           c.ordinal_position
         ) AS column_comment
       FROM information_schema.columns c
+      LEFT JOIN pg_catalog.pg_attribute a
+        ON a.attrelid = to_regclass(quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))
+        AND a.attname = c.column_name
       WHERE c.table_schema = ${this.schemaExpr}
         AND c.table_name = $1
       ORDER BY c.ordinal_position
@@ -98,23 +111,23 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
      * while `pg_get_indexdef` reprints an identifier *quoted*, so a camelCase column came back as
      * `"tenantId"` and matched no column of the table. Prisma and drizzle-kit both split it this way.
      *
-     * Indexes backing a constraint are left out, primary keys among them: `@Field({ unique })` emits a
-     * `UNIQUE` constraint and no index, so reporting the index Postgres builds underneath it told every
-     * project it had an index its entities never asked for.
+     * The key's index and an `EXCLUDE`'s are left out. A `UNIQUE` constraint's index stays, as SQL Server
+     * and the MySQL family report theirs: the diff reads one over a single column as that column's
+     * uniqueness, and one over several as the unique `@Index` it is.
      */
     getIndexesQuery(_tableName) {
         return /*sql*/ `
       SELECT
         i.relname AS index_name,
         ix.indisunique AS is_unique,
-        am.amname AS method,
+        ${this.indexMethodSql} AS method,
         pg_get_expr(ix.indpred, ix.indrelid, true) AS predicate,
         k.n <= ix.indnkeyatts AS is_key,
         k.attnum = 0 AS is_expression,
         COALESCE(a.attname::text, pg_get_indexdef(ix.indexrelid, k.n::int, true)) AS entry,
         (ix.indoption[k.n - 1] & 1) <> 0 AS descending,
-        (ix.indoption[k.n - 1] & 2) <> 0 AS nulls_first,
-        CASE WHEN op.opcdefault THEN NULL ELSE op.opcname END AS ops_class
+        ${this.nullsFirstSql} AS nulls_first,
+        ${this.opsClassSql} AS ops_class
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid
@@ -127,22 +140,17 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND n.nspname = ${this.schemaExpr}
         AND NOT ix.indisprimary
         AND NOT EXISTS (
-          SELECT 1 FROM pg_constraint con
-          WHERE con.conindid = ix.indexrelid
-            AND con.contype IN (${this.constraintIndexTypes.map((type) => `'${type}'`).join(', ')})
+          SELECT 1 FROM pg_constraint con WHERE con.conindid = ix.indexrelid AND con.contype = 'x'
         )
       ORDER BY i.relname, k.n
     `;
     }
-    /**
-     * Constraint kinds whose backing index is the constraint itself rather than an index anyone asked
-     * for. Postgres builds one for `PRIMARY KEY`, `UNIQUE` and `EXCLUDE`, and only for those: a plain
-     * `CREATE UNIQUE INDEX` has no `pg_constraint` row at all, so it survives.
-     *
-     * Nothing to do with {@link indexFacets}, which says which *attributes* of an index diffing may
-     * compare. This one decides which indexes are reported at all.
-     */
-    constraintIndexTypes = ['p', 'u', 'x'];
+    /** Whether an entry sorts nulls first, which Postgres states on every entry. */
+    nullsFirstSql = '(ix.indoption[k.n - 1] & 2) <> 0';
+    /** An index's access method, which is the type it declares. */
+    indexMethodSql = 'am.amname';
+    /** An entry's operator class, where it is not the default for its type. */
+    opsClassSql = 'CASE WHEN op.opcdefault THEN NULL ELSE op.opcname END';
     /** From `pg_constraint`, whose key arrays keep each column paired with the one it references. */
     getForeignKeysQuery(_tableName) {
         const columnsOf = (keys, table) => /*sql*/ `ARRAY_TO_JSON(ARRAY(
@@ -184,7 +192,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.column_name,
-            type: this.normalizeType(row.data_type, row.udt_name),
+            type: row.formatted_type?.toUpperCase() ?? this.normalizeType(row.data_type, row.udt_name),
             nullable: row.is_nullable === 'YES',
             defaultValue: this.parseDefaultValue(row.column_default),
             isPrimaryKey: row.is_primary_key,
@@ -197,11 +205,25 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             generatedAs: row.generated_as ?? undefined,
         }));
     }
+    /**
+     * A vector index keeps its distance as its vector column's operator class, `{type}_{metric}_ops`, which
+     * is how `PgIndexDdl` writes the entity's `distance`; read back as that `distance`, so the two compare.
+     * No class named is the engine's default, L2.
+     */
+    withVectorDistance(index) {
+        if (!isVectorIndexType(index.type)) {
+            return index;
+        }
+        const opsClass = index.entries.find((entry) => entry.opsClass)?.opsClass;
+        const distance = this.dialect.indexedDistance(opsClass ? /_([a-z0-9]+)_ops$/.exec(opsClass)?.[1] : 'l2');
+        const entries = index.entries.map(({ opsClass: _opsClass, ...entry }) => entry);
+        return distance ? { ...index, distance, entries } : index;
+    }
     async mapIndexesResult(_read, _tableName, results) {
         // One row per index entry, ordered by position, so the rows of an index are its entries in order.
         return [...Map.groupBy(results, (row) => row.index_name)].map(([name, rows]) => {
             const include = rows.filter((row) => !row.is_key).map((row) => row.entry);
-            return {
+            return this.withVectorDistance({
                 name,
                 entries: rows.filter((row) => row.is_key).map(mapIndexEntry),
                 unique: rows[0].is_unique,
@@ -209,7 +231,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
                 where: rows[0].predicate ?? undefined,
                 include: include.length > 0 ? include : undefined,
                 ...fulltextIndex(rows),
-            };
+            });
         });
     }
     async mapForeignKeysResult(_read, _tableName, results) {
@@ -305,7 +327,7 @@ function mapIndexEntry(row) {
         column: row.entry,
         ...(row.is_expression && { expression: true }),
         order: row.descending ? 'desc' : 'asc',
-        nulls: row.nulls_first ? 'first' : 'last',
+        ...(row.nulls_first !== null && { nulls: row.nulls_first ? 'first' : 'last' }),
         ...(row.ops_class && { opsClass: row.ops_class }),
     };
 }
@@ -313,16 +335,21 @@ function mapIndexEntry(row) {
  * CockroachDB answers the same catalogue queries and differs only in what it can express: v26.2.5
  * still rejects `NULLS FIRST/LAST` and operator classes as "unimplemented", and it sorts nulls first
  * on an ASC column where Postgres sorts them last. Reading a nulls order back would therefore report
- * every ascending index as drifted, against an entity that could not have asked for one. Its access
- * method, `prefix`, needs nothing: a method that is not a known index type is reported as no type.
+ * every ascending index as drifted, against an entity that could not have asked for one.
  */
 export class CockroachSchemaIntrospector extends PostgresSchemaIntrospector {
-    indexFacets = new Set(['order', 'include']);
+    indexFacets = new Set([
+        'order',
+        'include',
+        'vector',
+        'distance',
+    ]);
+    /** None: it rejects a stated nulls order, so reading one back gives an index it would refuse to rebuild. */
+    nullsFirstSql = 'NULL::BOOL';
     /**
-     * `'u'` is missing on purpose. CockroachDB registers a `UNIQUE` constraint for a plain `CREATE
-     * UNIQUE INDEX` too, naming it after the index, so filtering on it would hide every unique index a
-     * user asked for and report it missing forever. It leaves no way to tell the two apart, so the
-     * index a `@Field({ unique })` builds underneath itself stays visible there.
+     * Every index reports the access method `prefix` and no operator class, so a vector index is read off
+     * its definition, `USING cspann (vec vector_cosine_ops)`: its type, and its last key's class.
      */
-    constraintIndexTypes = ['p', 'x'];
+    indexMethodSql = `CASE WHEN pg_get_indexdef(ix.indexrelid) LIKE '% USING cspann %' THEN 'vector' ELSE am.amname END`;
+    opsClassSql = `CASE WHEN k.n = ix.indnkeyatts THEN substring(pg_get_indexdef(ix.indexrelid) from '(\\w+_ops)\\)') END`;
 }

package/dist/migrate/introspection/sqliteIntrospector.d.ts

@@ -8,6 +8,7 @@ export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospec
     /** Whether an index is libSQL's vector index, where the engine has one; elsewhere a declared one is built plain. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     /** Not SQLite's own tables, nor the ones libSQL keeps a vector index in: its metadata and `<index>_shadow`. */
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: SqliteCountRow[]): boolean;

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -5,8 +5,11 @@ import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.j
  */
 export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     /** Whether an index is libSQL's vector index, where the engine has one; elsewhere a declared one is built plain. */
-    indexFacets = new Set(this.dialect.hasVectorIndex() ? ['vector'] : []);
+    indexFacets = new Set(this.dialect.hasVectorIndex() ? ['vector', 'distance'] : []);
     /** Not SQLite's own tables, nor the ones libSQL keeps a vector index in: its metadata and `<index>_shadow`. */
+    triggersQuery() {
+        return /*sql*/ `SELECT name, sql AS definition FROM sqlite_master WHERE type = 'trigger' AND tbl_name = ?`;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT name
@@ -86,15 +89,12 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         const indexSchemas = [];
         for (const index of results) {
             const columns = await this.getIndexColumns(read, index.name);
-            // Include user-created indexes ('c') and multi-column unique constraints ('u')
-            // Skip primary key indexes ('pk') and single-column unique constraints
-            const isUserCreated = index.origin === 'c';
-            const isCompositeUnique = index.origin === 'u' && columns.length > 1;
+            // A unique constraint's index ('u') is reported as every engine reports it, and only the key's ('pk') left out.
             // `PRAGMA index_info` names an expression entry `null` (its `cid` is -2), and the expression text
             // lives only in `sqlite_master.sql`. Reporting `{ column: null }` put a column literally named
             // `null` into the diff, so an index UQL cannot describe is left out, libSQL's vector index aside.
             const named = columns.filter((column) => column.name !== null);
-            if (!isUserCreated && !isCompositeUnique) {
+            if (index.origin === 'pk') {
                 continue;
             }
             if (named.length === columns.length) {
@@ -168,8 +168,13 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             return undefined;
         }
         const metric = row.sql?.match(/'metric=(\w+)'/i)?.[1]?.toLowerCase();
-        const distances = new Map([...this.dialect.vectorMetrics].map(([distance, { index }]) => [index, distance]));
-        return { name: indexName, entries: [{ column }], unique: false, type: 'vector', distance: distances.get(metric) };
+        return {
+            name: indexName,
+            entries: [{ column }],
+            unique: false,
+            type: 'vector',
+            distance: this.dialect.indexedDistance(metric),
+        };
     }
     /** The statement that created the table, which is where SQLite keeps every expression it was given. */
     async getTableDdl(read, tableName) {

package/dist/migrate/migrator.d.ts

@@ -63,6 +63,33 @@ export declare class Migrator {
      * Generate a migration based on entity schema differences
      */
     generateFromEntities(name: string): Promise<string>;
+    /**
+     * Each entity on a table this plan does not create - a new one carries its triggers in its `CREATE` -
+     * beside the triggers uql has installed there, read once per schema. Kept only where either side has
+     * any: one declaring none on a table holding none has nothing to reconcile.
+     */
+    private installedTriggers;
+    /**
+     * The alters, with the triggers reconciled around them. Postgres refuses to retype or drop a column a
+     * trigger names, so every trigger on a table whose columns change comes off before the alters and what
+     * its entity declares goes back on after. `down` is lazy: SQLite cannot express every alter's inverse.
+     */
+    private alterPlan;
+    /**
+     * Each entity's triggers taken from what the catalogue holds to what it declares. Against the catalogue
+     * rather than a diff, because a trigger hangs off a table whose columns may be unchanged: a body edited
+     * on a settled table appears in no diff at all.
+     */
+    private reconcileTriggers;
+    /**
+     * The inverse: what the reconcile created dropped, and what it dropped restored as the engine reprints
+     * it. Read off the catalogue rather than recorded by uql, and exactly right for restoring one.
+     */
+    private revertedTriggers;
+    /** The entities whose tables are among `created`. */
+    private createdEntities;
+    /** The table `entity` maps to, as a diff names it. */
+    private tableOf;
     /**
      * Get all schema differences between entities and database
      */
@@ -82,7 +109,7 @@ export declare class Migrator {
      * settle instead of colliding; an existing one still pays for introspection, as a diff needs columns.
      */
     private planEntity;
-    /** The same for one entity against the table it already has, and nothing where the two agree. */
+    /** The diff for one entity against the table it already has, and none where the two agree. */
     private alterFromEntity;
     /** The configured entities, with `entity` among them however the migrator was built. */
     private entitiesWith;
@@ -101,6 +128,11 @@ export declare class Migrator {
      * never asks for the rollback, which on SQLite cannot even be expressed (no `ALTER COLUMN`).
      */
     private pendingChanges;
+    /**
+     * Safe mode only adds: a change with a `from` drops or rebuilds what the table holds, so it is held,
+     * and so is a key whole, which rebuilds an index over every row and fails where a column holds a null.
+     * Without `drop`, a column's drop is held too.
+     */
     protected filterDiff(diff: SchemaDiff, options: {
         safe?: boolean;
         drop?: boolean;