@prisma/client-engine-runtime 6.13.0 → 6.14.0-dev.10

package/dist/QueryPlan.d.ts

@@ -78,6 +78,7 @@ export type QueryPlanDbQuery = {
     fragments: Fragment[];
     placeholderFormat: PlaceholderFormat;
     params: PrismaValue[];
+    chunkable: boolean;
 };
 export type Fragment = {
     type: 'stringChunk';

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { ConnectionInfo } from '@prisma/driver-adapter-utils';
 import { Context } from '@opentelemetry/api';
 import type { IsolationLevel } from '@prisma/driver-adapter-utils';
 import { Span } from '@opentelemetry/api';
@@ -218,13 +219,14 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, }: QueryInterpreterOptions);
+    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
         transactionManager: QueryInterpreterTransactionManager;
         placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
+        connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
     run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
@@ -238,6 +240,7 @@ export declare type QueryInterpreterOptions = {
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
+    connectionInfo?: ConnectionInfo;
 };
 
 export declare type QueryInterpreterTransactionManager = {
@@ -261,6 +264,7 @@ export declare type QueryPlanDbQuery = {
     fragments: Fragment[];
     placeholderFormat: PlaceholderFormat;
     params: PrismaValue[];
+    chunkable: boolean;
 };
 
 export declare type QueryPlanNode = {

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { ConnectionInfo } from '@prisma/driver-adapter-utils';
 import { Context } from '@opentelemetry/api';
 import type { IsolationLevel } from '@prisma/driver-adapter-utils';
 import { Span } from '@opentelemetry/api';
@@ -218,13 +219,14 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, }: QueryInterpreterOptions);
+    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
         transactionManager: QueryInterpreterTransactionManager;
         placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
+        connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
     run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
@@ -238,6 +240,7 @@ export declare type QueryInterpreterOptions = {
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
+    connectionInfo?: ConnectionInfo;
 };
 
 export declare type QueryInterpreterTransactionManager = {
@@ -261,6 +264,7 @@ export declare type QueryPlanDbQuery = {
     fragments: Fragment[];
     placeholderFormat: PlaceholderFormat;
     params: PrismaValue[];
+    chunkable: boolean;
 };
 
 export declare type QueryPlanNode = {

package/dist/index.js

@@ -708,17 +708,21 @@ function isPrismaValueBigInt(value) {
 }
 
 // src/interpreter/renderQuery.ts
-function renderQuery(dbQuery, scope, generators) {
+function renderQuery(dbQuery, scope, generators, maxChunkSize) {
   const queryType = dbQuery.type;
+  const params = evaluateParams(dbQuery.params, scope, generators);
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators));
-    case "templateSql":
-      return renderTemplateSql(
-        dbQuery.fragments,
-        dbQuery.placeholderFormat,
-        evaluateParams(dbQuery.params, scope, generators)
-      );
+      return [renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators))];
+    case "templateSql": {
+      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, params, maxChunkSize) : [params];
+      return chunks.map((params2) => {
+        if (maxChunkSize !== void 0 && params2.length > maxChunkSize) {
+          throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
+        }
+        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params2);
+      });
+    }
     default:
       assertNever(queryType, `Invalid query type`);
   }
