@vibeorm/sql 4.3.0 → 5.0.0

package/dist/index.js

@@ -317,6 +317,7 @@ var mysqlDecimalCodec = {
 };
 var ZONE_LESS_DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
 var PG_ZONED_DATETIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)(\.\d{1,9})?([+-]\d{2})(?::?(\d{2}))?$/;
+var EXTENDED_DATETIME = /^(\d{4,})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?)?(?:([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?( BC)?$/;
 function parseDateTimeText(params) {
   const trimmed = params.text.trim();
   const date = parseDateTimeInstant({ trimmed });
@@ -341,11 +342,34 @@ function parseDateTimeInstant(params) {
     if (!Number.isNaN(iso.getTime()))
       return iso;
   }
+  const extended = parseExtendedDateTimeText({ text: trimmed });
+  if (extended !== undefined)
+    return extended;
   const parsed = new Date(trimmed);
   return Number.isNaN(parsed.getTime()) ? undefined : parsed;
 }
+function parseExtendedDateTimeText(params) {
+  const match = EXTENDED_DATETIME.exec(params.text.trim());
+  if (match === null)
+    return;
+  const [, yearText, month, day, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds, era] = match;
+  if (yearText.length < 5 && era === undefined)
+    return;
+  const year = era === undefined ? Number(yearText) : 1 - Number(yearText);
+  const date = new Date(0);
+  date.setUTCFullYear(year, Number(month) - 1, Number(day));
+  date.setUTCHours(Number(hours ?? 0), Number(minutes ?? 0), Number(seconds ?? 0), Number((fraction ?? "").padEnd(3, "0").slice(0, 3)));
+  if (sign !== undefined) {
+    const offset = (Number(offsetHours) * 3600 + Number(offsetMinutes ?? 0) * 60 + Number(offsetSeconds ?? 0)) * 1000;
+    date.setTime(date.getTime() - (sign === "-" ? -offset : offset));
+  }
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function decodedDateTimeRefusal() {
+  return new VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+}
 function invalidDecodedDateTime() {
-  throw new VibeError({ code: "VIBE_DATA_INVALID", message: "DateTime requires a finite timestamp; use an explicit extended timestamp decoder for infinity" });
+  throw decodedDateTimeRefusal();
 }
 var dateNativeCodec = {
   encode: (value) => {
@@ -2330,6 +2354,8 @@ var sqliteDialect = {
   keyListStrategy: "values",
   keysetSeekStrategy: "rowValue",
   keyPageStrategy: "inLimit",
+  lateralJson: null,
+  relationStrategyDefault: "query",
   relationFilterStrategy: "inSelect",
   deferredJoinPage: null,
   nativeNullsOrder: "low",
@@ -2842,6 +2868,10 @@ function isDbNowMarker(value) {
   return candidate.__dbNow === true && typeof candidate.offsetSeconds === "number" && Number.isFinite(candidate.offsetSeconds);
 }
 var SQL_DEFAULT_CELL = Object.freeze({ __sqlDefault: true });
+var SQL_KEEP_CELL = Object.freeze({ __sqlKeep: true });
+function isSqlKeepCell(value) {
+  return value === SQL_KEEP_CELL;
+}
 function isSqlDefaultCell(value) {
   return value === SQL_DEFAULT_CELL;
 }
@@ -2979,6 +3009,8 @@ var postgresDialect = {
   keyListStrategy: "unnest",
   keysetSeekStrategy: "rowValue",
   keyPageStrategy: "lateral",
+  lateralJson: { rowArray: "json_build_array", arrayAgg: "json_agg", emptyArray: "'[]'::json", order: "inAggregate", timeOfDayAsText: false, requiresUtcDateTimeWire: false },
+  relationStrategyDefault: "join",
   relationFilterStrategy: "exists",
   deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: true },
   nativeNullsOrder: "high",
@@ -3064,6 +3096,8 @@ var mysqlDialect = {
   keyListStrategy: "rowValue",
   keysetSeekStrategy: "or",
   keyPageStrategy: "window",
+  lateralJson: { rowArray: "JSON_ARRAY", arrayAgg: "JSON_ARRAYAGG", emptyArray: "JSON_ARRAY()", order: "positionSlot", timeOfDayAsText: true, requiresUtcDateTimeWire: true },
+  relationStrategyDefault: "join",
   relationFilterStrategy: "exists",
   deferredJoinPage: { minSkip: 1000, requiresCoveringIndex: false },
   nativeNullsOrder: "low",
@@ -3077,7 +3111,7 @@ var mysqlDialect = {
     duplicatesInOneStatement: "lastWriteWins"
   },
   excludedRowRef: { form: "rowAlias", alias: "new" },
-  doNothingForm: "insertIgnore",
+  doNothingForm: "duplicateKeyKeep",
   insensitiveLike: "lower",
   strictMatchStrategy: "binary",
   greatestForm: "wrapped-frame",
@@ -3752,11 +3786,14 @@ function renderRlsPolicy(params) {
 }
 function renderRlsContext(params) {
   requireRls(params);
-  if (validateRlsContextIR({ context: params.context }).length !== 0 || Object.keys(params.context).length === 0 || typeof params.values !== "object" || params.values === null || Array.isArray(params.values)) {
+  const extra = params.role !== undefined || params.readOnly === true || params.backend === true;
+  if (validateRlsContextIR({ context: params.context }).length !== 0 || Object.keys(params.context).length === 0 && !extra || typeof params.values !== "object" || params.values === null || Array.isArray(params.values)) {
     throw new RlsContextError({ reason: "invalid" });
   }
   const collector = new ParamCollector(params.dialect);
   const parts = [];
+  if (params.role !== undefined)
+    parts.push(`set_config('role', ${collector.add(runtimeRoleOf({ role: params.role }))}, true)`);
   for (const [key, slot] of Object.entries(params.context)) {
     if (!Object.hasOwn(params.values, key))
       throw new RlsContextError({ reason: "missing", key });
@@ -3770,15 +3807,24 @@ function renderRlsContext(params) {
     if (typeof key !== "string" || !Object.hasOwn(params.context, key))
       throw new RlsContextError({ reason: "invalid" });
   }
+  if (params.readOnly === true)
+    parts.push("set_config('transaction_read_only', 'on', true)");
+  if (params.backend === true) {
+    parts.push(`pg_catalog.pg_backend_pid()::text AS ${identifier2({ dialect: params.dialect, name: "backendPid" })}`, `(SELECT a.backend_start::text FROM pg_catalog.pg_stat_activity a WHERE a.pid = pg_catalog.pg_backend_pid()) AS ${identifier2({ dialect: params.dialect, name: "backendStart" })}`);
+  }
   return query({ text: `SELECT ${parts.join(", ")}`, values: collector.values });
 }
-function renderRlsRole(params) {
-  requireRls(params);
+function runtimeRoleOf(params) {
   if (typeof params.role !== "string" || params.role.trim().length === 0 || params.role.includes("\x00")) {
     throw new VibeError22({ code: "VIBE_CONFIG", message: "PGlite native RLS requires a trusted nonempty runtime role name" });
   }
+  return params.role;
+}
+function renderRlsRole(params) {
+  requireRls(params);
+  const role = runtimeRoleOf({ role: params.role });
   const collector = new ParamCollector(params.dialect);
-  return query({ text: `SELECT set_config('role', ${collector.add(params.role)}, true)`, values: collector.values });
+  return query({ text: `SELECT set_config('role', ${collector.add(role)}, true)`, values: collector.values });
 }
 
 // packages/sql/src/dialects/postgres-rls-readiness.ts
@@ -4037,7 +4083,7 @@ function renderStatement(params) {
     case "rlsPolicy":
       return renderRlsPolicy({ dialect, ...statement });
     case "rlsContext":
-      return renderRlsContext({ dialect, context: statement.context, values: statement.values });
+      return renderRlsContext({ dialect, ...statement });
     case "rlsRole":
       return renderRlsRole({ dialect, role: statement.role });
   }
@@ -4090,9 +4136,13 @@ function quoteProjection(dialect, column) {
   const alias = dialect.quoteIdent({ name: column.alias ?? column.name });
   if (column.transform === "castText")
     return `${textProjection({ dialect, expression: ref })} AS ${alias}`;
+  if (column.transform === "encodeBase64" && dialect.name === "mysql")
+    return `TO_BASE64(${ref}) AS ${alias}`;
   if (dialect.name !== "postgres") {
-    throw internalError3({ message: "encodeBase64 is a postgres construct" });
+    throw internalError3({ message: `${column.transform} is a postgres construct` });
   }
+  if (column.transform === "encodeArrayBase64")
+    return `encode(array_send(${ref}), 'base64') AS ${alias}`;
   return `encode(${ref}, 'base64') AS ${alias}`;
 }
 function textProjection(params) {
@@ -4494,6 +4544,35 @@ function renderKeyPage(params) {
   });
   return `SELECT ${[...projection, rank].join(", ")} FROM (VALUES ${tuples.join(", ")}) AS ${keys} INNER JOIN ${rows} ON ${membership}`;
 }
+function renderKeyRows(params) {
+  const { dialect, statement, keys, collector } = params;
+  if (statement.fromSelect !== undefined || statement.keyPage !== undefined || statement.fromUnion !== undefined || statement.table.alias !== undefined) {
+    throw internalError3({ message: "fromKeys uses table.name as the derived-table alias \u2014 fromSelect, keyPage, fromUnion and table.alias must be unset" });
+  }
+  if (statement.rowLock !== undefined)
+    throw internalError3({ message: "a locking read cannot read from key rows" });
+  const arity = keys.columns.length;
+  if (arity === 0 || keys.members.length !== arity) {
+    throw internalError3({ message: `fromKeys has ${keys.members.length} members for ${arity} columns` });
+  }
+  if (keys.rows.length === 0)
+    throw internalError3({ message: "fromKeys needs at least one key row" });
+  for (const row of keys.rows) {
+    if (row.length !== arity)
+      throw internalError3({ message: `fromKeys row has ${row.length} values for ${arity} columns` });
+  }
+  if (dialect.keyListStrategy !== "unnest" || keyListBindsUntypedRows({ members: keys.members })) {
+    throw unsupportedCapability27({
+      dialect: dialect.name,
+      feature: dialect.keyListStrategy !== "unnest" ? "a key-rows FROM (fromKeys)" : "a key-rows FROM over a DateTime key without a declared native type",
+      hint: "the runtime keeps the per-relation loads for this write"
+    });
+  }
+  const types = keys.members.map((member) => postgresKeyListElementType({ dialect, member }));
+  const arrays = types.map((type, index) => `${collector.add(keys.rows.map((row) => row[index]))}::${type}[]`);
+  const names = keys.columns.map((name) => dialect.quoteIdent({ name }));
+  return `unnest(${arrays.join(", ")}) AS ${dialect.quoteIdent({ name: statement.table.name })} (${names.join(", ")})`;
+}
 var UNION_BRANCH_MEMBERS = new Set(["kind", "table", "columns", "where", "orderBy", "limit"]);
 function renderUnionPage(params) {
   const { dialect, statement, collector } = params;
@@ -4679,22 +4758,31 @@ function renderSelectExpr(params) {
 }
 function renderPositionalRow(params) {
   const { dialect, join, subAlias } = params;
-  if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || join.select.rowNumber !== undefined) {
+  const json = lateralJsonOf({ dialect });
+  const position = join.select.rowNumber;
+  const positioned = position !== undefined && json.order === "positionSlot" && join.agg === "jsonArray" && position.partitionBy.length === 0 && position.orderBy.length > 0;
+  if (join.select.columns.length === 0 || join.select.selectExpr !== undefined || (join.select.aggregates?.length ?? 0) > 0 || position !== undefined && !positioned) {
     throw internalError3({ message: "positional lateral rows require an explicit column-only projection" });
   }
-  const names = join.select.columns.map((column) => projectionOutputName({ column }));
+  const names = [...join.select.columns.map((column) => projectionOutputName({ column })), ...positioned ? [position.alias] : []];
   if (new Set(names).size !== names.length) {
     throw internalError3({ message: "positional lateral projection has duplicate output names" });
   }
   const values = names.map((name) => `${subAlias}.${dialect.quoteIdent({ name })}`);
   const chunks = [];
   for (let index = 0;index < values.length; index += JSON_TRANSPORT.chunkSize) {
-    chunks.push(`json_build_array(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
+    chunks.push(`${json.rowArray}(${values.slice(index, index + JSON_TRANSPORT.chunkSize).join(", ")})`);
   }
   if (chunks.length > JSON_TRANSPORT.chunkSize) {
     throw internalError3({ message: "positional lateral projection exceeds the transport width limit" });
   }
-  return chunks.length === 1 ? chunks[0] : `json_build_array(${chunks.join(", ")})`;
+  return chunks.length === 1 ? chunks[0] : `${json.rowArray}(${chunks.join(", ")})`;
+}
+function lateralJsonOf(params) {
+  const json = params.dialect.lateralJson;
+  if (json === null)
+    throw internalError3({ message: "lateral JSON rendering on a dialect without LATERAL" });
+  return json;
 }
 function renderLateralJoin(params) {
   const { dialect, join, collector } = params;
@@ -4707,8 +4795,9 @@ function renderLateralJoin(params) {
   }
   const columnAlias = dialect.quoteIdent({ name: join.columnAlias });
   const subAlias = dialect.quoteIdent({ name: "__sub" });
+  const json = lateralJsonOf({ dialect });
   let aggOrder = "";
-  if (join.agg === "jsonArray" && join.select.orderBy !== undefined && join.select.orderBy.length > 0) {
+  if (json.order === "inAggregate" && join.agg === "jsonArray" && join.select.orderBy !== undefined && join.select.orderBy.length > 0) {
     const projected = new Set(join.select.columns.filter((column) => column.transform === undefined && column.castReal !== true).map((column) => column.name));
     const terms = join.select.orderBy;
     const columnTerms = terms.filter((term) => ("column" in term));
@@ -4724,8 +4813,11 @@ function renderLateralJoin(params) {
       aggOrder = ` ORDER BY ${rendered.join(", ")}`;
     }
   }
+  if (join.rowFormat !== "positional" && json.order !== "inAggregate") {
+    throw unsupportedCapability27({ dialect: dialect.name, feature: "object-format lateral rows", hint: 'lateral relation rows render positional (rowFormat "positional") on this dialect' });
+  }
   const rowJson = join.rowFormat === "positional" ? renderPositionalRow({ dialect, join, subAlias }) : `to_json(${subAlias}.*)`;
-  const projection = join.agg === "jsonArray" ? `COALESCE(json_agg(${rowJson}${aggOrder}), '[]'::json) AS ${columnAlias}` : `${rowJson} AS ${columnAlias}`;
+  const projection = join.agg === "jsonArray" ? `COALESCE(${json.arrayAgg}(${rowJson}${aggOrder}), ${json.emptyArray}) AS ${columnAlias}` : `${rowJson} AS ${columnAlias}`;
   const alias = dialect.quoteIdent({ name: join.alias });
   return `LEFT JOIN LATERAL (SELECT ${projection} FROM (${inner.text}) AS ${subAlias}) AS ${alias} ON true`;
 }
@@ -4848,12 +4940,12 @@ function renderSelect(params) {
   }
   if (statement.rowNumber !== undefined) {
     const rowNumber = statement.rowNumber;
-    if (rowNumber.partitionBy.length === 0) {
-      throw internalError3({ message: "rowNumber needs at least one partition column" });
+    if (rowNumber.partitionBy.length === 0 && rowNumber.orderBy.length === 0) {
+      throw internalError3({ message: "rowNumber needs a partition column or an order" });
     }
-    const partition = rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ");
-    const order = rowNumber.orderBy.length === 0 ? "" : ` ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
-    columnList.push(`ROW_NUMBER() OVER (PARTITION BY ${partition}${order}) AS ${dialect.quoteIdent({ name: rowNumber.alias })}`);
+    const partition = rowNumber.partitionBy.length === 0 ? "" : `PARTITION BY ${rowNumber.partitionBy.map((column) => quoteCol(dialect, column)).join(", ")}`;
+    const order = rowNumber.orderBy.length === 0 ? "" : `${partition === "" ? "" : " "}ORDER BY ${rowNumber.orderBy.map((term) => renderOrderTerm({ dialect, term, collector })).join(", ")}`;
+    columnList.push(`ROW_NUMBER() OVER (${partition}${order}) AS ${dialect.quoteIdent({ name: rowNumber.alias })}`);
   }
   let distinctPrefix = statement.distinct === true ? "DISTINCT " : "";
   if (statement.distinct === true && statement.distinctOn !== undefined) {
@@ -4871,7 +4963,9 @@ function renderSelect(params) {
   }
   const columns = columnList.length === 0 ? "*" : columnList.join(", ");
   let from;
-  if (statement.fromUnion !== undefined) {
+  if (statement.fromKeys !== undefined) {
+    from = renderKeyRows({ dialect, statement, keys: statement.fromKeys, collector });
+  } else if (statement.fromUnion !== undefined) {
     from = `(${renderUnionPage({ dialect, statement, collector })}) AS ${dialect.quoteIdent({ name: statement.table.name })}`;
   } else if (statement.keyPage !== undefined) {
     if (statement.fromSelect !== undefined || statement.table.alias !== undefined) {
@@ -4909,7 +5003,7 @@ function renderSelect(params) {
     }
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
-    if (!dialect.capabilities.lateralJoin) {
+    if (!dialect.capabilities.lateralJoin || dialect.lateralJson === null) {
       throw unsupportedCapability27({
         dialect: dialect.name,
         feature: "LATERAL JOIN relation loading",
@@ -5029,8 +5123,7 @@ function renderInsert(params) {
     }
   }
   const onConflict = statement.onConflict;
-  const skipConflicts = onConflict !== undefined && "doNothing" in onConflict;
-  const insertKeyword = skipConflicts && dialect.doNothingForm === "insertIgnore" ? "INSERT IGNORE INTO" : "INSERT INTO";
+  const insertKeyword = "INSERT INTO";
   const columnList = statement.columns.map((name) => dialect.quoteIdent({ name })).join(", ");
   const unnestSource = statement.unnest === undefined ? undefined : renderUnnestRows({ dialect, statement, members: statement.unnest, collector });
   const rowsSql = unnestSource !== undefined ? "" : statement.rows.map((row) => `(${row.map((value) => {
@@ -5072,12 +5165,25 @@ function renderInsert(params) {
           }
         }
         text += ` ON CONFLICT${target} DO NOTHING`;
-      } else if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
-        throw unsupportedCapability27({
-          dialect: dialect.name,
-          feature: "a refined conflict target (constraint / partial-index predicate) on INSERT IGNORE",
-          hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
-        });
+      } else {
+        if (onConflict.constraint !== undefined || onConflict.conflictWhere !== undefined) {
+          throw unsupportedCapability27({
+            dialect: dialect.name,
+            feature: "a refined conflict target (constraint / partial-index predicate) on ON DUPLICATE KEY UPDATE",
+            hint: "mysql skips on any duplicate key \u2014 drop the refinement or gate the call per dialect"
+          });
+        }
+        const keepName = onConflict.keepColumn ?? statement.columns[0];
+        if (keepName === undefined) {
+          throw internalError3({ message: "a skip-duplicates insert of an all-default row must name its keepColumn" });
+        }
+        const keep = dialect.quoteIdent({ name: keepName });
+        const current = `${dialect.quoteIdent({ name: statement.table.name })}.${keep}`;
+        const flag = onConflict.duplicateFlag;
+        if (flag !== undefined && !/^\d{1,20}$/.test(flag)) {
+          throw internalError3({ message: `duplicateFlag must be a decimal literal, got ${JSON.stringify(flag)}` });
+        }
+        text += flag === undefined ? ` ON DUPLICATE KEY UPDATE ${keep} = ${current}` : ` ON DUPLICATE KEY UPDATE ${keep} = IF(LAST_INSERT_ID(${flag}), ${current}, ${current})`;
       }
     } else {
       const updates = Object.entries(onConflict.update);
@@ -5134,7 +5240,7 @@ function renderUpdate(params) {
   if (assignments.length === 0) {
     throw internalError3({ message: "update must set at least one column" });
   }
-  const setSql = renderAssignments({ dialect, entries: assignments, collector });
+  const setSql = renderAssignments({ dialect, entries: assignments, collector, ...params.earlier === undefined ? {} : { steps: params.earlier } });
   let text = `UPDATE ${renderTable(dialect, statement.table)} SET ${setSql}`;
   if (statement.where !== undefined) {
     text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
@@ -5153,6 +5259,12 @@ function renderAssignments(params) {
   return entries.map(([name, value]) => {
     const column = dialect.quoteIdent({ name });
     const read = selfRef === undefined ? column : `${selfRef}.${column}`;
+    if (isStepColumnRef(value)) {
+      if (params.steps === undefined || !params.steps.has(value.step)) {
+        throw internalError3({ message: `an UPDATE set value reads step "${value.step}", which is not an earlier chain step` });
+      }
+      return `${column} = (SELECT ${dialect.quoteIdent({ name: value.column })} FROM ${dialect.quoteIdent({ name: value.step })})`;
+    }
     if (isSqlFragment(value)) {
       if (params.allowExcluded !== true || selfRef === undefined)
         throw internalError3({ message: "SQL assignment fragments require a conflict update" });
@@ -5166,6 +5278,11 @@ function renderAssignments(params) {
       }
       return `${column} = ${renderIncomingRowColumn({ dialect, column: value.column })}`;
     }
+    if (isSqlKeepCell(value)) {
+      if (params.allowExcluded !== true || selfRef === undefined)
+        throw internalError3({ message: "a keep-column cell is only meaningful inside an upsert's update arm" });
+      return `${column} = ${read}`;
+    }
     if (isJsonParamCell(value)) {
       return `${column} = ${collector.add(value.text)}${jsonCellCast(dialect, value)}`;
     }
@@ -5259,7 +5376,7 @@ function renderChainStep(params) {
     case "insertSelect":
       return renderInsertSelect({ dialect, statement, collector, earlier: params.earlier });
     case "update":
-      return renderUpdate({ dialect, statement, collector }).text;
+      return renderUpdate({ dialect, statement, collector, earlier: params.earlier }).text;
     case "delete":
       return renderDelete({ dialect, statement, collector }).text;
   }
@@ -5360,6 +5477,19 @@ function renderInsertSelect(params) {
   if (statement.where !== undefined) {
     text += ` WHERE ${renderExpr({ dialect, expr: statement.where, collector })}`;
   }
+  const conflict = statement.conflictDoNothing;
+  if (conflict !== undefined) {
+    if (conflict.columns.length === 0)
+      throw internalError3({ message: "an INSERT \u2026 SELECT conflict clause needs at least one column" });
+    if (dialect.doNothingForm !== "onConflictDoNothing") {
+      throw unsupportedCapability27({
+        dialect: dialect.name,
+        feature: "ON CONFLICT DO NOTHING on an INSERT \u2026 SELECT chain step",
+        hint: "gate on SqlDialect.statementChain and keep the multi-statement path"
+      });
+    }
+    text += ` ON CONFLICT (${conflict.columns.map((name) => dialect.quoteIdent({ name })).join(", ")}) DO NOTHING`;
+  }
   return text + applyReturning({ dialect, requested: statement.returning }).suffix;
 }
 // packages/sql/src/dialects/postgres-type-identity.ts
@@ -5504,31 +5634,54 @@ function sqliteTableConstraints(params) {
   return result;
 }
 // packages/sql/src/dialects/migration-visibility.ts
-import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
-function renderMigrationVisibility(params) {
-  if (params.dialect.name !== "mysql")
-    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
-  const collector = new ParamCollector(params.dialect);
-  const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
-  return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA`, values: collector.values, returning: "none" };
-}
-// packages/sql/src/dialects/migration-inventory.ts
 import { unsupportedCapability as unsupportedCapability33 } from "@vibeorm/schema";
+
+// packages/sql/src/dialects/migration-inventory.ts
+import { unsupportedCapability as unsupportedCapability32 } from "@vibeorm/schema";
+var MYSQL_NO_ROW_LIMIT = " LIMIT 18446744073709551615";
 function renderSqliteColumnInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT name, hidden, pk, dflt_value AS definition FROM pragma_table_xinfo(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY cid`, values: collector.values, returning: "none" };
 }
 function renderSqliteForeignKeyInventory(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
   const collector = new ParamCollector(params.dialect);
   return { text: `SELECT id, seq, "from", "to", "table", on_update, on_delete, match FROM pragma_foreign_key_list(${collector.add(params.table)}, ${collector.add(params.namespace)}) ORDER BY id, seq`, values: collector.values, returning: "none" };
 }
+function renderSqliteColumnInventoryBatch(params) {
+  if (params.dialect.name !== "sqlite")
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteColumnInventory" });
+  const collector = new ParamCollector(params.dialect);
+  const request = params.dialect.quoteIdent({ name: "vibe_request" });
+  return { text: `SELECT j.key AS ${request}, x.name AS name, x.hidden AS hidden, x.pk AS pk, x.dflt_value AS definition FROM json_each(${collector.add(JSON.stringify(params.tables))}) j LEFT JOIN pragma_table_xinfo(j.value, ${collector.add(params.namespace)}) x ORDER BY j.key, x.cid`, values: collector.values, returning: "none" };
+}
+function renderSqliteForeignKeyInventoryBatch(params) {
+  if (params.dialect.name !== "sqlite")
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteForeignKeyInventory" });
+  const collector = new ParamCollector(params.dialect);
+  const request = params.dialect.quoteIdent({ name: "vibe_request" });
+  return { text: `SELECT j.key AS ${request}, f.id AS id, f.seq AS seq, f."from" AS "from", f."to" AS "to", f."table" AS "table", f.on_update AS on_update, f.on_delete AS on_delete, f.match AS match FROM json_each(${collector.add(JSON.stringify(params.tables))}) j LEFT JOIN pragma_foreign_key_list(j.value, ${collector.add(params.namespace)}) f ORDER BY j.key, f.id, f.seq`, values: collector.values, returning: "none" };
+}
+var SQLITE_INTROSPECTION_PRAGMA_ORDER = Object.freeze({
+  table_xinfo: "p.cid",
+  index_list: "p.seq",
+  index_xinfo: "p.seqno",
+  foreign_key_list: "p.id, p.seq"
+});
+function renderSqliteIntrospectionPragmaBatch(params) {
+  if (params.dialect.name !== "sqlite")
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteIntrospectionPragmaBatch" });
+  const order = SQLITE_INTROSPECTION_PRAGMA_ORDER[params.pragma];
+  if (order === undefined)
+    throw unsupportedCapability32({ dialect: "sqlite", feature: `introspectionPragma:${String(params.pragma)}` });
+  return { text: `SELECT j.key AS ${params.dialect.quoteIdent({ name: "vibe_request" })}, p.* FROM json_each(${params.dialect.quoteStringLiteral({ value: JSON.stringify(params.names) })}) j LEFT JOIN pragma_${params.pragma}(j.value) p ORDER BY j.key, ${order}`, values: [], returning: "none" };
+}
 function renderSqliteRebuildObjects(params) {
   if (params.dialect.name !== "sqlite")
-    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
+    throw unsupportedCapability32({ dialect: params.dialect.name, feature: "sqliteRebuildObjects" });
   return { text: "SELECT name, tbl_name, type, sql FROM main.sqlite_schema WHERE type IN ('index', 'trigger') AND sql IS NOT NULL ORDER BY type, name", values: [], returning: "none" };
 }
 function renderMigrationInventory(params) {
@@ -5561,11 +5714,20 @@ UNION ALL SELECT 'trigger', TRIGGER_NAME, EVENT_OBJECT_TABLE, NULL, NULL, NULL F
 UNION ALL SELECT 'column', COLUMN_NAME, TABLE_NAME, NULL, NULL, NULL FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${n()} AND TABLE_NAME <> '_vibe_migrations'
 UNION ALL SELECT CASE WHEN GENERATION_EXPRESSION <> '' THEN 'generatedColumn' ELSE 'columnDefault' END, COLUMN_NAME, TABLE_NAME, NULL, NULL, NULL FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${n()} AND TABLE_NAME <> '_vibe_migrations' AND (COLUMN_DEFAULT IS NOT NULL OR GENERATION_EXPRESSION <> '')
 UNION ALL SELECT 'function', ROUTINE_NAME, NULL, NULL, '[]', NULL FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${n()} AND ROUTINE_TYPE = 'FUNCTION'
-ORDER BY kind, parent, name`, values: collector.values, returning: "none" };
+ORDER BY kind, parent, name${MYSQL_NO_ROW_LIMIT}`, values: collector.values, returning: "none" };
   }
   const schema = params.dialect.quoteIdent({ name: params.namespace });
   return { text: `SELECT type AS kind, name, tbl_name AS parent, sql AS definition FROM ${schema}.sqlite_schema WHERE name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_vibe_migrations' ORDER BY type, tbl_name, name`, values: [], returning: "none" };
 }
+
+// packages/sql/src/dialects/migration-visibility.ts
+function renderMigrationVisibility(params) {
+  if (params.dialect.name !== "mysql")
+    throw unsupportedCapability33({ dialect: params.dialect.name, feature: "mysqlCatalogVisibility" });
+  const collector = new ParamCollector(params.dialect);
+  const grantee = "CONCAT(QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', 1)), '@', QUOTE(SUBSTRING_INDEX(CURRENT_USER(), '@', -1)))";
+  return { text: `SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.USER_PRIVILEGES WHERE GRANTEE = ${grantee} UNION SELECT PRIVILEGE_TYPE AS privilege FROM information_schema.SCHEMA_PRIVILEGES WHERE GRANTEE = ${grantee} AND ${collector.add(params.namespace)} LIKE TABLE_SCHEMA${MYSQL_NO_ROW_LIMIT}`, values: collector.values, returning: "none" };
+}
 // packages/sql/src/dialects/migration-objects.ts
 import { internalError as internalError4, unsupportedCapability as unsupportedCapability34 } from "@vibeorm/schema";
 function renderMigrationObjectQuery(params) {
@@ -5622,35 +5784,12 @@ function objectQuery(params) {
         break;
     }
   } else if (dialect.name === "mysql") {
-    switch (object.kind) {
-      case "view":
-        text = `SELECT VIEW_DEFINITION AS definition, CHECK_OPTION AS checkOption, SECURITY_TYPE AS securityType, DEFINER AS definer FROM information_schema.VIEWS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
-        break;
-      case "trigger":
-        text = `SELECT ACTION_STATEMENT AS definition, ACTION_TIMING AS timing, EVENT_MANIPULATION AS event, ACTION_ORDER AS actionOrder, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = ${namespace} AND EVENT_OBJECT_TABLE = ${name} AND TRIGGER_NAME = ${collector.add(object.name)}`;
-        break;
-      case "function":
-        text = `SELECT ROUTINE_DEFINITION AS definition, DTD_IDENTIFIER AS result, IS_DETERMINISTIC AS deterministic, SQL_DATA_ACCESS AS dataAccess, SECURITY_TYPE AS securityType, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_NAME = ${name} AND ROUTINE_TYPE = 'FUNCTION'`;
-        break;
-      case "column":
-      case "columnDefault":
-      case "generatedColumn":
-        text = `SELECT COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_DEFAULT AS definition, GENERATION_EXPRESSION AS ${dialect.quoteIdent({ name: "generated" })}, EXTRA AS extra, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND COLUMN_NAME = ${collector.add(object.column)}`;
-        break;
-      case "constraint":
-        if (object.constraintType === "exclusion")
-          throw unsupportedCapability34({ dialect: "mysql", feature: "exclusionConstraints" });
-        text = `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
-        break;
-      case "index":
-        text = `SELECT INDEX_NAME AS name, NON_UNIQUE AS nonUnique, INDEX_TYPE AS method, IS_VISIBLE AS visible FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)} GROUP BY INDEX_NAME, NON_UNIQUE, INDEX_TYPE, IS_VISIBLE`;
-        break;
-      case "table":
-        text = `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
-        break;
-      default:
-        throw unsupportedCapability34({ dialect: "mysql", feature: `inspect:${object.kind}` });
-    }
+    if (object.kind === "constraint" && object.constraintType === "exclusion")
+      throw unsupportedCapability34({ dialect: "mysql", feature: "exclusionConstraints" });
+    const mysql = mysqlFactsText({ dialect, identity: object, namespace, name, collector });
+    if (mysql === undefined)
+      throw unsupportedCapability34({ dialect: "mysql", feature: `inspect:${object.kind}` });
+    text = mysql;
   } else {
     if (physical.namespace !== "main" && physical.namespace !== "temp")
       throw unsupportedCapability34({ dialect: "sqlite", feature: "attachedSchemaInspection" });
@@ -5669,18 +5808,103 @@ function objectQuery(params) {
   }
   return { text, values: collector.values, returning: "none" };
 }
-function renderMysqlObjectMembers(params) {
-  if (params.dialect.name !== "mysql")
-    return;
-  const object = params.identity;
+function mysqlFactsText(params) {
+  const { dialect, identity: object, namespace, name, collector } = params;
+  switch (object.kind) {
+    case "view":
+      return `SELECT VIEW_DEFINITION AS definition, CHECK_OPTION AS checkOption, SECURITY_TYPE AS securityType, DEFINER AS definer FROM information_schema.VIEWS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
+    case "trigger":
+      return `SELECT ACTION_STATEMENT AS definition, ACTION_TIMING AS timing, EVENT_MANIPULATION AS event, ACTION_ORDER AS actionOrder, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.TRIGGERS WHERE TRIGGER_SCHEMA = ${namespace} AND EVENT_OBJECT_TABLE = ${name} AND TRIGGER_NAME = ${collector.add(object.name)}`;
+    case "function":
+      return `SELECT ROUTINE_DEFINITION AS definition, DTD_IDENTIFIER AS result, IS_DETERMINISTIC AS deterministic, SQL_DATA_ACCESS AS dataAccess, SECURITY_TYPE AS securityType, SQL_MODE AS sqlMode, DEFINER AS definer FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ${namespace} AND ROUTINE_NAME = ${name} AND ROUTINE_TYPE = 'FUNCTION'`;
+    case "column":
+    case "columnDefault":
+    case "generatedColumn":
+      return `SELECT COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_DEFAULT AS definition, GENERATION_EXPRESSION AS ${dialect.quoteIdent({ name: "generated" })}, EXTRA AS extra, COLLATION_NAME AS collation FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND COLUMN_NAME = ${collector.add(object.column)}`;
+    case "constraint":
+      if (object.constraintType === "exclusion")
+        return;
+      return `SELECT tc.CONSTRAINT_TYPE AS type, tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS definition, rc.UPDATE_RULE AS onUpdate, rc.DELETE_RULE AS onDelete, rc.MATCH_OPTION AS matchOption FROM information_schema.TABLE_CONSTRAINTS tc LEFT JOIN information_schema.CHECK_CONSTRAINTS cc ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc ON rc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND rc.TABLE_NAME = tc.TABLE_NAME AND rc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME WHERE tc.TABLE_SCHEMA = ${namespace} AND tc.TABLE_NAME = ${name} AND tc.CONSTRAINT_NAME = ${collector.add(object.name)}`;
+    case "index":
+      return `SELECT INDEX_NAME AS name, NON_UNIQUE AS nonUnique, INDEX_TYPE AS method, IS_VISIBLE AS visible FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)} GROUP BY INDEX_NAME, NON_UNIQUE, INDEX_TYPE, IS_VISIBLE`;
+    case "table":
+      return `SELECT TABLE_TYPE AS type, ENGINE AS engine, TABLE_COLLATION AS collation FROM information_schema.TABLES WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name}`;
+    default:
+      return;
+  }
+}
+function mysqlMemberParts(params) {
+  const { identity: object, collector } = params;
   if (object.kind !== "function" && object.kind !== "index" && object.kind !== "constraint")
     return;
-  const collector = new ParamCollector(params.dialect);
   const physical = "table" in object ? object.table : object.name;
   const namespace = collector.add(physical.namespace);
   const name = collector.add(physical.name);
-  const text = object.kind === "function" ? `SELECT PARAMETER_MODE AS mode, PARAMETER_NAME AS name, DTD_IDENTIFIER AS type, CHARACTER_SET_NAME AS characterSet, COLLATION_NAME AS collation FROM information_schema.PARAMETERS WHERE SPECIFIC_SCHEMA = ${namespace} AND SPECIFIC_NAME = ${name} ORDER BY ORDINAL_POSITION` : object.kind === "index" ? `SELECT COLUMN_NAME AS name, EXPRESSION AS expression, SUB_PART AS prefixLength, COLLATION AS collation FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)} ORDER BY SEQ_IN_INDEX` : `SELECT COLUMN_NAME AS name, REFERENCED_TABLE_SCHEMA AS referenceNamespace, REFERENCED_TABLE_NAME AS referenceTable, REFERENCED_COLUMN_NAME AS referenceColumn FROM information_schema.KEY_COLUMN_USAGE WHERE CONSTRAINT_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND CONSTRAINT_NAME = ${collector.add(object.name)} ORDER BY ORDINAL_POSITION`;
-  return { text, values: collector.values, returning: "none" };
+  return object.kind === "function" ? { columns: "PARAMETER_MODE AS mode, PARAMETER_NAME AS name, DTD_IDENTIFIER AS type, CHARACTER_SET_NAME AS characterSet, COLLATION_NAME AS collation", source: `information_schema.PARAMETERS WHERE SPECIFIC_SCHEMA = ${namespace} AND SPECIFIC_NAME = ${name}`, ordinal: "ORDINAL_POSITION" } : object.kind === "index" ? { columns: "COLUMN_NAME AS name, EXPRESSION AS expression, SUB_PART AS prefixLength, COLLATION AS collation", source: `information_schema.STATISTICS WHERE TABLE_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND INDEX_NAME = ${collector.add(object.name)}`, ordinal: "SEQ_IN_INDEX" } : { columns: "COLUMN_NAME AS name, REFERENCED_TABLE_SCHEMA AS referenceNamespace, REFERENCED_TABLE_NAME AS referenceTable, REFERENCED_COLUMN_NAME AS referenceColumn", source: `information_schema.KEY_COLUMN_USAGE WHERE CONSTRAINT_SCHEMA = ${namespace} AND TABLE_NAME = ${name} AND CONSTRAINT_NAME = ${collector.add(object.name)}`, ordinal: "ORDINAL_POSITION" };
+}
+function renderMysqlObjectMembers(params) {
+  if (params.dialect.name !== "mysql")
+    return;
+  const collector = new ParamCollector(params.dialect);
+  const parts = mysqlMemberParts({ identity: params.identity, collector });
+  if (parts === undefined)
+    return;
+  return { text: `SELECT ${parts.columns} FROM ${parts.source} ORDER BY ${parts.ordinal}`, values: collector.values, returning: "none" };
+}
+var MYSQL_OBJECT_BATCH_SIZE = 100;
+var MYSQL_BATCH_NO_ROW_LIMIT = " LIMIT 18446744073709551615";
+function mysqlBatches(params) {
+  const batches = [];
+  for (const group of params.groups.values()) {
+    for (let offset = 0;offset < group.length; offset += MYSQL_OBJECT_BATCH_SIZE) {
+      const chunk = group.slice(offset, offset + MYSQL_OBJECT_BATCH_SIZE);
+      batches.push({
+        text: `${chunk.map((entry, index) => entry.branch(index)).join(" UNION ALL ")}${params.suffix}${MYSQL_BATCH_NO_ROW_LIMIT}`,
+        values: chunk.flatMap((entry) => entry.values),
+        returning: "none",
+        positions: chunk.map((entry) => entry.position)
+      });
+    }
+  }
+  return batches;
+}
+function renderMysqlObjectBatch(params) {
+  const { dialect } = params;
+  if (dialect.name !== "mysql")
+    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+  const position = dialect.quoteIdent({ name: "vibe_position" });
+  const groups = new Map;
+  for (const [index, identity] of params.identities.entries()) {
+    if (identity.kind === "namespace")
+      continue;
+    const physical = "table" in identity ? identity.table : identity.name;
+    const collector = new ParamCollector(dialect);
+    const text = mysqlFactsText({ dialect, identity, namespace: collector.add(physical.namespace), name: collector.add(physical.name), collector });
+    if (text === undefined)
+      continue;
+    const group = groups.get(text) ?? [];
+    group.push({ position: index, branch: (branch) => `SELECT ${branch} AS ${position}, q.* FROM (${text}) q`, values: collector.values });
+    groups.set(text, group);
+  }
+  return mysqlBatches({ groups, suffix: "" });
+}
+function renderMysqlObjectMembersBatch(params) {
+  const { dialect } = params;
+  if (dialect.name !== "mysql")
+    throw unsupportedCapability34({ dialect: dialect.name, feature: "batchedMigrationInspection" });
+  const position = dialect.quoteIdent({ name: "vibe_position" });
+  const ordinal = dialect.quoteIdent({ name: "vibe_ordinal" });
+  const groups = new Map;
+  for (const [index, identity] of params.identities.entries()) {
+    const collector = new ParamCollector(dialect);
+    const parts = mysqlMemberParts({ identity, collector });
+    if (parts === undefined)
+      continue;
+    const group = groups.get(identity.kind) ?? [];
+    group.push({ position: index, branch: (branch) => `SELECT ${branch} AS ${position}, ${parts.ordinal} AS ${ordinal}, ${parts.columns} FROM ${parts.source}`, values: collector.values });
+    groups.set(identity.kind, group);
+  }
+  return mysqlBatches({ groups, suffix: ` ORDER BY ${position}, ${ordinal}` });
 }
 function renderMigrationDependencies(params) {
   return dependencyQuery({ ...params, collector: new ParamCollector(params.dialect) });
@@ -5919,6 +6143,7 @@ export {
   SQLITE_SESSION_SQL,
   SQL_DEFAULT_CELL,
   SQL_DIALECTS,
+  SQL_KEEP_CELL,
   assertIndexExpressionVersion,
   assertSqlParamBuilding,
   chainVetoToken,
@@ -5940,6 +6165,7 @@ export {
   dbNowMarker,
   decode,
   decodeIsNoop,
+  decodedDateTimeRefusal,
   describeRowLock,
   encode,
   endsWithPattern,
@@ -5966,6 +6192,7 @@ export {
   isSqlCommand,
   isSqlDefaultCell,
   isSqlFragment,
+  isSqlKeepCell,
   isSqlParam,
   isSqlQuery,
   isStepColumnRef,
@@ -5977,6 +6204,7 @@ export {
   mysqlDialect,
   nativeEnumArrayParameter,
   parseDateTimeText,
+  parseExtendedDateTimeText,
   parseJsonText,
   parsePgArrayLiteral,
   parsePgArrayLiteralNested,
@@ -6024,7 +6252,9 @@ export {
   renderModuleJournal,
   renderMysqlCheckProbe,
   renderMysqlGeneratedColumnProbe,
+  renderMysqlObjectBatch,
   renderMysqlObjectMembers,
+  renderMysqlObjectMembersBatch,
   renderPostgresDefaultFunctionIdentity,
   renderPostgresDropGeneratedExpression,
   renderPostgresExplain,
@@ -6059,8 +6289,11 @@ export {
   renderShadowOperation,
   renderSqlFragment,
   renderSqliteColumnInventory,
+  renderSqliteColumnInventoryBatch,
   renderSqliteForeignKeyInventory,
+  renderSqliteForeignKeyInventoryBatch,
   renderSqliteFtsUpdateTrigger,
+  renderSqliteIntrospectionPragmaBatch,
   renderSqliteRebuildObjects,
   renderStatement,
   resolveIndexKeys,
@@ -6089,4 +6322,4 @@ export {
   toPgArrayLiteral
 };
 
-//# debugId=75BF4FE272330AE564756E2164756E21
+//# debugId=0FD86C4E8226D05064756E2164756E21