Function createMany

packages/core/fumadb/src/adapters/drizzle/query.ts:583–626

(table, values)

    },

    async createMany(table, values) {
      if (values.length === 0) return [];
      const idField = table.getIdColumn().names.drizzle;
      const drizzleTable = toDrizzle(table);
      values = values.map((v) => mapValues(v, table));
      const columnsPerRow = Math.max(1, Object.keys(values[0]!).length);
      const batchSize = parameterBoundedBatchSize(table, columnsPerRow, 0, maxBoundParameters);
      const batches: (typeof values)[] = [];
      for (let i = 0; i < values.length; i += batchSize) {
        batches.push(values.slice(i, i + batchSize));
      }

      const insertBatches = async (handle: typeof db): Promise<{ _id: unknown }[]> => {
        if (provider === "sqlite" || provider === "postgresql") {
          const out: { _id: unknown }[] = [];
          for (const batch of batches) {
            out.push(
              ...(await (handle as unknown as P_DBType)
                .insert(drizzleTable as unknown as P_TableType)
                .values(batch)
                .returning({
                  _id: (drizzleTable as unknown as P_TableType)[idField],
                })),
            );
          }
          return out;
        }

        const results: Record<string, unknown>[] = [];
        for (const batch of batches) {
          results.push(...(await handle.insert(drizzleTable).values(batch).$returningId()));
        }
        return results.map((result) => ({ _id: result[idField] }));
      };

      if (batches.length === 1) return insertBatches(db);
      // One logical insert split into parameter-bounded statements must stay
      // atomic: a later batch's constraint failure rolls back the earlier
      // batches. (Engines without interactive transactions auto-commit each
      // statement; `createMany` needs the inserted ids back, which the native
      // batch API's result shape does not guarantee across drivers, so those
      // engines keep sequential statements — their documented constraint.)
      return runAtomically(insertBatches);
    },

    async deleteMany(table, v) {
      const drizzleTable = toDrizzle(table);