turbine-orm 0.90.2 → 0.91.0

package/dist/cjs/query/writes.js

@@ -45,6 +45,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.COUNT_ONLY = void 0;
 exports.coerceWriteValue = coerceWriteValue;
 exports.buildReselectByWhere = buildReselectByWhere;
 exports.buildCreate = buildCreate;
@@ -62,6 +63,7 @@ exports.buildUpdateMany = buildUpdateMany;
 exports.buildDeleteMany = buildDeleteMany;
 exports.piiColumns = piiColumns;
 exports.piiFields = piiFields;
+exports.isCountOnly = isCountOnly;
 exports.writeProjectionCacheSegment = writeProjectionCacheSegment;
 exports.applyUpdatedAtColumns = applyUpdatedAtColumns;
 exports.writeReturningColumns = writeReturningColumns;
@@ -891,12 +893,17 @@ function buildCreateMany(qi, args, overBindLimit = 'refuse', projection) {
  * builder (`skipGlobalFilters`), which a concurrent call could change across
  * an await.
  */
-function planCreateMany(qi, args, projection) {
+function planCreateMany(qi, args, projection, canSplit = true) {
     const prepared = prepareCreateMany(qi, args, projection);
     if ('deferred' in prepared)
         return { chunks: [prepared.deferred], rowsPerChunk: args.data.length };
     const rows = prepared.rowValues;
-    const size = rowsPerStatement(qi, prepared);
+    const { most, chunk } = statementSizes(qi, prepared);
+    // Rows that cannot be told apart across statements (refused below past one),
+    // and a call whose executor cannot run several statements in one
+    // transaction (`canSplit`), take the fewest statements the engine allows;
+    // the rest are split at the size the engine runs fastest.
+    const size = !canSplit || (prepared.conflict && !prepared.identity) ? most : chunk;
     if (rows.length <= size) {
         return { chunks: [emitCreateMany(qi, prepared, rows, 'allow', true)], rowsPerChunk: size };
     }
@@ -924,12 +931,19 @@ function prepareCreateMany(qi, args, projection) {
     // The data-independent half of onConflict is checked before the empty-data
     // shortcut, so a call is never valid with no rows and invalid with some.
     const conflict = args.onConflict === undefined ? null : resolveConflictPlan(qi, args);
+    const countOnly = isCountOnly(projection);
+    // Before the empty-data shortcut too, so the refusal never depends on the rows.
+    if (countOnly && args.skipDuplicates && qi.dialect.capabilities.skipDuplicatesCountsSkipped) {
+        throw new errors_js_1.UnsupportedFeatureError('createMany({ skipDuplicates: true, returning: false })', qi.dialect.name, 'It counts a skipped row as written, so the count would include the rows skipped. Without ' +
+            'returning: false the call writes the same rows and reports no count.');
+    }
     if (args.data.length === 0) {
         return {
             deferred: {
-                sql: `SELECT * FROM ${qt} WHERE false`,
+                // `1 = 0`, not `false`: T-SQL has no boolean literal in a condition.
+                sql: `SELECT * FROM ${qt} WHERE 1 = 0`,
                 params: [],
-                transform: () => [],
+                transform: () => (countOnly ? { count: 0 } : []),
                 tag: `${qi.table}.createMany`,
             },
         };
@@ -958,7 +972,9 @@ function prepareCreateMany(qi, args, projection) {
             deferred: {
                 sql: buildDefaultValuesInsert(qi, args.data.length, args.skipDuplicates, projection),
                 params: [],
-                transform: (result) => result.rows.map((row) => parseWriteRow(qi, row, projection)),
+                transform: (result) => countOnly
+                    ? countOf(result)
+                    : result.rows.map((row) => parseWriteRow(qi, row, projection)),
                 tag: `${qi.table}.createMany`,
             },
         };
@@ -1036,32 +1052,40 @@ function emitCreateMany(qi, prepared, rowValues, overBindLimit, first) {
     return {
         sql: built.sql,
         params: built.params,
-        transform: (result) => result.rows.map((row) => parseWriteRow(qi, row, projection)),
+        transform: (result) => isCountOnly(projection)
+            ? countOf(result)
+            : result.rows.map((row) => parseWriteRow(qi, row, projection)),
         tag: `${qi.table}.createMany`,
     };
 }
 /**
- * Rows one `createMany` statement may carry: the most that keep its bind
- * parameters within the engine's limit and, on SQL Server, its rows within
- * the 1000 a plain `INSERT ... VALUES` accepts. The parameter cost is measured
- * from one-row and two-row builds, which separates the per-row parameters from
- * the ones bound once per statement (an onConflict update's values); the
- * PostgreSQL UNNEST form binds one array per column, so its rows never run out.
+ * Rows one `createMany` statement may carry. `most`: the most that keep its
+ * bind parameters within the engine's limit and, on SQL Server, its rows
+ * within the 1000 a plain `INSERT ... VALUES` accepts. `chunk`: the same under
+ * the engine's `chunkBindParameters`, the size a call that runs as several
+ * statements is split at. The parameter cost is measured from one-row and
+ * two-row builds, which separates the per-row parameters from the ones bound
+ * once per statement (an onConflict update's values); the PostgreSQL UNNEST
+ * form binds one array per column, so its rows never run out.
  */
-function rowsPerStatement(qi, prepared) {
+function statementSizes(qi, prepared) {
     // An onConflict statement (SQL Server's MERGE) reads its rows as a derived
     // table, which the plain INSERT ... VALUES row cap does not bind.
     const cap = prepared.conflict ? Infinity : qi.dialect.capabilities.maxInsertRows;
-    const limit = (0, dialect_js_1.maxBindParameters)(qi.dialect);
+    const limit = (0, dialect_js_1.maxBindParameters)(qi.dialect) ?? Infinity;
+    // A dialect written before the key existed has none, and splits at its limit.
+    const preferred = qi.dialect.capabilities.chunkBindParameters;
+    const chunkLimit = typeof preferred === 'number' && preferred < limit ? preferred : limit;
     const rows = prepared.rowValues;
-    if (limit === undefined || rows.length < 2)
-        return cap;
+    if (!Number.isFinite(chunkLimit) || rows.length < 2)
+        return { most: cap, chunk: cap };
     const one = emitCreateMany(qi, prepared, rows.slice(0, 1), 'allow', true).params.length;
     const perRow = emitCreateMany(qi, prepared, rows.slice(0, 2), 'allow', true).params.length - one;
     if (perRow <= 0)
-        return cap;
+        return { most: cap, chunk: cap };
     const fixed = Math.max(0, one - perRow);
-    return Math.max(1, Math.min(cap, Math.floor((limit - fixed) / perRow)));
+    const fit = (bound) => Number.isFinite(bound) ? Math.max(1, Math.min(cap, Math.floor((bound - fixed) / perRow))) : cap;
+    return { most: fit(limit), chunk: fit(chunkLimit) };
 }
 const ON_CONFLICT_KEYS = new Set(['target', 'update', 'where', 'ignore']);
 /**
@@ -1422,6 +1446,11 @@ function buildBulkUpsert(qi, conflict, insert, columns, overBindLimit, projectio
         transform: (result) => {
             if (identity)
                 assertEachRowWrittenOnce(qi, conflict, identity, result.rows, first);
+            // COUNT_ONLY: the rows back are the identity columns (or none at all when
+            // the written rows cannot be identified), counted and never returned.
+            if (isCountOnly(projection)) {
+                return (identity ? { count: result.rows.length } : countOf(result));
+            }
             const rows = result.rows.map((row) => parseWriteRow(qi, row, projection));
             if (identity && identity.added.length > 0) {
                 for (const row of rows)
@@ -2052,6 +2081,21 @@ function piiFields(_qi, meta) {
     }
     return out;
 }
+/**
+ * The projection of `createMany({ returning: false })`: no column. A plain
+ * insert then sends no RETURNING / OUTPUT and reports its row count; an
+ * onConflict call returns only its identity columns (see
+ * {@link conflictIdentity}), which the count is taken from.
+ */
+exports.COUNT_ONLY = Object.freeze({ columns: Object.freeze([]) });
+/** True for {@link COUNT_ONLY} (or any projection naming no column). */
+function isCountOnly(projection) {
+    return projection !== undefined && projection.columns.length === 0;
+}
+/** `{ count }` from a write that returned no rows to count: the engine's row count. */
+function countOf(result) {
+    return { count: typeof result.rowCount === 'number' ? result.rowCount : result.rows.length };
+}
 /**
  * The write-SQL cache segment for a projection. EMPTY for the default shape, so
  * every existing key is byte-identical; a projected statement differs only in
@@ -2147,6 +2191,9 @@ function writeReturningColumns(qi, projection) {
  */
 function writeReselectSelection(qi, projection) {
     const cols = writeReturningColumns(qi, projection);
+    // COUNT_ONLY: the re-read is counted, not returned, so it reads no column.
+    if (cols !== '*' && cols.length === 0)
+        return '1';
     return cols === '*' ? '*' : cols.join(', ');
 }
 /**

package/dist/cjs/sqlite.js

@@ -913,12 +913,16 @@ exports.sqliteDialect = {
         // The default SQLITE_MAX_VARIABLE_NUMBER.
         maxBindParameters: 32766,
         maxInsertRows: Number.POSITIVE_INFINITY,
+        // Measured: 40,000 rows insert 70 to 140 times faster in statements of 250
+        // parameters than of 32,766 (named-parameter lookup is a linear search).
+        chunkBindParameters: 250,
         upsertConflictTarget: 'explicit',
         setClauseOrder: 'snapshot',
         reselectLocksRows: false,
         integerDivision: '/',
         updateExpressions: true,
         bulkUpsertAppliesRepeatedKeys: true,
+        skipDuplicatesCountsSkipped: false,
         readOnlyTransactions: false,
         connectionParameters: false,
         backendCancel: false,
@@ -1129,6 +1133,8 @@ exports.sqliteDialect = {
             (boolean ? 'Write true or false.' : 'Write a number, or a string holding one, such as "12.5".'));
     },
     buildReturningClause(selection = '*') {
+        if (selection !== '*' && selection.length === 0)
+            return '';
         return ` RETURNING ${selection === '*' ? '*' : selection.join(', ')}`;
     },
     buildInsertStatement(input) {

package/dist/dialect.d.ts

@@ -501,6 +501,17 @@ export interface EngineCapabilities {
      * not bound by it.
      */
     readonly maxInsertRows: number;
+    /**
+     * The most bind parameters each statement of a `createMany` that runs as
+     * several statements carries: at most `maxBindParameters`, and lower where
+     * an engine slows faster than linearly with a statement's size. SQLite
+     * finds each named parameter by a linear search, at prepare and at bind, so
+     * 40,000 six-column rows took 141 s in statements of 32,766 parameters and
+     * 1 s in statements of 250. A call whose rows cannot be told apart
+     * across statements, or on a pool with no `connect()`, is not split below
+     * `maxBindParameters` (see `planCreateMany`).
+     */
+    readonly chunkBindParameters: number;
     /**
      * What a single-statement upsert conflicts on. `'explicit'`: the conflict
      * target it names. `'any-unique-key'`: whichever unique key collides first
@@ -531,6 +542,16 @@ export interface EngineCapabilities {
      * it afterwards, so the statement runs in a transaction it can roll back.
      */
     readonly bulkUpsertAppliesRepeatedKeys: boolean;
+    /**
+     * A `skipDuplicates` insert reports a skipped row as affected, so its row
+     * count cannot be the rows it inserted. MySQL: its skip is a no-op
+     * `ON DUPLICATE KEY UPDATE`, which under `CLIENT_FOUND_ROWS` (mysql2's
+     * default) counts a matched row, and a one-row statement's result carries no
+     * `info` to subtract the duplicates from. `createMany` refuses
+     * `skipDuplicates` with `returning: false` here (E017). False on an engine
+     * that never runs a skip.
+     */
+    readonly skipDuplicatesCountsSkipped: boolean;
     /** `$transaction({ readOnly: true })`: `READ ONLY` after the dialect's BEGIN. Else E017. */
     readonly readOnlyTransactions: boolean;
     /**
@@ -817,7 +838,11 @@ export interface Dialect {
     readonly explainQuery?: {
         prefix: string;
     };
-    /** Build a dialect-specific RETURNING clause. Return an empty string when unsupported. */
+    /**
+     * Build a dialect-specific RETURNING clause. Return an empty string when
+     * unsupported, and for an empty column list (a write that returns no column,
+     * `createMany({ returning: false })`).
+     */
     buildReturningClause(selection?: ReturningSelection): string;
     /** Build a single-row INSERT statement. Inputs are SQL-ready quoted fragments. */
     buildInsertStatement(input: InsertStatementInput): string;

package/dist/dialect.js

@@ -102,12 +102,14 @@ export const postgresDialect = {
         // Counted in a 16-bit field.
         maxBindParameters: 65535,
         maxInsertRows: Number.POSITIVE_INFINITY,
+        chunkBindParameters: 65535,
         upsertConflictTarget: 'explicit',
         setClauseOrder: 'snapshot',
         reselectLocksRows: false,
         integerDivision: '/',
         updateExpressions: true,
         bulkUpsertAppliesRepeatedKeys: false,
+        skipDuplicatesCountsSkipped: false,
         readOnlyTransactions: true,
         connectionParameters: true,
         backendCancel: true,
@@ -185,6 +187,8 @@ export const postgresDialect = {
         return `COALESCE((${subquery}), ${fallback})`;
     },
     buildReturningClause(selection = '*') {
+        if (selection !== '*' && selection.length === 0)
+            return '';
         return ` RETURNING ${selection === '*' ? '*' : selection.join(', ')}`;
     },
     buildInsertStatement(input) {

package/dist/index.d.ts

@@ -47,9 +47,9 @@ export { HttpJsonSink, type HttpJsonSinkOptions, type MetricsFlushBatch, type Me
 export { executePipeline, type PipelineOptions, type PipelineResults, pipelineSupported } from './pipeline.js';
 export { fingerprintPrismaSchema } from './prisma-schema-fingerprint.js';
 export { type CaseArm, type ExprOperand, expr, type NumericOperand } from './query/expr.js';
-export { type AggregateArgs, type AggregateResult, type ArrayFilter, AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_COUNT_BATCH_MIN_PARENT_ROWS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, type ColumnRef, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateDataInput, type CreateManyArgs, col, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GlobalFilters, type GroupByAggregateSpec, type GroupByArgs, type GroupByDistinctOn, type GroupByResult, type HavingClause, type JsonEncoding, type JsonFilter, type JsonPathAggregateTarget, type JsonPathGroupKey, type JsonPathOrderBy, type JsonValue, jsonValue, type MiddlewareFn, type NestedCreateOp, type NestedUpdateOp, type NestedUpdateOpItem, type NestedUpsertOpItem, type OmitResult, type OrderByClause, type OrderByObject, type OrderBySpec, type OrderDirection, type PrivilegeOption, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type RelationLoadStrategy, type RelationOrderBy, type RelationOrderByChain, type RelationPickBy, type RelationPickOrderBy, type SelectResult, type SkipGlobalFilters, type TemporalInfinityReading, type TextSearchFilter, type TypedWithClause, UNSAFE, type Unsafe, type UpdateArgs, type UpdateDataInput, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type VectorDistanceFilter, type VectorFilter, type VectorMetric, type VectorOrderBy, type VectorOrderByDistance, type WhereClause, type WhereOperator, type WhereValue, type WithClause, type WithOptions, type WithOrderByObject, type WithResult, } from './query/index.js';
+export { type AggregateArgs, type AggregateResult, type ArrayFilter, AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_COUNT_BATCH_MIN_PARENT_ROWS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, type ColumnRef, type ConnectOrCreateOp, type CountArgs, type CreateArgs, type CreateDataInput, type CreateManyArgs, type CreateManyCount, type CreateManyResult, col, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FieldResult, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GlobalFilters, type GroupByAggregateSpec, type GroupByArgs, type GroupByDistinctOn, type GroupByResult, type HavingClause, type JsonEncoding, type JsonFilter, type JsonPathAggregateTarget, type JsonPathGroupKey, type JsonPathOrderBy, type JsonValue, jsonValue, type MiddlewareFn, type NestedCreateOp, type NestedUpdateOp, type NestedUpdateOpItem, type NestedUpsertOpItem, type OmitResult, type OrderByClause, type OrderByObject, type OrderBySpec, type OrderDirection, type PrivilegeOption, type QueryEvent, type QueryEventListener, QueryInterface, type QueryResult, type RelationDescriptor, type RelationFilter, type RelationLoadStrategy, type RelationOrderBy, type RelationOrderByChain, type RelationPickBy, type RelationPickOrderBy, type SelectResult, type SkipGlobalFilters, type TemporalInfinityReading, type TextSearchFilter, type TypedWithClause, UNSAFE, type Unsafe, type UpdateArgs, type UpdateDataInput, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type VectorDistanceFilter, type VectorFilter, type VectorMetric, type VectorOrderBy, type VectorOrderByDistance, type WhereClause, type WhereOperator, type WhereValue, type WithClause, type WithOptions, type WithOrderByObject, type WithResult, } from './query/index.js';
 export type { SqlCommentOptions } from './query/sql-comment.js';
-export type { AggregateResultOf, ConflictTarget, ConflictUpdateData, CreateManyOnConflict, DefaultInputTypes, ExcludedRef, GlobalFilter, NestedToOneCreateOp, NestedToOneUpdateOp, OptionalInput, PercentileMethod, PercentileSpec, RelationKind, RowLock, RowLockMode, SqlExpr, SqlExprKind, TableInputTypes, } from './query/types.js';
+export type { AggregateResultOf, ConflictTarget, ConflictUpdateData, CreateManyOnConflict, DefaultInputTypes, ExcludedRef, FieldPercentiles, GlobalFilter, NestedToOneCreateOp, NestedToOneUpdateOp, OptionalInput, PercentileArgs, PercentileExprSpec, PercentileKeysChecked, PercentileMethod, PercentileSpec, RelationKind, RowLock, RowLockMode, SqlExpr, SqlExprKind, TableInputTypes, } from './query/types.js';
 export { MAX_QUERY_TAG_LENGTH, RAW_QUERY_MODEL } from './query-events.js';
 export { type ActiveSubscription, type ListenOptions, type ListenReconnectOptions, type NotificationHandler, type Subscription, validateChannel, } from './realtime.js';
 export type { CheckMetadata, ColumnMetadata, IndexMetadata, PrismaCompatMap, PrismaModelMap, PrismaRelationMap, PrismaSchemaSource, ReferentialAction, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';

package/dist/mssql.js

@@ -633,6 +633,7 @@ export const mssqlDialect = {
         // The limit the driver can actually send (see MSSQL_MAX_PARAMS), not 2100.
         maxBindParameters: MSSQL_MAX_PARAMS,
         maxInsertRows: MSSQL_MAX_INSERT_ROWS,
+        chunkBindParameters: MSSQL_MAX_PARAMS,
         upsertConflictTarget: 'explicit',
         setClauseOrder: 'snapshot',
         reselectLocksRows: false,
@@ -640,6 +641,7 @@ export const mssqlDialect = {
         updateExpressions: true,
         // MERGE refuses a target row matched twice (error 8672).
         bulkUpsertAppliesRepeatedKeys: false,
+        skipDuplicatesCountsSkipped: false,
         readOnlyTransactions: false,
         connectionParameters: false,
         backendCancel: false,

package/dist/mysql.js

@@ -698,6 +698,7 @@ export const mysqlDialect = {
         // Counted in a 16-bit field.
         maxBindParameters: 65535,
         maxInsertRows: Number.POSITIVE_INFINITY,
+        chunkBindParameters: 65535,
         upsertConflictTarget: 'any-unique-key',
         setClauseOrder: 'left-to-right',
         reselectLocksRows: true,
@@ -705,6 +706,8 @@ export const mysqlDialect = {
         updateExpressions: true,
         // Caught by the onConflict re-read, which runs in the reselect transaction.
         bulkUpsertAppliesRepeatedKeys: true,
+        // A skipped row is a no-op ON DUPLICATE KEY UPDATE, counted under FOUND_ROWS.
+        skipDuplicatesCountsSkipped: true,
         readOnlyTransactions: true,
         connectionParameters: false,
         backendCancel: false,

package/dist/powdb.js

@@ -116,12 +116,14 @@ export const powdbDialect = {
         structuredValueColumns: 'scalars',
         maxBindParameters: Number.POSITIVE_INFINITY,
         maxInsertRows: Number.POSITIVE_INFINITY,
+        chunkBindParameters: Number.POSITIVE_INFINITY,
         upsertConflictTarget: 'explicit',
         setClauseOrder: 'snapshot',
         reselectLocksRows: false,
         integerDivision: '/',
         updateExpressions: false,
         bulkUpsertAppliesRepeatedKeys: false,
+        skipDuplicatesCountsSkipped: false,
         readOnlyTransactions: false,
         connectionParameters: false,
         backendCancel: false,

package/dist/powql.d.ts

@@ -37,7 +37,7 @@
 import type { PowdbPool } from './powdb.js';
 import type { MiddlewareFn, QueryInterfaceOptions } from './query/index.js';
 import type { TableClient } from './query/table-client.js';
-import type { AggregateArgs, AggregateResultOf, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FieldResult, FindManyArgs, FindUniqueArgs, GroupByArgs, GroupByResult, OptionalInput, QueryResult, TypedWithClause, UpdateArgs, UpdateManyArgs, UpsertArgs } from './query/types.js';
+import type { AggregateArgs, AggregateResultOf, CountArgs, CreateArgs, CreateManyArgs, CreateManyResult, DeleteArgs, DeleteManyArgs, FieldResult, FindManyArgs, FindUniqueArgs, GroupByArgs, GroupByResult, OptionalInput, QueryResult, TypedWithClause, UpdateArgs, UpdateManyArgs, UpsertArgs } from './query/types.js';
 import { type SchemaMetadata } from './schema.js';
 /**
  * Max values one `in` / `notIn` on a PowDB-native `datetime` column may carry.
@@ -1146,7 +1146,10 @@ export declare class PowqlInterface<T extends object = Record<string, unknown>>
      * byte-identical PowQL.
      */
     private assertUniformCreateManyRows;
-    createMany<S extends Record<string, boolean> | undefined = undefined, O extends Record<string, boolean> | undefined = undefined>(args: CreateManyArgs<T, OptionalInput<T>, S, O>): Promise<FieldResult<T, S, O>[]>;
+    createMany<S extends Record<string, boolean> | undefined = undefined, O extends Record<string, boolean> | undefined = undefined, C extends boolean | undefined = undefined>(args: CreateManyArgs<T, OptionalInput<T>, S, O, C>): Promise<CreateManyResult<FieldResult<T, S, O>, C>>;
+    /** `returning: false` validated: a boolean, and not combined with a projection. */
+    private createManyCountOnly;
+    private insertMany;
     update<S extends Record<string, boolean> | undefined = undefined, O extends Record<string, boolean> | undefined = undefined>(args: UpdateArgs<T, NoRelations, S, O>): Promise<FieldResult<T, S, O>>;
     updateMany(args: UpdateManyArgs<T>): Promise<{
         count: number;

package/dist/powql.js

@@ -3857,35 +3857,56 @@ export class PowqlInterface {
     async createMany(args) {
         args = this.normalizeArgs(args);
         return this.withMiddleware('createMany', args, async () => {
-            if (args.onConflict !== undefined) {
-                throw new UnsupportedFeatureError('createMany({ onConflict })', 'powdb', "PowQL's upsert statement takes one row. Call upsert() per row inside $transaction.");
-            }
-            // Validated as every engine validates it; it acts only on onConflict's
-            // update, which is refused above.
-            resolveSkipGlobalFilters(args.skipGlobalFilters);
-            if (args.skipDuplicates) {
-                // PowQL's `insert … returning` has no conflict clause, so there is no
-                // faithful skip-duplicates form; refuse rather than silently insert.
-                throw new UnsupportedFeatureError('createMany({ skipDuplicates: true })', 'powdb', 'PowQL insert has no ON CONFLICT DO NOTHING equivalent, filter duplicates before inserting.');
-            }
-            // Resolved before the write, so a bad projection writes nothing.
-            const plan = this.writeReturnPlan(args);
-            const supplied = args.data.map((d) => this.applyPkDefault(d));
-            if (!supplied.length)
-                return [];
-            // Uniformity is judged on what the caller supplied, as the SQL engines
-            // judge it; defaults are then filled per row.
-            this.assertUniformCreateManyRows(supplied);
-            const inputs = supplied.map((d) => this.applyColumnDefaults(d));
-            const params = [];
-            const tuples = inputs.map((d) => {
-                const assigns = this.scalarData(d);
-                return `{ ${assigns.map((a) => `${quotePowqlIdent(a.col.name)} := ${this.writeRef(a.value, a.col, params)}`).join(', ')} }`;
-            });
-            // Multi-row insert with `returning` hands back every inserted row in one round-trip.
-            const { rows, native } = await this.exec(`insert ${this.qt} ${tuples.join(', ')} returning`, params, args.timeout, 'createMany');
-            return this.shape(rows, native).map((r) => this.shapeWriteRow(r, plan));
+            // `returning: false` is checked as the SQL engines check it. PowQL's
+            // insert still returns the rows, which are counted and dropped.
+            const countOnly = this.createManyCountOnly(args);
+            const rows = await this.insertMany(args);
+            return countOnly ? { count: rows.length } : rows;
+        });
+    }
+    /** `returning: false` validated: a boolean, and not combined with a projection. */
+    createManyCountOnly(args) {
+        const { returning } = args;
+        if (returning === undefined || returning === true)
+            return false;
+        if (returning !== false) {
+            throw new ValidationError(`createMany on "${this.table}": returning must be true or false, received ${typeof returning}.`);
+        }
+        if (args.select !== undefined || args.omit !== undefined) {
+            throw new ValidationError(`createMany on "${this.table}": returning: false returns { count } and no rows, so it takes no ` +
+                `\`${args.select !== undefined ? 'select' : 'omit'}\`. Drop one of them.`);
+        }
+        return true;
+    }
+    async insertMany(args) {
+        if (args.onConflict !== undefined) {
+            throw new UnsupportedFeatureError('createMany({ onConflict })', 'powdb', "PowQL's upsert statement takes one row. Call upsert() per row inside $transaction.");
+        }
+        // Validated as every engine validates it; it acts only on onConflict's
+        // update, which is refused above.
+        resolveSkipGlobalFilters(args.skipGlobalFilters);
+        if (args.skipDuplicates) {
+            // PowQL's `insert … returning` has no conflict clause, so there is no
+            // faithful skip-duplicates form; refuse rather than silently insert.
+            throw new UnsupportedFeatureError('createMany({ skipDuplicates: true })', 'powdb', 'PowQL insert has no ON CONFLICT DO NOTHING equivalent, filter duplicates before inserting.');
+        }
+        // Resolved before the write, so a bad projection writes nothing.
+        const plan = this.writeReturnPlan(args);
+        const supplied = args.data.map((d) => this.applyPkDefault(d));
+        if (!supplied.length)
+            return [];
+        // Uniformity is judged on what the caller supplied, as the SQL engines
+        // judge it; defaults are then filled per row.
+        this.assertUniformCreateManyRows(supplied);
+        const inputs = supplied.map((d) => this.applyColumnDefaults(d));
+        const params = [];
+        const tuples = inputs.map((d) => {
+            const assigns = this.scalarData(d);
+            return `{ ${assigns.map((a) => `${quotePowqlIdent(a.col.name)} := ${this.writeRef(a.value, a.col, params)}`).join(', ')} }`;
         });
+        // Multi-row insert with `returning` hands back every inserted row in one round-trip.
+        const { rows, native } = await this.exec(`insert ${this.qt} ${tuples.join(', ')} returning`, params, args.timeout, 'createMany');
+        return this.shape(rows, native).map((r) => this.shapeWriteRow(r, plan));
     }
     async update(args) {
         args = this.normalizeArgs(args);

package/dist/prisma-compat.d.ts

@@ -137,7 +137,7 @@ export interface CompatQueryInterface {
     findFirstOrThrow(args?: Record<string, unknown>): Promise<unknown>;
     findUniqueOrThrow(args: Record<string, unknown>): Promise<unknown>;
     create(args: Record<string, unknown>): Promise<unknown>;
-    createMany(args: Record<string, unknown>): Promise<unknown[]>;
+    createMany(args: Record<string, unknown>): Promise<unknown>;
     update(args: Record<string, unknown>): Promise<unknown>;
     updateMany(args: Record<string, unknown>): Promise<{
         count: number;
@@ -156,7 +156,7 @@ export interface CompatQueryInterface {
     buildFindFirstOrThrow(args?: Record<string, unknown>): DeferredQuery<unknown>;
     buildFindUniqueOrThrow(args: Record<string, unknown>): DeferredQuery<unknown>;
     buildCreate(args: Record<string, unknown>): DeferredQuery<unknown>;
-    buildCreateMany(args: Record<string, unknown>): DeferredQuery<unknown[]>;
+    buildCreateMany(args: Record<string, unknown>): DeferredQuery<unknown>;
     buildUpdate(args: Record<string, unknown>): DeferredQuery<unknown>;
     buildUpdateMany(args: Record<string, unknown>): DeferredQuery<{
         count: number;

package/dist/prisma-compat.js

@@ -1864,12 +1864,12 @@ function createManyRunsOf(t) {
 async function createManyByRun(qi, t, runs) {
     let count = 0;
     for (const run of runs) {
-        const args = { data: run };
+        const args = { data: run, returning: false };
         if (t.skipDuplicates)
             args.skipDuplicates = true;
         if (t.timeout !== undefined)
             args.timeout = t.timeout;
-        count += (await qi.createMany(args)).length;
+        count += (await qi.createMany(args)).count;
     }
     return { count };
 }
@@ -1965,7 +1965,10 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
                     `array of them, received ${describeValue(data)}.`);
             }
             const rows = list.map((d) => translateWriteData(ctx, mm, applyCreateDefaults(mm, d)));
-            const t = { data: rows };
+            // Prisma's createMany resolves to { count }, which core counts
+            // without returning the rows (a plain MySQL insert returns none, so
+            // counting rows reported 0 there).
+            const t = { data: rows, returning: false };
             applyNativeOptions(CREATE_MANY_OPTIONS, args, t);
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
@@ -1977,11 +1980,11 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
             // stays all-or-nothing and the count is the total actually inserted.
             const runs = createManyRunsOf(t);
             if (runs.length <= 1)
-                return qi.createMany(t).then((r) => ({ count: r.length }));
+                return qi.createMany(t);
             return runInTx((table) => createManyByRun(table(mm.table), t, runs));
         }, {
             build: (qi, t) => qi.buildCreateMany(t),
-            reshape: (raw) => ({ count: raw.length }),
+            reshape: (raw) => raw,
             // A mixed batch is more than one statement, so the array
             // $transaction([...]) form runs the whole array sequentially in a tx.
             nested: (t) => createManyRunsOf(t).length > 1,