Function nativeUpdateMany

packages/sql/src/AbstractSqlDriver.ts:1441–1650

(
    entityName: EntityName<T>,
    where: FilterQuery<T>[],
    data: EntityDictionary<T>[],
    options: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T> = {},
    transform?: (sql: string, params: any[]) => string,
  )

  }

  override async nativeUpdateMany<T extends object>(
    entityName: EntityName<T>,
    where: FilterQuery<T>[],
    data: EntityDictionary<T>[],
    options: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T> = {},
    transform?: (sql: string, params: any[]) => string,
  ): Promise<QueryResult<T>> {
    options.processCollections ??= true;
    options.convertCustomTypes ??= true;
    const meta = this.metadata.get<T>(entityName);

    if (options.upsert) {
      const uniqueFields =
        options.onConflictFields ??
        ((Utils.isPlainObject(where[0])
          ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key))
          : meta.primaryKeys) as (keyof T)[]);
      const qb = this.createQueryBuilder<T>(
        entityName,
        options.ctx,
        'write',
        options.convertCustomTypes,
        options.loggerContext,
      ).withSchema(this.getSchemaName(meta, options));
      qb.setAbortOptions(pickAbortOptions(options));
      const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
      qb.insert(data as T[])
        .onConflict(uniqueFields as any)
        .returning(returning as any);

      if (!options.onConflictAction || options.onConflictAction === 'merge') {
        const fields = getOnConflictFields(meta, data[0], uniqueFields, options);
        qb.merge(fields as any);
      }

      if (options.onConflictAction === 'ignore') {
        qb.ignore();
      }

      if (options.onConflictWhere) {
        qb.where(options.onConflictWhere as any);
      }

      return this.rethrow(qb.execute('run', false));
    }

    const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
    const keys = new Set<EntityKey<T>>();
    const fields = new Set<string>();
    const returning = new Set<EntityKey<T>>();

    for (const row of data) {
      for (const k of Utils.keys(row)) {
        keys.add(k as EntityKey<T>);

        if (isRaw(row[k])) {
          returning.add(k);
        }