uql-orm 0.80.0 → 0.81.0

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -8,6 +8,7 @@ import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../uti
 import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
+import { sides } from '../schemaChange.js';
 import { renderIndexDefinition } from './definitionToNode.js';
 import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
@@ -106,16 +107,11 @@ export class MongoSchemaGenerator extends MongoDialect {
     generateDropTable(tableName) {
         return serializeMongoCommand({ action: 'dropCollection', name: tableName });
     }
+    /** A collection's indexes: each dropped, then each created, an alter as both. */
     generateAlterTable(diff) {
         return [
-            ...(diff.indexesToDrop ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
-            ...(diff.indexesToAdd ?? []).map((index) => this.generateCreateIndex(diff.tableName, index)),
-        ];
-    }
-    generateAlterTableDown(diff) {
-        return [
-            ...(diff.indexesToAdd ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
-            ...(diff.indexesToDrop ?? []).map((index) => this.generateCreateIndex(diff.tableName, index)),
+            ...sides(diff.indexes, 'from').map((index) => this.dropIndexCommand(diff.tableName, index)),
+            ...sides(diff.indexes, 'to').map((index) => this.generateCreateIndex(diff.tableName, index)),
         ];
     }
     /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
@@ -221,17 +217,13 @@ export class MongoSchemaGenerator extends MongoDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        // By name: MongoDB lists a text index's fields alphabetically, so a shape would not match its own.
-        const { toAdd, toDrop } = indexChanges(collectionName, this.indexesOf(meta, collectionName), currentTable.indexes, (index) => index.name);
-        if (!toAdd.length && !toDrop.length) {
-            return undefined;
-        }
-        return {
-            tableName: collectionName,
-            type: 'alter',
-            indexesToAdd: toAdd.length ? toAdd : undefined,
-            indexesToDrop: toDrop.length ? toDrop.map(indexNodeToSchema) : undefined,
-        };
+        const { toAdd, toDrop, toAlter } = indexChanges(collectionName, this.indexesOf(meta, collectionName), currentTable.indexes, currentTable.indexFacets);
+        const indexes = [
+            ...toAdd.map((to) => ({ to })),
+            ...toDrop.map((from) => ({ from: indexNodeToSchema(from) })),
+            ...toAlter.map(({ from, to }) => ({ from: indexNodeToSchema(from), to })),
+        ];
+        return indexes.length ? { tableName: collectionName, type: 'alter', indexes } : undefined;
     }
 }
 /** The first value `partialFilterExpression` refuses, `null`, or a migration cannot carry as JSON, such as a `Date`. */

package/dist/migrate/index.d.ts

@@ -1,4 +1,4 @@
-export type { ColumnSchema, DialectName, ForeignKeySchema, IndexSchema, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlDialectName, SqlQuerier, SqlQueryDialect, SyncOptions, TableSchema, } from '../type/index.js';
+export type { Change, ColumnSchema, DialectName, ForeignKeySchema, IndexSchema, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, PrimaryKeySchema, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlDialectName, SqlQuerier, SqlQueryDialect, SyncOptions, TableSchema, } from '../type/index.js';
 export { type Config, isSqlQuerier } from '../type/index.js';
 export { acquireQuerierForMigrations } from './acquireQuerierForMigrations.js';
 export { assertCliConfig } from './assertCliConfig.js';
@@ -10,6 +10,7 @@ export * from './drift/index.js';
 export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { type BuilderMigrationDefinition, defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
+export { reverseDiff } from './schemaChange.js';
 export { SqlSchemaGenerator } from './schemaGenerator.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/dist/migrate/index.js

@@ -16,6 +16,7 @@ export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
 // Schema generators
+export { reverseDiff } from './schemaChange.js';
 export { SqlSchemaGenerator } from './schemaGenerator.js';
 // Storage implementations
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';

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

@@ -1,5 +1,5 @@
 import { type ForeignKeyAction } from '../../schema/types.js';
-import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
+import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, PrimaryKeySchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
  * Reads the rows of one statement while introspecting a table.
@@ -43,7 +43,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
      * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
      */
-    ownedTriggers(): Promise<Map<string, InstalledTriggers>>;
+    ownedTriggers(table: string): Promise<InstalledTriggers>;
     tableExists(tableName: string): Promise<boolean>;
     /**
      * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
@@ -54,10 +54,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected getColumns(read: TableRowReader, tableName: string): Promise<ColumnSchema[]>;
     protected getIndexes(read: TableRowReader, tableName: string): Promise<IndexSchema[]>;
     protected getForeignKeys(read: TableRowReader, tableName: string): Promise<ForeignKeySchema[]>;
-    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<{
-        columns?: string[];
-        name?: string;
-    }>;
+    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<PrimaryKeySchema | undefined>;
     protected tableExistsParams(tableName: string): unknown[];
     protected getColumnsParams(tableName: string): unknown[];
     protected getIndexesParams(tableName: string): unknown[];
@@ -90,6 +87,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      * `definition`, and where the body lives apart, the `requires` recreated first: what is installed, not
      * what uql wrote, which is exactly what a rollback puts back.
      */
+    /** The triggers on the table its one parameter names: each one's `name`, `definition`, and what it `requires`. */
     protected abstract triggersQuery(): string;
     /**
      * Extract table name from a row returned by getTableNamesQuery.
@@ -113,7 +111,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected mapPrimaryKeyResult(results: RawRow[]): string[] | undefined;
     /**
      * What the engine calls the key's constraint, where the query reported one. Only a `DROP` needs it,
-     * and only the reported name will do - see {@link TableSchema.primaryKeyName}.
+     * and only the reported name will do - see {@link PrimaryKeySchema.name}.
      */
     protected mapPrimaryKeyName(results: RawRow[]): string | undefined;
     /** Parse default value string to appropriate type. */

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -38,8 +38,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return {
                 name: tableName,
                 columns,
-                primaryKey: primaryKey.columns,
-                primaryKeyName: primaryKey.name,
+                primaryKey,
                 indexes,
                 foreignKeys,
             };
@@ -56,20 +55,13 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
      * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
      * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
      */
-    async ownedTriggers() {
-        return this.withSqlQuerier(async (querier) => {
-            const byTable = new Map();
-            for (const row of await querier.all(this.triggersQuery())) {
-                const name = String(row['name']);
-                if (!isOwnedName(name)) {
-                    continue;
-                }
-                const table = String(row['table']);
-                const statements = [row['requires'], row['definition']].filter(Boolean).map((sql) => String(sql));
-                byTable.set(table, (byTable.get(table) ?? new Map()).set(name, statements));
-            }
-            return byTable;
-        });
+    async ownedTriggers(table) {
+        const rows = await this.withSqlQuerier((querier) => querier.all(this.triggersQuery(), [table]));
+        return new Map(rows.flatMap((row) => {
+            const name = String(row['name']);
+            const statements = [row['requires'], row['definition']].filter(Boolean).map((sql) => String(sql));
+            return isOwnedName(name) ? [[name, statements]] : [];
+        }));
     }
     async tableExists(tableName) {
         return this.withSqlQuerier((querier) => this.tableExistsInternal(createTableRowReader(querier), tableName));
@@ -104,7 +96,8 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     }
     async getPrimaryKey(read, tableName) {
         const results = await read(this.getPrimaryKeyQuery(tableName), this.getPrimaryKeyParams(tableName));
-        return { columns: this.mapPrimaryKeyResult(results), name: this.mapPrimaryKeyName(results) };
+        const columns = this.mapPrimaryKeyResult(results);
+        return columns && { columns, name: this.mapPrimaryKeyName(results) };
     }
     tableExistsParams(tableName) {
         return [tableName];
@@ -166,7 +159,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     }
     /**
      * What the engine calls the key's constraint, where the query reported one. Only a `DROP` needs it,
-     * and only the reported name will do - see {@link TableSchema.primaryKeyName}.
+     * and only the reported name will do - see {@link PrimaryKeySchema.name}.
      */
     mapPrimaryKeyName(results) {
         const name = results[0]?.['constraint_name'];

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -1,5 +1,5 @@
 import { canonicalColumnType } from '../../schema/canonicalType.js';
-import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
+import { createTableNode, keyOfColumns, SchemaAST } from '../../schema/schemaAST.js';
 import { escapeSqlId } from '../../util/index.js';
 import { derivedForeignKeyName } from '../../util/sql.util.js';
 /**
@@ -56,7 +56,7 @@ export class BaseSqlIntrospector {
         return ast;
     }
     buildTable(schema) {
-        const table = createTableNode(schema.name, this.schema);
+        const table = createTableNode(schema.name, this.schema, this.indexFacets);
         const { columns } = table;
         for (const col of schema.columns) {
             // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
@@ -71,12 +71,10 @@ export class BaseSqlIntrospector {
             };
             columns.set(col.name, column);
         }
-        // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
-        // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
-        // to the flags for an introspector that reports no key of its own.
-        const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
-        table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
-        table.primaryKeyName = schema.primaryKeyName;
+        // From the ordered key the query returned, not from the per-column flags: `(a, b)` is a different
+        // key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back to the flags
+        // for an introspector that reports no key of its own.
+        table.primaryKey = schema.primaryKey ?? keyOfColumns(schema.columns);
         return table;
     }
     buildRelationships(ast, tableNodes, schema, fromTable) {
@@ -105,16 +103,7 @@ export class BaseSqlIntrospector {
             // does not have, and the index if that leaves none, is what the entity side does too.
             const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
             if (entries.length > 0) {
-                const index = {
-                    name: idx.name,
-                    table,
-                    entries,
-                    unique: idx.unique,
-                    type: idx.type,
-                    where: idx.where,
-                    include: idx.include,
-                };
-                ast.addIndex(index);
+                ast.addIndex({ ...idx, table, entries });
             }
         }
     }

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

@@ -11,7 +11,7 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
     /** MongoDB has no triggers, so none is ever installed. */
-    ownedTriggers(): Promise<Map<string, InstalledTriggers>>;
+    ownedTriggers(): Promise<InstalledTriggers>;
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     /** Collections only, the way a SQL engine lists its base tables: no view, nor the `system.views` behind one. */

package/dist/migrate/introspection/mongoIntrospector.js

@@ -24,7 +24,7 @@ export class MongoSchemaIntrospector {
         for (const name of tableNames) {
             const schema = await this.getTableSchema(name);
             if (schema) {
-                ast.addTable(buildTable(schema));
+                ast.addTable(buildTable(schema, this.indexFacets));
             }
         }
         return ast;
@@ -107,8 +107,8 @@ async function hasCollection(db, name) {
     return collections.length > 0;
 }
 /** Mongo has no columns to read, so a table's are the fields its indexes name, one node per field. */
-function buildTable({ name, indexes = [] }) {
-    const table = createTableNode(name);
+function buildTable({ name, indexes = [] }, indexFacets) {
+    const table = createTableNode(name, undefined, indexFacets);
     for (const index of indexes) {
         for (const { column } of index.entries) {
             if (!table.columns.has(column)) {

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -11,10 +11,11 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     defaultSchemaExpr = 'SCHEMA_NAME()';
     triggersQuery() {
         return /*sql*/ `
-      SELECT OBJECT_NAME(t.parent_id) AS [table], t.name AS name, m.definition AS definition
+      SELECT t.name AS name, m.definition AS definition
       FROM sys.triggers t
       JOIN sys.sql_modules m ON m.object_id = t.object_id
       WHERE t.parent_id <> 0 AND OBJECT_SCHEMA_NAME(t.parent_id) = ${this.schemaExpr}
+        AND OBJECT_NAME(t.parent_id) = ${this.dialect.placeholder(1)}
     `;
     }
     getTableNamesQuery() {

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';
 /**
@@ -17,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
@@ -52,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

@@ -9,11 +9,11 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     defaultSchemaExpr = 'DATABASE()';
     triggersQuery() {
         return /*sql*/ `
-      SELECT EVENT_OBJECT_TABLE AS \`table\`, TRIGGER_NAME AS name,
+      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}
+      WHERE TRIGGER_SCHEMA = ${this.schemaExpr} AND EVENT_OBJECT_TABLE = ${this.dialect.placeholder(1)}
     `;
     }
     getTableNamesQuery() {
@@ -62,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 = ?
@@ -110,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,
@@ -120,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.
@@ -164,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

@@ -22,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;
     /**
@@ -32,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;
@@ -73,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;
@@ -104,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;