@@ -756,61 +760,36 @@ function evaluateParam(param, scope, generators) {
   return value;
 }
 function renderTemplateSql(fragments, placeholderFormat, params) {
-  let paramIndex = 0;
-  let placeholderNumber = 1;
+  let sql = "";
+  const ctx = { placeholderNumber: 1 };
   const flattenedParams = [];
-  const sql = fragments.map((fragment) => {
-    const fragmentType = fragment.type;
-    switch (fragmentType) {
-      case "parameter":
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        flattenedParams.push(params[paramIndex++]);
-        return formatPlaceholder(placeholderFormat, placeholderNumber++);
-      case "stringChunk":
-        return fragment.chunk;
-      case "parameterTuple": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
-        const placeholders = paramArray.length == 0 ? "NULL" : paramArray.map((value) => {
-          flattenedParams.push(value);
-          return formatPlaceholder(placeholderFormat, placeholderNumber++);
-        }).join(",");
-        return `(${placeholders})`;
-      }
-      case "parameterTupleList": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        if (!Array.isArray(paramValue)) {
-          throw new Error(`Malformed query template. Tuple list expected.`);
-        }
-        if (paramValue.length === 0) {
-          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
-        }
-        const tupleList = paramValue.map((tuple) => {
-          if (!Array.isArray(tuple)) {
-            throw new Error(`Malformed query template. Tuple expected.`);
-          }
-          const elements = tuple.map((value) => {
-            flattenedParams.push(value);
-            return formatPlaceholder(placeholderFormat, placeholderNumber++);
-          }).join(fragment.itemSeparator);
-          return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
-        }).join(fragment.groupSeparator);
-        return tupleList;
-      }
-      default:
-        assertNever(fragmentType, "Invalid fragment type");
-    }
-  }).join("");
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    flattenedParams.push(...flattenedFragmentParams(fragment));
+    sql += renderFragment(fragment, placeholderFormat, ctx);
+  }
   return renderRawSql(sql, flattenedParams);
 }
+function renderFragment(fragment, placeholderFormat, ctx) {
+  const fragmentType = fragment.type;
+  switch (fragmentType) {
+    case "parameter":
+      return formatPlaceholder(placeholderFormat, ctx.placeholderNumber++);
+    case "stringChunk":
+      return fragment.chunk;
+    case "parameterTuple": {
+      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(",");
+      return `(${placeholders})`;
+    }
+    case "parameterTupleList": {
+      return fragment.value.map((tuple) => {
+        const elements = tuple.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(fragment.itemSeparator);
+        return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
+      }).join(fragment.groupSeparator);
+    }
+    default:
+      assertNever(fragmentType, "Invalid fragment type");
+  }
+}
 function formatPlaceholder(placeholderFormat, placeholderNumber) {
   return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
 }
