uql-orm 0.52.0 → 0.54.0

package/dist/migrate/schemaGenerator.js

@@ -4,10 +4,11 @@ import { areTypesEqual, canonicalToSql, engineType, fieldOptionsToCanonical, isV
 import { indexSignature } from '../schema/indexDifferences.js';
 import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
-import { getKeys, isAutoIncrement, isSoleIdField, qualifyName } from '../util/index.js';
+import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName } from '../util/sql.util.js';
 import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
-import { indexDdlFor } from './ddl/index.js';
+import { indexDdlFor, tableDdlFor } from './ddl/index.js';
+import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 /**
@@ -19,10 +20,13 @@ export class SqlSchemaGenerator {
     defaultForeignKeyAction;
     /** `CREATE INDEX` for this dialect: the migrator's, so a runtime import carries none of it. */
     indexDdl;
+    /** The `ALTER TABLE` statements this dialect spells its own way, the migrator's for the same reason. */
+    tableDdl;
     constructor(dialect, defaultForeignKeyAction = 'NO ACTION') {
         this.dialect = dialect;
         this.defaultForeignKeyAction = defaultForeignKeyAction;
         this.indexDdl = indexDdlFor(dialect);
+        this.tableDdl = tableDdlFor(dialect);
     }
     get namingStrategy() {
         return this.dialect.namingStrategy;
@@ -46,9 +50,6 @@ export class SqlSchemaGenerator {
     escapeId(identifier) {
         return this.dialect.escapeId(identifier);
     }
-    /**
-     * Primary key type for auto-increment integer IDs
-     */
     /**
      * How an auto-increment key of `type` is spelled: the type as any other column renders it, plus what
      * the engine appends to make it generated.
@@ -138,7 +139,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTable(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // Before the columns, because a key column being added cannot be part of the old key, and after
         // it is dropped the table is free to take the new one below.
         if (diff.primaryKey?.from.length) {
@@ -154,7 +154,7 @@ export class SqlSchemaGenerator {
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
                 this.assertColumnAddable(diff.tableName, column);
-                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.generateColumnDefinitionFromSchema(column)};`);
+                statements.push(this.tableDdl.addColumn(diff.tableName, this.generateColumnDefinitionFromSchema(column)));
                 statements.push(...this.generateColumnCommentStatement(diff.tableName, column, diff.schema));
             }
         }
@@ -169,7 +169,7 @@ export class SqlSchemaGenerator {
         // Drop columns
         if (diff.columnsToDrop?.length) {
             for (const columnName of diff.columnsToDrop) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
             }
         }
         // Add indexes
@@ -206,7 +206,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTableDown(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // Constraints first, mirroring the up direction: the up added them last, so the down drops them
         // first, and a column it is about to drop is then free of anything naming it.
         statements.push(...this.dropForeignKeyStatements(diff.tableName, [
@@ -222,7 +221,7 @@ export class SqlSchemaGenerator {
         // Reverse column additions by dropping them
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
             }
         }
         // Reverse column alterations by restoring original schema
@@ -273,53 +272,35 @@ export class SqlSchemaGenerator {
      * {@link renderColumn}, which is the part that must not be written twice.
      */
     generateColumnDefinitionFromSchema(column) {
-        let type = column.type;
-        if (!type.includes('(')) {
-            if (column.precision !== undefined) {
-                type += column.scale === undefined ? `(${column.precision})` : `(${column.precision}, ${column.scale})`;
-            }
-            else if (column.length !== undefined) {
-                type += `(${column.length})`;
-            }
-        }
-        return this.renderColumn({ ...column, type });
+        return this.renderColumn({ ...column, type: sizedType(column) });
     }
     /**
-     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
-     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
-     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
+     * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
+     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
+     * enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     renderColumn(column) {
-        let def = `${this.escapeId(column.name)} ${column.type}`;
-        // Before the constraints, which every engine here accepts and is where each documents it. The
-        // clause takes the place of a `DEFAULT`, which is mutually exclusive with it; everything else -
-        // `NOT NULL`, `UNIQUE`, an enum `CHECK`, a comment - a generated column carries like any other.
-        if (column.generatedAs) {
-            def += ` GENERATED ALWAYS AS (${column.generatedAs}) STORED`;
-        }
-        if (!column.nullable && !column.isPrimaryKey) {
+        const type = column.generatedAs
+            ? this.tableDdl.storedGeneratedColumn(column.type, column.generatedAs)
+            : column.type;
+        let def = `${this.escapeId(column.name)} ${type}`;
+        if (!column.nullable) {
             def += ' NOT NULL';
         }
         if (column.isUnique && !column.isPrimaryKey) {
             def += ' UNIQUE';
         }
+        def += this.tableDdl.defaultClause(column);
+        if (column.comment) {
+            def += this.generateColumnComment(column.comment);
+        }
         if (column.enum?.length) {
             const values = column.enum.map((value) => this.dialect.escape(value)).join(', ');
             def += ` CHECK (${this.escapeId(column.name)} IN (${values}))`;
         }
-        def += this.defaultClause(column);
-        if (column.comment) {
-            def += this.generateColumnComment(column.comment);
-        }
         return def;
     }
-    /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
-     * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
-    defaultClause(column) {
-        return column.defaultValue === undefined
-            ? ''
-            : ` DEFAULT ${formatDefaultValue(column.defaultValue, this.dialect, column.type)}`;
-    }
     getSqlType(field) {
         // A foreign key takes the type of the key it points at. A `referencedKey` the target does not
         // have falls through to this column's own options, as the AST builder does with the same case.
@@ -338,35 +319,9 @@ export class SqlSchemaGenerator {
         }
         return this.canonicalTypeToSql(canonical);
     }
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
+    /** The statements that alter `column` in place, as this dialect spells them. */
     generateAlterColumnStatements(tableName, column, newDefinition) {
-        const table = this.escapeId(tableName);
-        const colName = this.escapeId(column.name);
-        if (this.dialect.alterColumnSyntax === 'none') {
-            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
-                `This database does not support ALTER COLUMN.`);
-        }
-        if (this.dialect.alterColumnStrategy === 'separate-clauses') {
-            const statements = [];
-            // Separate ALTER COLUMN clauses for different changes (Postgres)
-            statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} TYPE ${column.type};`);
-            if (column.nullable) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP NOT NULL;`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET NOT NULL;`);
-            }
-            if (column.defaultValue !== undefined) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET${this.defaultClause(column)};`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP DEFAULT;`);
-            }
-            return statements;
-        }
-        return [`ALTER TABLE ${table} ${this.dialect.alterColumnSyntax} ${newDefinition};`];
+        return this.tableDdl.alterColumn(tableName, column, newDefinition);
     }
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment) {
@@ -403,9 +358,6 @@ export class SqlSchemaGenerator {
         const tableRef = this.dialect.escapeQualifiedId(tableName, schema);
         return [`COMMENT ON COLUMN ${tableRef}.${this.escapeId(column.name)} IS ${this.dialect.escape(column.comment)};`];
     }
-    /**
-     * Compare an entity with a database table node and return the differences.
-     */
     /**
      * How this entity differs from the table the database reported, as the migrator's `SchemaDiff`.
      *
@@ -489,13 +441,6 @@ export class SqlSchemaGenerator {
             foreignKeysToAlter: foreignKeysToAlter.length ? foreignKeysToAlter : undefined,
         };
     }
-    /**
-     * What the shared differ needs from a dialect: a type as this engine would actually store it.
-     *
-     * `boolean` is `TINYINT(1)` on MySQL and `INTEGER` on SQLite, so two canonical types that differ on
-     * paper can be one column in the database. Round-tripping through the engine's own spelling is what
-     * stops every such column reporting an alteration on every sync.
-     */
     /**
      * Indexes the entity declares that the table does not already have, in any shape.
      *
@@ -627,10 +572,7 @@ export class SqlSchemaGenerator {
         return this.generateCreateTableFromNode(tableNode, options);
     }
     generateRenameTableSql(oldName, newName) {
-        if (this.dialect.renameTableSyntax === 'rename-table') {
-            return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
-        }
-        return `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameTable(oldName, newName);
     }
     /**
      * `ADD COLUMN`, plus the constraint and index the column declares.
@@ -643,7 +585,7 @@ export class SqlSchemaGenerator {
     generateAddColumnSql(tableName, column) {
         this.assertColumnAddable(tableName, column);
         const colSql = this.generateColumnFromNode(fullColumnDefinitionToNode(column, tableName));
-        const statements = [`ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${colSql};`];
+        const statements = [this.tableDdl.addColumn(tableName, colSql)];
         const foreignKey = columnForeignKey(column);
         if (foreignKey) {
             statements.push(...this.addForeignKeyStatements(tableName, [foreignKey]));
@@ -660,10 +602,10 @@ export class SqlSchemaGenerator {
         return this.generateAlterColumnStatements(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node)).join('\n');
     }
     generateDropColumnSql(tableName, columnName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)};`;
+        return this.tableDdl.dropColumn(tableName, columnName).join('\n');
     }
     generateRenameColumnSql(tableName, oldName, newName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameColumn(tableName, oldName, newName);
     }
     /**
      * `CONSTRAINT <name> FOREIGN KEY (...) REFERENCES ... ON DELETE ... ON UPDATE ...`.

package/dist/migrate/storage/databaseStorage.d.ts

@@ -1,10 +1,10 @@
 import type { MigrationStorage, QuerierPool, SqlQuerier } from '../../type/index.js';
+/** Where executed migrations are recorded when the config does not name a table. */
+export declare const DEFAULT_MIGRATIONS_TABLE = "uql_migrations";
 /**
  * Stores migration state in a database table.
  * Uses the querier's dialect for escaping and placeholders.
  */
-/** Where executed migrations are recorded when the config does not name a table. */
-export declare const DEFAULT_MIGRATIONS_TABLE = "uql_migrations";
 export declare class DatabaseMigrationStorage implements MigrationStorage {
     private readonly pool;
     private readonly tableName;

package/dist/migrate/storage/databaseStorage.js

@@ -1,10 +1,10 @@
 import { withSqlQuerierForMigrations } from '../acquireQuerierForMigrations.js';
+/** Where executed migrations are recorded when the config does not name a table. */
+export const DEFAULT_MIGRATIONS_TABLE = 'uql_migrations';
 /**
  * Stores migration state in a database table.
  * Uses the querier's dialect for escaping and placeholders.
  */
-/** Where executed migrations are recorded when the config does not name a table. */
-export const DEFAULT_MIGRATIONS_TABLE = 'uql_migrations';
 export class DatabaseMigrationStorage {
     pool;
     tableName;

package/dist/mongo/mongoDialect.js

@@ -4,7 +4,7 @@ import { COUNT_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, sortCountField } from '..
 import { resolveQueryJoins, resolveSortableJoin } from '../dialect/queryJoins.js';
 import { assertSoleId, getMeta, soleIdOf } from '../entity/index.js';
 import { QueryRaw } from '../type/queryRaw.js';
-import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, buildQueryWhereAsMap, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
+import { asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, entityName, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isJsonUpdateOp, isOperatorMap, isOperatorObject, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationSize, parseSortByCount, someKey, targetKeyColumns, } from '../util/index.js';
 /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoDialect} and its schema generator. */
 export const mongoDialectFeatures = {
     explicitJsonCast: false,
@@ -14,7 +14,6 @@ export const mongoDialectFeatures = {
     indexIfNotExists: false,
     schemas: false, // the connection picks the database, and a collection name takes no dot
     dropTableCascade: false,
-    renameColumn: false,
     foreignKeyAlter: false,
     primaryKeyAlter: false,
     generatedColumnAdd: false,
@@ -24,7 +23,6 @@ export const mongoDialectFeatures = {
     supportsTimestamptz: false,
     stringSizing: 'bounded-text',
     supportsUnsigned: false,
-    multipleCascadePaths: true,
     serverSideCursors: false,
 };
 /** What `toWireId` converts: the hex spelling of an `ObjectId`, and nothing looser. */
@@ -70,7 +68,7 @@ export class MongoDialect extends AbstractDialect {
     where(entity, where = {}, opts = {}) {
         const meta = getMeta(entity);
         // Filters are applied once, here at the scope entry point; recursion uses `renderFilter`.
-        return this.renderFilter(entity, this.scopedWhereMap(meta, where, opts));
+        return this.renderFilter(entity, this.scopedWhere(meta, where, opts));
     }
     /**
      * A `$where` that may constrain relations, split into the `$lookup` stages it needs and the `$match`
@@ -82,7 +80,7 @@ export class MongoDialect extends AbstractDialect {
     whereWithRelations(entity, where = {}, opts = {}) {
         const meta = getMeta(entity);
         const lookups = { stages: [], temps: [] };
-        const filter = this.renderFilter(entity, this.scopedWhereMap(meta, where, opts), opts, lookups);
+        const filter = this.renderFilter(entity, this.scopedWhere(meta, where, opts), opts, lookups);
         return { stages: lookups.stages, filter, unset: lookups.temps };
     }
     /** Whether a `$where` constrains any relation, and so needs the aggregation path rather than a cursor. */
@@ -91,9 +89,9 @@ export class MongoDialect extends AbstractDialect {
             return false;
         }
         const meta = getMeta(entity);
-        const whereMap = buildQueryWhereAsMap(meta, where);
+        const whereMap = where;
         return someKey(whereMap, (key) => MongoDialect.isGroupOp(key)
-            ? (whereMap[key] ?? []).some((it) => this.constrainsRelations(entity, it))
+            ? (whereMap[key] ?? []).some((it) => !(it instanceof QueryRaw) && this.constrainsRelations(entity, it))
             : Boolean(meta.relations[key]));
     }
     /**
@@ -103,9 +101,8 @@ export class MongoDialect extends AbstractDialect {
      */
     renderFilter(entity, where = {}, opts, lookups) {
         const meta = getMeta(entity);
-        const whereMap = buildQueryWhereAsMap(meta, where);
         const filter = {};
-        for (const [rawKey, rawVal] of Object.entries(whereMap)) {
+        for (const [rawKey, rawVal] of Object.entries(where)) {
             let key = rawKey;
             let val = rawVal;
             if (MongoDialect.isGroupOp(key)) {
@@ -155,8 +152,6 @@ export class MongoDialect extends AbstractDialect {
         const { join, negate } = MongoDialect.GROUP_OPS[key];
         const parts = MongoDialect.groupClauses(key, val)
             .map((filterIt) => {
-            // A `QueryRaw` here would recurse forever: `buildQueryWhereAsMap` re-wraps it as
-            // `{ $and: [raw] }`, which lands back on this branch.
             this.assertNoRaw(filterIt);
             return this.renderFilter(entity, filterIt, opts, lookups);
         })
@@ -190,7 +185,7 @@ export class MongoDialect extends AbstractDialect {
         // `withDeleted()` or `hardDelete` on the parent must not un-hide trashed rows of the target, the
         // same rule the SQL dialects' relation subqueries follow.
         const targetCondition = (sizeVal === undefined ? val : {});
-        const targetScope = this.renderFilter(relEntity, this.scopedWhereMap(relMeta, targetCondition), opts);
+        const targetScope = this.renderFilter(relEntity, this.scopedWhere(relMeta, targetCondition), opts);
         lookups.temps.push(temp);
         lookups.stages.push(this.relationLookup(meta, relOpts, relMeta, relEntity, targetScope, temp, tail, opts));
         return sizeVal === undefined
@@ -221,7 +216,7 @@ export class MongoDialect extends AbstractDialect {
     junctionLookup(meta, relOpts, relMeta, targetScope, temp, tail, opts) {
         const throughEntity = relOpts.through();
         const throughMeta = getMeta(throughEntity);
-        const junctionScope = this.renderFilter(throughEntity, this.scopedWhereMap(throughMeta, {}), opts);
+        const junctionScope = this.renderFilter(throughEntity, this.scopedWhere(throughMeta, {}), opts);
         const nested = REL_NESTED_KEY;
         // Both ends are one column here - each `$lookup` matches one field against `_id` - so both sides
         // must be sole-keyed. Sliced rather than indexed positionally: `references[1]` is the parent's
@@ -493,7 +488,7 @@ export class MongoDialect extends AbstractDialect {
             const relEntity = relOpts.entity();
             const relMeta = getMeta(relEntity);
             const temp = sortCountField(key);
-            const targetScope = this.renderFilter(relEntity, this.scopedWhereMap(relMeta, {}), opts);
+            const targetScope = this.renderFilter(relEntity, this.scopedWhere(relMeta, {}), opts);
             const tail = [{ $count: COUNT_ALIAS }];
             stages.push(this.relationLookup(meta, relOpts, relMeta, relEntity, targetScope, temp, tail, opts), {
                 $addFields: { [temp]: { $ifNull: [{ $arrayElemAt: [`$${temp}.${COUNT_ALIAS}`, 0] }, 0] } },

package/dist/mongo/mongodbQuerier.d.ts

@@ -1,6 +1,6 @@
 import type { Document, MongoClient } from 'mongodb';
 import { AbstractQuerier } from '../querier/index.js';
-import type { EntityData, ExtraOptions, IdValue, PrimaryKey, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryFilter, QueryGroupMap, QueryOptions, QuerySearch, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
+import type { EntityData, ExtraOptions, PrimaryKey, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryFilter, QueryGroupMap, QueryOptions, QuerySearch, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
 import { type ParentPartition } from '../util/index.js';
 import type { MongoDialect } from './mongoDialect.js';
 export declare class MongodbQuerier extends AbstractQuerier {
@@ -56,7 +56,7 @@ export declare class MongodbQuerier extends AbstractQuerier {
      * the floor, and skipped the relation-sort rejection {@link MongoDialect.sort} raises.
      */
     private settleIds;
-    internalInsertMany<E extends Document>(entity: Type<E>, payloads: EntityData<E>[]): Promise<IdValue<E>[]>;
+    internalInsertMany<E extends Document>(entity: Type<E>, rows: EntityData<E>[]): Promise<void>;
     internalUpdateMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, payload: UpdatePayload<E>, opts?: QueryOptions): Promise<number>;
     /**
      * `_id` is immutable, so a key the payload names can only be written on the insert branch of an
@@ -65,18 +65,16 @@ export declare class MongodbQuerier extends AbstractQuerier {
     private upsertUpdate;
     private buildConflictFilter;
     protected internalUpsertOne<E extends Document>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: EntityData<E>): Promise<{
-        firstId: PrimaryKey | undefined;
+        ids: (PrimaryKey | undefined)[];
         changes: number;
         created: boolean;
     }>;
     protected internalUpsertMany<E extends Document>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: EntityData<E>[]): Promise<{
         changes: number;
         ids?: undefined;
-        firstId?: undefined;
     } | {
         changes: number;
         ids: (PrimaryKey | undefined)[];
-        firstId: PrimaryKey | undefined;
     }>;
     protected internalDeleteMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
     get hasOpenTransaction(): boolean;

package/dist/mongo/mongodbQuerier.js

@@ -1,6 +1,6 @@
 import { COUNT_ALIAS } from '../dialect/aliases.js';
 import { hasRequiredJoin } from '../dialect/queryJoins.js';
-import { getMeta, idOf, soleIdOf } from '../entity/index.js';
+import { getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
 import { AbstractQuerier, enrichError } from '../querier/index.js';
 import { clone, getKeys, getRelationRequestSummary, getSoftDeleteValue, hasKeys, idOnlyQuery, isPagedQuery, populatesRelations, queryChildrenOf, throwNoPendingTransaction, throwPendingTransaction, withoutSoftDeleteFilter, } from '../util/index.js';
 /**
@@ -259,22 +259,17 @@ export class MongodbQuerier extends AbstractQuerier {
         // are named the same way every other driver names them.
         return (this.dialect.normalizeIds(meta, founds) || []).map((found) => idOf(meta, found));
     }
-    async internalInsertMany(entity, payloads) {
+    async internalInsertMany(entity, rows) {
         return this.timed('internalInsertMany', undefined, async () => {
-            if (!payloads?.length) {
-                return [];
-            }
-            payloads = clone(payloads);
             const meta = getMeta(entity);
-            const persistables = this.dialect.getPersistables(meta, payloads, 'onInsert');
+            const persistables = this.dialect.getPersistables(meta, rows, 'onInsert');
             const { insertedIds } = await this.execute((session) => this.collection(entity).insertMany(persistables, { session }));
             const ids = Object.values(insertedIds).map((id) => this.dialect.fromWireId(id));
             const idKey = soleIdOf(meta, 'insert');
-            for (const [index, it] of payloads.entries()) {
-                it[idKey] = ids[index];
+            for (let index = 0; index < rows.length; index++) {
+                rows[index][idKey] = ids[index];
             }
-            await this.insertRelations(entity, payloads);
-            return ids;
+            await this.insertRelations(entity, rows);
         });
     }
     async internalUpdateMany(entity, qm, payload, opts) {
@@ -332,10 +327,11 @@ export class MongodbQuerier extends AbstractQuerier {
                 includeResultMetadata: true,
                 session,
             }));
-            const firstId = this.dialect.fromWireId(res?.value?._id);
+            // Read off the document as written, which carries its `_id` on either branch.
+            const id = this.dialect.fromWireId(res?.value?._id);
             // `updatedExisting` is false when a new document was inserted (upserted).
             const created = res?.lastErrorObject?.['updatedExisting'] === false;
-            return { firstId, changes: firstId ? 1 : 0, created };
+            return { ids: [id], changes: id === undefined ? 0 : 1, created };
         });
     }
     async internalUpsertMany(entity, conflictPaths, payload) {
@@ -343,8 +339,10 @@ export class MongodbQuerier extends AbstractQuerier {
             if (!payload?.length) {
                 return { changes: 0 };
             }
-            payload = clone(payload);
             const meta = getMeta(entity);
+            // Asked before `getPersistable` fills an `onInsert` key into rows it may only update.
+            const unnamed = payload.map((row) => !namesKey(meta, row));
+            payload = clone(payload);
             const operations = payload.map((item) => {
                 const persistable = this.dialect.getPersistable(meta, item, 'onInsert');
                 const filter = this.buildConflictFilter(entity, conflictPaths, item);
@@ -359,14 +357,15 @@ export class MongodbQuerier extends AbstractQuerier {
             });
             const res = await this.execute((session) => this.collection(entity).bulkWrite(operations, { session }));
             const changes = (res.upsertedCount ?? 0) + (res.modifiedCount ?? 0);
-            // `upsertedIds` only covers newly-inserted documents, keyed by operation index: a matched and
-            // updated document's `_id` is not in the response. Read by that index rather than flattened,
-            // so each id lands on the row it belongs to and the gaps stay gaps.
-            const ids = payload.map((_, index) => {
+            // `upsertedIds` names only the documents inserted, keyed by operation index, so each lands on
+            // its own row; an updated document's `_id` is read back by the conflict fields instead.
+            const reported = payload.map((_, index) => {
                 const id = res.upsertedIds[index];
                 return id === undefined ? undefined : this.dialect.fromWireId(id);
             });
-            return { changes, ids, firstId: ids.find((id) => id !== undefined) };
+            const unplaced = reported.some((id, index) => id === undefined && unnamed[index]);
+            const found = unplaced ? await this.idsByConflict(entity, conflictPaths, payload) : [];
+            return { changes, ids: reported.map((id, index) => id ?? found[index]) };
         });
     }
     async internalDeleteMany(entity, qm, opts = {}) {

package/dist/mssql/mssqlDialect.d.ts

@@ -1,5 +1,5 @@
 import { MergeSqlDialect } from '../dialect/mergeSqlDialect.js';
-import type { DialectFeatures, EntityMeta, FieldOptions, InsertIdSource, Query, QueryContext, QueryOptions, QueryPager, QuerySizeComparisonOps, Type } from '../type/index.js';
+import type { DialectFeatures, EntityMeta, FieldOptions, InsertIdSource, Query, QueryContext, QueryOptions, QueryPager, QuerySizeComparisonOps, Type, VectorDistance, VectorMetric } from '../type/index.js';
 /**
  * Microsoft SQL Server 2017 and up - the floor `STRING_AGG` sets, every other construct here being
  * 2016 or older.
@@ -30,6 +30,8 @@ export declare class MsSqlDialect extends MergeSqlDialect {
     readonly maxBindValues = 2100;
     /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
     readonly returningPosition = "after-target";
+    /** Microsoft documents no row order for a `MERGE ... OUTPUT`. */
+    readonly upsertReturningOrdered = false;
     readonly insertIdSource: InsertIdSource;
     /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
     protected readonly mergeTargetHint = " WITH (HOLDLOCK)";
@@ -89,6 +91,17 @@ export declare class MsSqlDialect extends MergeSqlDialect {
      * `uuidv7()` is emitted on. It is a predicate rather than a value, so it stands alone.
      */
     protected regexCondition(operand: string, placeholder: string): string;
+    /**
+     * `VECTOR_DISTANCE('cosine', a, b)`, one function taking the metric by name; `dot` is the negated
+     * inner product, pgvector's `<#>` convention. Exact search, as on sqlite-vec: 2025's DiskANN index
+     * is a preview feature, and only `VECTOR_SEARCH` reads it, never an `ORDER BY VECTOR_DISTANCE`.
+     */
+    readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
+    /**
+     * `VECTOR_DISTANCE` refuses the `nvarchar` a vector binds as, so it is cast - to the value's own
+     * length, which is its dimension. A write would convert implicitly, and shares the cast anyway.
+     */
+    protected appendVectorValue(ctx: QueryContext, value: readonly unknown[]): void;
     /** There is no `CREATE SCHEMA IF NOT EXISTS`, and `CREATE SCHEMA` has to be alone in its batch. */
     createSchemaSql(schema: string): string;
     /** The estimate the engine already keeps per partition, live without a stats refresh. */

package/dist/mssql/mssqlDialect.js

@@ -27,22 +27,16 @@ export class MsSqlDialect extends MergeSqlDialect {
         indexIfNotExists: false,
         schemas: true,
         dropTableCascade: false,
-        // `sp_rename` is a stored procedure, not DDL, so a rename is refused by name rather than emitted
-        // as an `ALTER TABLE` the parser rejects.
-        renameColumn: false,
         foreignKeyAlter: true,
         primaryKeyAlter: true,
         generatedColumnAdd: true,
         // Extended properties are out-of-band metadata with their own procedures, not comments.
         commentSyntax: 'none',
         vectorIndexRequiresNotNull: false,
-        vectorSupportsLength: false,
+        vectorSupportsLength: true,
         supportsTimestamptz: false,
         stringSizing: 'varchar',
         supportsUnsigned: false,
-        // Error 1785: the constraint is refused at create time, so any diamond-shaped schema would fail
-        // to build at all rather than misbehave on write.
-        multipleCascadePaths: false,
         serverSideCursors: false,
     };
     dialectName = 'mssql';
@@ -70,6 +64,8 @@ export class MsSqlDialect extends MergeSqlDialect {
     maxBindValues = 2100;
     /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
     returningPosition = 'after-target';
+    /** Microsoft documents no row order for a `MERGE ... OUTPUT`. */
+    upsertReturningOrdered = false;
     insertIdSource = 'returning';
     /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
     mergeTargetHint = ' WITH (HOLDLOCK)';
@@ -188,6 +184,25 @@ export class MsSqlDialect extends MergeSqlDialect {
     regexCondition(operand, placeholder) {
         return `REGEXP_LIKE(${operand}, ${placeholder})`;
     }
+    /**
+     * `VECTOR_DISTANCE('cosine', a, b)`, one function taking the metric by name; `dot` is the negated
+     * inner product, pgvector's `<#>` convention. Exact search, as on sqlite-vec: 2025's DiskANN index
+     * is a preview feature, and only `VECTOR_SEARCH` reads it, never an `ORDER BY VECTOR_DISTANCE`.
+     */
+    vectorMetrics = new Map([
+        ['cosine', { fn: 'VECTOR_DISTANCE', metricArg: 'cosine' }],
+        ['l2', { fn: 'VECTOR_DISTANCE', metricArg: 'euclidean' }],
+        ['inner', { fn: 'VECTOR_DISTANCE', metricArg: 'dot' }],
+    ]);
+    /**
+     * `VECTOR_DISTANCE` refuses the `nvarchar` a vector binds as, so it is cast - to the value's own
+     * length, which is its dimension. A write would convert implicitly, and shares the cast anyway.
+     */
+    appendVectorValue(ctx, value) {
+        ctx.append('CAST(');
+        super.appendVectorValue(ctx, value);
+        ctx.append(` AS VECTOR(${value.length}))`);
+    }
     /** There is no `CREATE SCHEMA IF NOT EXISTS`, and `CREATE SCHEMA` has to be alone in its batch. */
     createSchemaSql(schema) {
         const literal = escapeSingleQuotes(schema);