@mikro-orm/knex 6.2.9-dev.12 → 6.2.9-dev.14

package/AbstractSqlDriver.d.ts

@@ -28,6 +28,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    /**
+     * Fast comparison for collection snapshots that are represented by PK arrays.
+     * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
+     * Always expects the same length of the arrays, since we only compare PKs of the same entity type.
+     */
+    private comparePrimaryKeyArrays;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;

package/AbstractSqlDriver.js

@@ -631,6 +631,26 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
+    /**
+     * Fast comparison for collection snapshots that are represented by PK arrays.
+     * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
+     * Always expects the same length of the arrays, since we only compare PKs of the same entity type.
+     */
+    comparePrimaryKeyArrays(a, b) {
+        for (let i = a.length; i-- !== 0;) {
+            if (['number', 'string', 'bigint', 'boolean'].includes(typeof a[i])) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            else {
+                if (!core_1.Utils.equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     async syncCollections(collections, options) {
         const groups = {};
         for (const coll of collections) {
@@ -638,7 +658,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const meta = wrapped.__meta;
             const pks = wrapped.getPrimaryKeys(true);
             const snap = coll.getSnapshot();
-            const includes = (arr, item) => !!arr.find(i => core_1.Utils.equals(i, item));
+            const includes = (arr, item) => !!arr.find(i => this.comparePrimaryKeyArrays(i, item));
             const snapshot = snap ? snap.map(item => (0, core_1.helper)(item).getPrimaryKeys(true)) : [];
             const current = coll.getItems(false).map(item => (0, core_1.helper)(item).getPrimaryKeys(true));
             const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
@@ -648,8 +668,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             // wrong order if we just delete and insert to the end (only owning sides can have fixed order)
             if (coll.property.owner && coll.property.fixedOrder && !equals && Array.isArray(deleteDiff)) {
                 deleteDiff.length = insertDiff.length = 0;
-                deleteDiff.push(...snapshot);
-                insertDiff.push(...current);
+                for (const item of snapshot) {
+                    deleteDiff.push(item);
+                }
+                for (const item of current) {
+                    insertDiff.push(item);
+                }
             }
             if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;

package/PivotCollectionPersister.d.ts

@@ -8,6 +8,7 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private readonly platform;
     private readonly inserts;
     private readonly deletes;
+    private readonly batchSize;
     private order;
     constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: any, schema?: string | undefined);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;

package/PivotCollectionPersister.js

@@ -44,6 +44,7 @@ class PivotCollectionPersister {
     platform;
     inserts = new Map();
     deletes = new Map();
+    batchSize;
     order = 0;
     constructor(meta, driver, ctx, schema) {
         this.meta = meta;
@@ -51,6 +52,7 @@ class PivotCollectionPersister {
         this.ctx = ctx;
         this.schema = schema;
         this.platform = this.driver.getPlatform();
+        this.batchSize = this.driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks) {
         if (insertDiff.length) {
@@ -90,13 +92,18 @@ class PivotCollectionPersister {
     }
     async execute() {
         if (this.deletes.size > 0) {
-            const knex = this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write')
-                .withSchema(this.schema)
-                .getKnex();
-            for (const item of this.deletes.values()) {
-                knex.orWhere(item.getCondition());
+            const deletes = [...this.deletes.values()];
+            for (let i = 0; i < deletes.length; i += this.batchSize) {
+                const chunk = deletes.slice(i, i + this.batchSize);
+                const cond = { $or: [] };
+                for (const item of chunk) {
+                    cond.$or.push(item.getCondition());
+                }
+                await this.driver.nativeDelete(this.meta.className, cond, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                });
             }
-            await this.driver.execute(knex.delete());
         }
         if (this.inserts.size === 0) {
             return;
@@ -108,12 +115,15 @@ class PivotCollectionPersister {
         items = items.filter(i => i);
         /* istanbul ignore else */
         if (this.platform.allowsMultiInsert()) {
-            await this.driver.nativeInsertMany(this.meta.className, items, {
-                ctx: this.ctx,
-                schema: this.schema,
-                convertCustomTypes: false,
-                processCollections: false,
-            });
+            for (let i = 0; i < items.length; i += this.batchSize) {
+                const chunk = items.slice(i, i + this.batchSize);
+                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                    convertCustomTypes: false,
+                    processCollections: false,
+                });
+            }
         }
         else {
             await core_1.Utils.runSerial(items, item => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.9-dev.12",
+  "version": "6.2.9-dev.14",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.2.8"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.9-dev.12"
+    "@mikro-orm/core": "6.2.9-dev.14"
   }
 }