@@ -843,6 +822,143 @@ function toArgType(value) {
 function doesRequireEvaluation(param) {
   return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
 }
+function* pairFragmentsWithParams(fragments, params) {
+  let index = 0;
+  for (const fragment of fragments) {
+    switch (fragment.type) {
+      case "parameter": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        yield { ...fragment, value: params[index++] };
+        break;
+      }
+      case "stringChunk": {
+        yield fragment;
+        break;
+      }
+      case "parameterTuple": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const value = params[index++];
+        yield { ...fragment, value: Array.isArray(value) ? value : [value] };
+        break;
+      }
+      case "parameterTupleList": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const value = params[index++];
+        if (!Array.isArray(value)) {
+          throw new Error(`Malformed query template. Tuple list expected.`);
+        }
+        if (value.length === 0) {
+          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
+        }
+        for (const tuple of value) {
+          if (!Array.isArray(tuple)) {
+            throw new Error(`Malformed query template. Tuple expected.`);
+          }
+        }
+        yield { ...fragment, value };
+        break;
+      }
+    }
+  }
+}
+function* flattenedFragmentParams(fragment) {
+  switch (fragment.type) {
+    case "parameter":
+      yield fragment.value;
+      break;
+    case "stringChunk":
+      break;
+    case "parameterTuple":
+      yield* fragment.value;
+      break;
+    case "parameterTupleList":
+      for (const tuple of fragment.value) {
+        yield* tuple;
+      }
+      break;
+  }
+}
+function chunkParams(fragments, params, maxChunkSize) {
+  let totalParamCount = 0;
+  let maxParamsPerFragment = 0;
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    let paramSize = 0;
+    for (const _ of flattenedFragmentParams(fragment)) {
+      void _;
+      paramSize++;
+    }
+    maxParamsPerFragment = Math.max(maxParamsPerFragment, paramSize);
+    totalParamCount += paramSize;
+  }
+  let chunkedParams = [[]];
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    switch (fragment.type) {
+      case "parameter": {
+        for (const params2 of chunkedParams) {
+          params2.push(fragment.value);
+        }
+        break;
+      }
+      case "stringChunk": {
+        break;
+      }
+      case "parameterTuple": {
+        const thisParamCount = fragment.value.length;
+        let chunks = [];
+        if (maxChunkSize && // Have we split the parameters into chunks already?
+        chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+        thisParamCount === maxParamsPerFragment && // Do we need chunking to fit the parameters?
+        totalParamCount > maxChunkSize && // Would chunking enable us to fit the parameters?
+        totalParamCount - thisParamCount < maxChunkSize) {
+          const availableSize = maxChunkSize - (totalParamCount - thisParamCount);
+          chunks = chunkArray(fragment.value, availableSize);
+        } else {
+          chunks = [fragment.value];
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => chunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+      case "parameterTupleList": {
+        const thisParamCount = fragment.value.reduce((acc, tuple) => acc + tuple.length, 0);
+        const completeChunks = [];
+        let currentChunk = [];
+        let currentChunkParamCount = 0;
+        for (const tuple of fragment.value) {
+          if (maxChunkSize && // Have we split the parameters into chunks already?
+          chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+          thisParamCount === maxParamsPerFragment && // Is there anything in the current chunk?
+          currentChunk.length > 0 && // Will adding this tuple exceed the max chunk size?
+          totalParamCount - thisParamCount + currentChunkParamCount + tuple.length > maxChunkSize) {
+            completeChunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkParamCount = 0;
+          }
+          currentChunk.push(tuple);
+          currentChunkParamCount += tuple.length;
+        }
+        if (currentChunk.length > 0) {
+          completeChunks.push(currentChunk);
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => completeChunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+    }
+  }
+  return chunkedParams;
+}
+function chunkArray(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
 
 // src/interpreter/serializeSql.ts
 var import_driver_adapter_utils2 = require("@prisma/driver-adapter-utils");
@@ -1052,6 +1168,7 @@ var QueryInterpreter = class _QueryInterpreter {
   #serializer;
   #rawSerializer;
   #provider;
+  #connectioInfo;
   constructor({
     transactionManager,
     placeholderValues,
@@ -1059,7 +1176,8 @@ var QueryInterpreter = class _QueryInterpreter {
     tracingHelper,
     serializer,
     rawSerializer,
-    provider
+    provider,
+    connectionInfo
   }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
@@ -1068,6 +1186,7 @@ var QueryInterpreter = class _QueryInterpreter {
     this.#serializer = serializer;
     this.#rawSerializer = rawSerializer ?? serializer;
     this.#provider = provider;
+    this.#connectioInfo = connectionInfo;
   }
   static forSql(options) {
     return new _QueryInterpreter({
@@ -1077,7 +1196,8 @@ var QueryInterpreter = class _QueryInterpreter {
       tracingHelper: options.tracingHelper,
       serializer: serializeSql,
       rawSerializer: serializeRawSql,
-      provider: options.provider
+      provider: options.provider,
+      connectionInfo: options.connectionInfo
     });
   }
   async run(queryPlan, queryable) {
@@ -1138,21 +1258,29 @@ var QueryInterpreter = class _QueryInterpreter {
         };
       }
       case "execute": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          return { value: await queryable.executeRaw(query) };
-        });
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let sum = 0;
+        for (const query of queries) {
+          sum += await this.#withQuerySpanAndEvent(query, queryable, () => queryable.executeRaw(query));
+        }
+        return { value: sum };
       }
       case "query": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          const result = await queryable.queryRaw(query);
-          if (node.args.type === "rawSql") {
-            return { value: this.#rawSerializer(result), lastInsertId: result.lastInsertId };
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let results;
+        for (const query of queries) {
+          const result = await this.#withQuerySpanAndEvent(query, queryable, () => queryable.queryRaw(query));
+          if (results === void 0) {
+            results = result;
           } else {
-            return { value: this.#serializer(result), lastInsertId: result.lastInsertId };
+            results.rows.push(...result.rows);
+            results.lastInsertId = result.lastInsertId;
           }
-        });
+        }
+        return {
+          value: node.args.type === "rawSql" ? this.#rawSerializer(results) : this.#serializer(results),
+          lastInsertId: results?.lastInsertId
+        };
       }
       case "reverse": {
         const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
@@ -1289,6 +1417,34 @@ var QueryInterpreter = class _QueryInterpreter {
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
+  #maxChunkSize() {
+    if (this.#connectioInfo?.maxBindValues !== void 0) {
+      return this.#connectioInfo.maxBindValues;
+    }
+    return this.#providerMaxChunkSize();
+  }
+  #providerMaxChunkSize() {
+    if (this.#provider === void 0) {
+      return void 0;
+    }
+    switch (this.#provider) {
+      case "cockroachdb":
+      case "postgres":
+      case "postgresql":
+      case "prisma+postgres":
+        return 32766;
+      case "mysql":
+        return 65535;
+      case "sqlite":
+        return 999;
+      case "sqlserver":
+        return 2098;
+      case "mongodb":
+        return void 0;
+      default:
+        assertNever(this.#provider, `Unexpected provider: ${this.#provider}`);
+    }
+  }
   #withQuerySpanAndEvent(query, queryable, execute) {
     return withQuerySpanAndEvent({
       query,

package/dist/index.mjs

@@ -659,17 +659,21 @@ function isPrismaValueBigInt(value) {
 }
 
 // src/interpreter/renderQuery.ts
-function renderQuery(dbQuery, scope, generators) {
+function renderQuery(dbQuery, scope, generators, maxChunkSize) {
   const queryType = dbQuery.type;
+  const params = evaluateParams(dbQuery.params, scope, generators);
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators));
-    case "templateSql":
-      return renderTemplateSql(
-        dbQuery.fragments,
-        dbQuery.placeholderFormat,
-        evaluateParams(dbQuery.params, scope, generators)
-      );
+      return [renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators))];
+    case "templateSql": {
+      const chunks = dbQuery.chunkable ? chunkParams(dbQuery.fragments, params, maxChunkSize) : [params];
+      return chunks.map((params2) => {
+        if (maxChunkSize !== void 0 && params2.length > maxChunkSize) {
+          throw new UserFacingError("The query parameter limit supported by your database is exceeded.", "P2029");
+        }
+        return renderTemplateSql(dbQuery.fragments, dbQuery.placeholderFormat, params2);
+      });
+    }
     default:
       assertNever(queryType, `Invalid query type`);
   }
@@ -707,61 +711,36 @@ function evaluateParam(param, scope, generators) {
   return value;
 }
 function renderTemplateSql(fragments, placeholderFormat, params) {
-  let paramIndex = 0;
-  let placeholderNumber = 1;
+  let sql = "";
+  const ctx = { placeholderNumber: 1 };
   const flattenedParams = [];
-  const sql = fragments.map((fragment) => {
-    const fragmentType = fragment.type;
-    switch (fragmentType) {
-      case "parameter":
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        flattenedParams.push(params[paramIndex++]);
-        return formatPlaceholder(placeholderFormat, placeholderNumber++);
-      case "stringChunk":
-        return fragment.chunk;
-      case "parameterTuple": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
-        const placeholders = paramArray.length == 0 ? "NULL" : paramArray.map((value) => {
-          flattenedParams.push(value);
-          return formatPlaceholder(placeholderFormat, placeholderNumber++);
-        }).join(",");
-        return `(${placeholders})`;
-      }
-      case "parameterTupleList": {
-        if (paramIndex >= params.length) {
-          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
-        }
-        const paramValue = params[paramIndex++];
-        if (!Array.isArray(paramValue)) {
-          throw new Error(`Malformed query template. Tuple list expected.`);
-        }
-        if (paramValue.length === 0) {
-          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
-        }
-        const tupleList = paramValue.map((tuple) => {
-          if (!Array.isArray(tuple)) {
-            throw new Error(`Malformed query template. Tuple expected.`);
-          }
-          const elements = tuple.map((value) => {
-            flattenedParams.push(value);
-            return formatPlaceholder(placeholderFormat, placeholderNumber++);
-          }).join(fragment.itemSeparator);
-          return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
-        }).join(fragment.groupSeparator);
-        return tupleList;
-      }
-      default:
-        assertNever(fragmentType, "Invalid fragment type");
-    }
-  }).join("");
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    flattenedParams.push(...flattenedFragmentParams(fragment));
+    sql += renderFragment(fragment, placeholderFormat, ctx);
+  }
   return renderRawSql(sql, flattenedParams);
 }
+function renderFragment(fragment, placeholderFormat, ctx) {
+  const fragmentType = fragment.type;
+  switch (fragmentType) {
+    case "parameter":
+      return formatPlaceholder(placeholderFormat, ctx.placeholderNumber++);
+    case "stringChunk":
+      return fragment.chunk;
+    case "parameterTuple": {
+      const placeholders = fragment.value.length == 0 ? "NULL" : fragment.value.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(",");
+      return `(${placeholders})`;
+    }
+    case "parameterTupleList": {
+      return fragment.value.map((tuple) => {
+        const elements = tuple.map(() => formatPlaceholder(placeholderFormat, ctx.placeholderNumber++)).join(fragment.itemSeparator);
+        return `${fragment.itemPrefix}${elements}${fragment.itemSuffix}`;
+      }).join(fragment.groupSeparator);
+    }
+    default:
+      assertNever(fragmentType, "Invalid fragment type");
+  }
+}
 function formatPlaceholder(placeholderFormat, placeholderNumber) {
   return placeholderFormat.hasNumbering ? `${placeholderFormat.prefix}${placeholderNumber}` : placeholderFormat.prefix;
 }
@@ -794,6 +773,143 @@ function toArgType(value) {
 function doesRequireEvaluation(param) {
   return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
 }
+function* pairFragmentsWithParams(fragments, params) {
+  let index = 0;
+  for (const fragment of fragments) {
+    switch (fragment.type) {
+      case "parameter": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        yield { ...fragment, value: params[index++] };
+        break;
+      }
+      case "stringChunk": {
+        yield fragment;
+        break;
+      }
+      case "parameterTuple": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const value = params[index++];
+        yield { ...fragment, value: Array.isArray(value) ? value : [value] };
+        break;
+      }
+      case "parameterTupleList": {
+        if (index >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const value = params[index++];
+        if (!Array.isArray(value)) {
+          throw new Error(`Malformed query template. Tuple list expected.`);
+        }
+        if (value.length === 0) {
+          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
+        }
+        for (const tuple of value) {
+          if (!Array.isArray(tuple)) {
+            throw new Error(`Malformed query template. Tuple expected.`);
+          }
+        }
+        yield { ...fragment, value };
+        break;
+      }
+    }
+  }
+}
+function* flattenedFragmentParams(fragment) {
+  switch (fragment.type) {
+    case "parameter":
+      yield fragment.value;
+      break;
+    case "stringChunk":
+      break;
+    case "parameterTuple":
+      yield* fragment.value;
+      break;
+    case "parameterTupleList":
+      for (const tuple of fragment.value) {
+        yield* tuple;
+      }
+      break;
+  }
+}
+function chunkParams(fragments, params, maxChunkSize) {
+  let totalParamCount = 0;
+  let maxParamsPerFragment = 0;
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    let paramSize = 0;
+    for (const _ of flattenedFragmentParams(fragment)) {
+      void _;
+      paramSize++;
+    }
+    maxParamsPerFragment = Math.max(maxParamsPerFragment, paramSize);
+    totalParamCount += paramSize;
+  }
+  let chunkedParams = [[]];
+  for (const fragment of pairFragmentsWithParams(fragments, params)) {
+    switch (fragment.type) {
+      case "parameter": {
+        for (const params2 of chunkedParams) {
+          params2.push(fragment.value);
+        }
+        break;
+      }
+      case "stringChunk": {
+        break;
+      }
+      case "parameterTuple": {
+        const thisParamCount = fragment.value.length;
+        let chunks = [];
+        if (maxChunkSize && // Have we split the parameters into chunks already?
+        chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+        thisParamCount === maxParamsPerFragment && // Do we need chunking to fit the parameters?
+        totalParamCount > maxChunkSize && // Would chunking enable us to fit the parameters?
+        totalParamCount - thisParamCount < maxChunkSize) {
+          const availableSize = maxChunkSize - (totalParamCount - thisParamCount);
+          chunks = chunkArray(fragment.value, availableSize);
+        } else {
+          chunks = [fragment.value];
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => chunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+      case "parameterTupleList": {
+        const thisParamCount = fragment.value.reduce((acc, tuple) => acc + tuple.length, 0);
+        const completeChunks = [];
+        let currentChunk = [];
+        let currentChunkParamCount = 0;
+        for (const tuple of fragment.value) {
+          if (maxChunkSize && // Have we split the parameters into chunks already?
+          chunkedParams.length === 1 && // Is this the fragment that has the most parameters?
+          thisParamCount === maxParamsPerFragment && // Is there anything in the current chunk?
+          currentChunk.length > 0 && // Will adding this tuple exceed the max chunk size?
+          totalParamCount - thisParamCount + currentChunkParamCount + tuple.length > maxChunkSize) {
+            completeChunks.push(currentChunk);
+            currentChunk = [];
+            currentChunkParamCount = 0;
+          }
+          currentChunk.push(tuple);
+          currentChunkParamCount += tuple.length;
+        }
+        if (currentChunk.length > 0) {
+          completeChunks.push(currentChunk);
+        }
+        chunkedParams = chunkedParams.flatMap((params2) => completeChunks.map((chunk) => [...params2, chunk]));
+        break;
+      }
+    }
+  }
+  return chunkedParams;
+}
+function chunkArray(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
 
 // src/interpreter/serializeSql.ts
 import { ColumnTypeEnum } from "@prisma/driver-adapter-utils";
@@ -1003,6 +1119,7 @@ var QueryInterpreter = class _QueryInterpreter {
   #serializer;
   #rawSerializer;
   #provider;
+  #connectioInfo;
   constructor({
     transactionManager,
     placeholderValues,
@@ -1010,7 +1127,8 @@ var QueryInterpreter = class _QueryInterpreter {
     tracingHelper,
     serializer,
     rawSerializer,
-    provider
+    provider,
+    connectionInfo
   }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
@@ -1019,6 +1137,7 @@ var QueryInterpreter = class _QueryInterpreter {
     this.#serializer = serializer;
     this.#rawSerializer = rawSerializer ?? serializer;
     this.#provider = provider;
+    this.#connectioInfo = connectionInfo;
   }
   static forSql(options) {
     return new _QueryInterpreter({
@@ -1028,7 +1147,8 @@ var QueryInterpreter = class _QueryInterpreter {
       tracingHelper: options.tracingHelper,
       serializer: serializeSql,
       rawSerializer: serializeRawSql,
-      provider: options.provider
+      provider: options.provider,
+      connectionInfo: options.connectionInfo
     });
   }
   async run(queryPlan, queryable) {
@@ -1089,21 +1209,29 @@ var QueryInterpreter = class _QueryInterpreter {
         };
       }
       case "execute": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          return { value: await queryable.executeRaw(query) };
-        });
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let sum = 0;
+        for (const query of queries) {
+          sum += await this.#withQuerySpanAndEvent(query, queryable, () => queryable.executeRaw(query));
+        }
+        return { value: sum };
       }
       case "query": {
-        const query = renderQuery(node.args, scope, generators);
-        return this.#withQuerySpanAndEvent(query, queryable, async () => {
-          const result = await queryable.queryRaw(query);
-          if (node.args.type === "rawSql") {
-            return { value: this.#rawSerializer(result), lastInsertId: result.lastInsertId };
+        const queries = renderQuery(node.args, scope, generators, this.#maxChunkSize());
+        let results;
+        for (const query of queries) {
+          const result = await this.#withQuerySpanAndEvent(query, queryable, () => queryable.queryRaw(query));
+          if (results === void 0) {
+            results = result;
           } else {
-            return { value: this.#serializer(result), lastInsertId: result.lastInsertId };
+            results.rows.push(...result.rows);
+            results.lastInsertId = result.lastInsertId;
           }
-        });
+        }
+        return {
+          value: node.args.type === "rawSql" ? this.#rawSerializer(results) : this.#serializer(results),
+          lastInsertId: results?.lastInsertId
+        };
       }
       case "reverse": {
         const { value, lastInsertId } = await this.interpretNode(node.args, queryable, scope, generators);
@@ -1240,6 +1368,34 @@ var QueryInterpreter = class _QueryInterpreter {
         assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
+  #maxChunkSize() {
+    if (this.#connectioInfo?.maxBindValues !== void 0) {
+      return this.#connectioInfo.maxBindValues;
+    }
+    return this.#providerMaxChunkSize();
+  }
+  #providerMaxChunkSize() {
+    if (this.#provider === void 0) {
+      return void 0;
+    }
+    switch (this.#provider) {
+      case "cockroachdb":
+      case "postgres":
+      case "postgresql":
+      case "prisma+postgres":
+        return 32766;
+      case "mysql":
+        return 65535;
+      case "sqlite":
+        return 999;
+      case "sqlserver":
+        return 2098;
+      case "mongodb":
+        return void 0;
+      default:
+        assertNever(this.#provider, `Unexpected provider: ${this.#provider}`);
+    }
+  }
   #withQuerySpanAndEvent(query, queryable, execute) {
     return withQuerySpanAndEvent({
       query,

package/dist/interpreter/QueryInterpreter.d.ts

@@ -1,4 +1,4 @@
-import { SqlQueryable, SqlResultSet } from '@prisma/driver-adapter-utils';
+import { ConnectionInfo, SqlQueryable, SqlResultSet } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from '../events';
 import { QueryPlanNode } from '../QueryPlan';
 import { type SchemaProvider } from '../schema';
@@ -19,16 +19,18 @@ export type QueryInterpreterOptions = {
     serializer: (results: SqlResultSet) => Value;
     rawSerializer?: (results: SqlResultSet) => Value;
     provider?: SchemaProvider;
+    connectionInfo?: ConnectionInfo;
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, }: QueryInterpreterOptions);
+    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer, rawSerializer, provider, connectionInfo, }: QueryInterpreterOptions);
     static forSql(options: {
         transactionManager: QueryInterpreterTransactionManager;
         placeholderValues: Record<string, unknown>;
         onQuery?: (event: QueryEvent) => void;
         tracingHelper: TracingHelper;
         provider?: SchemaProvider;
+        connectionInfo?: ConnectionInfo;
     }): QueryInterpreter;
     run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;

package/dist/interpreter/renderQuery.d.ts

@@ -2,5 +2,5 @@ import { SqlQuery } from '@prisma/driver-adapter-utils';
 import type { PrismaValue, QueryPlanDbQuery } from '../QueryPlan';
 import { GeneratorRegistrySnapshot } from './generators';
 import { ScopeBindings } from './scope';
-export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): SqlQuery;
+export declare function renderQuery(dbQuery: QueryPlanDbQuery, scope: ScopeBindings, generators: GeneratorRegistrySnapshot, maxChunkSize?: number): SqlQuery[];
 export declare function evaluateParam(param: PrismaValue, scope: ScopeBindings, generators: GeneratorRegistrySnapshot): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.13.0",
+  "version": "6.14.0-dev.10",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,8 +31,8 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "6.13.0",
-    "@prisma/driver-adapter-utils": "6.13.0"
+    "@prisma/debug": "6.14.0-dev.10",
+    "@prisma/driver-adapter-utils": "6.14.0-dev.10"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",