@vibeorm/sql 4.0.0 → 4.2.0

package/dist/index.js

@@ -1,4 +1,76 @@
 // @bun
+// packages/sql/src/timestamp-identity.ts
+var identities = new WeakMap;
+function rememberTimestampIdentity(params) {
+  const { date, text } = params;
+  const fraction = /\.(\d+)/.exec(text)?.[1] ?? "";
+  const remainder = fraction.slice(3).replace(/0+$/, "");
+  const canonical = Date.prototype.toISOString.call(date).replace(/(\.\d{3})Z$/, `$1${remainder}Z`);
+  identities.set(date, {
+    milliseconds: Date.prototype.getTime.call(date),
+    text,
+    ...params.numeric === undefined ? {} : { numeric: params.numeric },
+    key: params.key ?? `date:${canonical}`,
+    kind: params.kind ?? "timestamp"
+  });
+  return date;
+}
+function identityOf(params) {
+  const stored = identities.get(params.date);
+  if (stored !== undefined && stored.milliseconds !== Date.prototype.getTime.call(params.date)) {
+    identities.delete(params.date);
+    return;
+  }
+  return stored;
+}
+function timestampIdentityKey(params) {
+  return identityOf(params)?.key ?? `date:${Number.isFinite(Date.prototype.getTime.call(params.date)) ? Date.prototype.toISOString.call(params.date) : "invalid"}`;
+}
+function timestampIdentityText(params) {
+  const identity = identityOf(params);
+  return identity !== undefined && (params.kind === undefined || identity.kind === params.kind) ? identity.text : undefined;
+}
+function sqliteTimestampIdentityValue(params) {
+  const identity = identityOf(params);
+  return identity?.kind === "sqlite" ? identity.numeric ?? identity.text : undefined;
+}
+function compareTimestampDates(params) {
+  const left = identityOf({ date: params.left });
+  const right = identityOf({ date: params.right });
+  if (timestampIdentityKey({ date: params.left }) === timestampIdentityKey({ date: params.right }))
+    return 0;
+  const rank = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  if (left?.kind === "sqlite" || right?.kind === "sqlite") {
+    return left?.numeric !== undefined && right?.numeric !== undefined ? rank(left.numeric, right.numeric) : null;
+  }
+  const clock = (identity) => {
+    const [, hours, minutes, seconds, offset] = identity.key.split(":");
+    const [whole, fraction = ""] = seconds.split(".");
+    const local = BigInt(Number(hours) * 3600 + Number(minutes) * 60 + Number(whole)) * 1000000000n + BigInt(fraction.padEnd(9, "0"));
+    const zone = Number(offset);
+    return [local - BigInt(zone) * 1000000n, -zone];
+  };
+  if (left?.kind !== undefined && left.kind !== "timestamp" || right?.kind !== undefined && right.kind !== "timestamp") {
+    if (left === undefined || right === undefined || left.kind !== right.kind)
+      return null;
+    const a = clock(left);
+    const b = clock(right);
+    return rank(a[0], b[0]) || rank(a[1], b[1]);
+  }
+  const milliseconds = rank(Date.prototype.getTime.call(params.left), Date.prototype.getTime.call(params.right));
+  if (milliseconds !== 0)
+    return milliseconds;
+  const a = /\.(\d+)/.exec(left?.text ?? "")?.[1]?.slice(3) ?? "";
+  const b = /\.(\d+)/.exec(right?.text ?? "")?.[1]?.slice(3) ?? "";
+  return rank(a.padEnd(Math.max(a.length, b.length), "0"), b.padEnd(Math.max(a.length, b.length), "0"));
+}
+function cloneTimestampDate(params) {
+  const date = new Date(Date.prototype.getTime.call(params.date));
+  const identity = identityOf(params);
+  if (identity !== undefined)
+    identities.set(date, identity);
+  return date;
+}
 // packages/sql/src/native-enum-parameter.ts
 var NATIVE_ENUM_ARRAY_PARAMETER = Symbol("vibeorm.nativeEnumArrayParameter");
 function nativeEnumArrayParameter(params) {
@@ -234,24 +306,24 @@ function parseDateTimeText(params) {
   if (ZONE_LESS_DATETIME.test(trimmed)) {
     const asUtc = new Date(`${trimmed.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z`);
     if (!Number.isNaN(asUtc.getTime()))
-      return asUtc;
+      return rememberTimestampIdentity({ date: asUtc, text: trimmed });
   }
   const zoned = PG_ZONED_DATETIME.exec(trimmed);
   if (zoned !== null) {
     const [, date, time, fraction, hours, minutes] = zoned;
     const iso = new Date(`${date}T${time}${(fraction ?? "").slice(0, 4)}${hours}:${minutes ?? "00"}`);
     if (!Number.isNaN(iso.getTime()))
-      return iso;
+      return rememberTimestampIdentity({ date: iso, text: trimmed });
   }
   const parsed = new Date(trimmed);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+  return Number.isNaN(parsed.getTime()) ? undefined : rememberTimestampIdentity({ date: parsed, text: trimmed });
 }
 var dateNativeCodec = {
   encode: (value) => {
     if (value instanceof Date && !Number.isFinite(value.getTime()) || typeof value === "number" && !Number.isFinite(value) || typeof value === "string" && /^[+-]?infinity$/i.test(value.trim())) {
       throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require finite timestamps; use an extended timestamp encoder for infinity" });
     }
-    return value;
+    return value instanceof Date ? timestampIdentityText({ date: value }) ?? value : value;
   },
   decode: (value) => {
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
@@ -265,16 +337,27 @@ var dateTextCodec = {
     dateNativeCodec.encode(value);
     const date = value instanceof Date ? value : typeof value === "string" ? parseDateTimeText({ text: value }) : typeof value === "number" ? new Date(value) : undefined;
     if (date !== undefined && Number.isFinite(date.getTime()))
-      return date.toISOString();
+      return value instanceof Date ? sqliteTimestampIdentityValue({ date: value }) ?? date.toISOString() : date.toISOString();
     throw new VibeError({ code: "VIBE_VALIDATION", message: "DateTime parameters require a valid finite timestamp" });
   },
-  decode: dateNativeCodec.decode
+  decode: (value) => {
+    const date = dateNativeCodec.decode(value);
+    if (typeof value === "number")
+      return rememberTimestampIdentity({ date, text: date.toISOString(), numeric: value, key: `epoch:${value}`, kind: "sqlite" });
+    return typeof value === "string" ? rememberTimestampIdentity({ date, text: value, key: `date:${value}`, kind: "sqlite" }) : date;
+  }
 };
 var mysqlDateCodec = {
   encode: (value) => {
     dateNativeCodec.encode(value);
-    if (value instanceof Date)
+    if (value instanceof Date) {
+      const text = timestampIdentityText({ date: value, kind: "timestamp" });
+      if (text !== undefined) {
+        const fraction = /\.(\d+)/.exec(text)?.[1] ?? "";
+        return value.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, `.${fraction.padEnd(3, "0")}`);
+      }
       return value;
+    }
     if (typeof value === "number") {
       const parsed = new Date(value);
       if (!Number.isNaN(parsed.getTime()))
@@ -301,18 +384,26 @@ function makeTimeOfDayCodec(params) {
       if (date === undefined || !Number.isFinite(date.getTime())) {
         throw new VibeError({ code: "VIBE_VALIDATION", message: "a time-of-day DateTime parameter requires a valid finite Date", meta: { value } });
       }
-      return `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
+      return timestampIdentityText({ date, kind: params.zoned ? "timetz" : "time" }) ?? `${timeOfDayText(utcMillisecondOfDay(date))}${suffix}`;
     },
     decode: (value) => {
-      if (value instanceof Date && Number.isFinite(value.getTime()))
-        return new Date(utcMillisecondOfDay(value));
+      if (value instanceof Date && Number.isFinite(value.getTime())) {
+        if (timestampIdentityText({ date: value, kind: params.zoned ? "timetz" : "time" }) !== undefined)
+          return value;
+        const milliseconds = utcMillisecondOfDay(value);
+        const text = timeOfDayText(milliseconds);
+        return rememberTimestampIdentity({ date: new Date(milliseconds), text: `${text}${suffix}`, key: `${params.zoned ? "timetz" : "time"}:${text}:0`, kind: params.zoned ? "timetz" : "time" });
+      }
       const match = typeof value === "string" ? TIME_OF_DAY_TEXT.exec(value.trim()) : null;
       if (match !== null) {
         const [, hours, minutes, seconds, fraction, sign, offsetHours, offsetMinutes, offsetSeconds] = match;
         const millisecond = Number(hours) * 3600000 + Number(minutes) * 60000 + Number(seconds ?? 0) * 1000 + Number((fraction ?? "").slice(0, 3).padEnd(3, "0"));
         const offset = sign === undefined ? 0 : (sign === "-" ? -1 : 1) * (Number(offsetHours) * 3600000 + Number(offsetMinutes ?? 0) * 60000 + Number(offsetSeconds ?? 0) * 1000);
         if (millisecond <= MILLISECONDS_PER_DAY) {
-          return new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+          const date = new Date(((millisecond - offset) % MILLISECONDS_PER_DAY + MILLISECONDS_PER_DAY) % MILLISECONDS_PER_DAY);
+          const exactFraction = (fraction ?? "").padEnd(3, "0").replace(/(?<=\d{3})0+$/, "");
+          const key = `${params.zoned ? "timetz" : "time"}:${hours}:${minutes}:${seconds ?? "00"}.${exactFraction}:${offset}`;
+          return rememberTimestampIdentity({ date, text: value.trim(), key, kind: params.zoned ? "timetz" : "time" });
         }
       }
       throw new VibeError({ code: "VIBE_DATA_INVALID", message: "a time-of-day DateTime column returned a value that is not a time of day", meta: { value } });
@@ -435,12 +526,27 @@ var DIALECT_CODECS = {
 
 // packages/sql/src/result-decoder.ts
 var scalarContracts = new WeakMap;
+var decoderIdentities = new WeakMap;
+var nullableDecoders = new WeakMap;
+var arrayDecoders = new WeakMap;
+function sameResultDecoder(params) {
+  if (params.left === params.right)
+    return true;
+  const identity = decoderIdentities.get(params.left);
+  return identity !== undefined && identity === decoderIdentities.get(params.right);
+}
+function wrappedIdentity(params) {
+  const identity = decoderIdentities.get(params.decoder);
+  return identity === undefined ? undefined : JSON.stringify([params.kind, identity]);
+}
 function resultScalarContract(params) {
   return scalarContracts.get(params.decoder);
 }
 function registerScalar(params) {
   if (params.contract !== undefined)
     scalarContracts.set(params.decoder, Object.freeze(params.contract));
+  if (params.identity !== undefined)
+    decoderIdentities.set(params.decoder, params.identity);
   return params.decoder;
 }
 function wrappedContract(params) {
@@ -473,7 +579,7 @@ function scalar(type, valid) {
       refuse(encoding, `Invalid ${type} projection value`);
     return result;
   };
-  return registerScalar({ contract: { scalar: type, nullable: false, list: false }, decoder: Object.freeze({
+  return registerScalar({ identity: JSON.stringify(["scalar", type]), contract: { scalar: type, nullable: false, list: false }, decoder: Object.freeze({
     decode: (params) => convert(params, false),
     encode: (params) => {
       const value = type === "Json" ? params.value : convert(params, true);
@@ -485,7 +591,7 @@ function scalar(type, valid) {
 }
 var stringDecoder = scalar("String", (value) => typeof value === "string");
 var dateDecoder = scalar("DateTime", (value) => value instanceof Date && Number.isFinite(value.getTime()));
-var extendedDecoder = registerScalar({ contract: { scalar: "DateTime", nullable: false, list: false }, decoder: Object.freeze({
+var extendedDecoder = registerScalar({ identity: "extended-date-time", contract: { scalar: "DateTime", nullable: false, list: false }, decoder: Object.freeze({
   decode: (params) => {
     if (params.value === "infinity" || params.value === Infinity)
       return "infinity";
@@ -506,15 +612,21 @@ function hasEncoder(decoder) {
   return "encode" in decoder && typeof decoder.encode === "function";
 }
 function nullable({ decoder }) {
+  const cached = nullableDecoders.get(decoder);
+  if (cached !== undefined)
+    return cached;
   const read = (params) => params.value === null ? null : decoder.decode(params);
-  if (!hasEncoder(decoder))
-    return Object.freeze({ decode: read });
-  return registerScalar({ contract: wrappedContract({ decoder, nullable: true }), decoder: Object.freeze({
+  const wrapped = hasEncoder(decoder) ? registerScalar({ identity: wrappedIdentity({ decoder, kind: "nullable" }), contract: wrappedContract({ decoder, nullable: true }), decoder: Object.freeze({
     decode: read,
     encode: (params) => params.value === null ? null : decoder.encode(params)
-  }) });
+  }) }) : Object.freeze({ decode: read });
+  nullableDecoders.set(decoder, wrapped);
+  return wrapped;
 }
 function array({ decoder }) {
+  const cached = arrayDecoders.get(decoder);
+  if (cached !== undefined)
+    return cached;
   const bidirectional = hasEncoder(decoder);
   const read = (params) => {
     const raw = params.value;
@@ -534,16 +646,16 @@ function array({ decoder }) {
       refuse(false, "Expected an array projection");
     return value.map((element) => decoder.decode({ ...params, value: element }));
   };
-  if (!hasEncoder(decoder))
-    return Object.freeze({ decode: read });
-  return registerScalar({ contract: wrappedContract({ decoder, list: true }), decoder: Object.freeze({
+  const wrapped = hasEncoder(decoder) ? registerScalar({ identity: wrappedIdentity({ decoder, kind: "array" }), contract: wrappedContract({ decoder, list: true }), decoder: Object.freeze({
     decode: read,
     encode: (params) => {
       if (!Array.isArray(params.value))
         refuse(true, "Expected an array parameter");
       return params.value.map((value) => decoder.encode({ ...params, value }));
     }
-  }) });
+  }) }) : Object.freeze({ decode: read });
+  arrayDecoders.set(decoder, wrapped);
+  return wrapped;
 }
 var encode = Object.freeze({
   array: ({ encoder }) => Object.freeze({
@@ -569,7 +681,7 @@ var decode = Object.freeze({
   array,
   enum: ({ values }) => {
     const members = new Set(values);
-    return registerScalar({ contract: { scalar: "String", nullable: false, list: false }, decoder: Object.freeze({
+    return registerScalar({ identity: JSON.stringify(["enum", [...members].sort()]), contract: { scalar: "String", nullable: false, list: false }, decoder: Object.freeze({
       decode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(false, "Unknown enum projection member"),
       encode: ({ value }) => typeof value === "string" && members.has(value) ? value : refuse(true, "Unknown enum parameter member")
     }) });
@@ -590,10 +702,23 @@ var decode = Object.freeze({
   }
 });
 
+// packages/sql/src/sql-handles.ts
+var checks = new Set;
+function registerSqlHandleCheck(params) {
+  checks.add(params.check);
+}
+function isSqlHandle(value) {
+  for (const check of checks)
+    if (check(value))
+      return true;
+  return false;
+}
+
 // packages/sql/src/sql-input.ts
 var inputs = new WeakMap;
 var tokens = new WeakMap;
 var scopes = new WeakMap;
+registerSqlHandleCheck({ check: (value) => inputs.has(value) || tokens.has(value) || scopes.has(value) });
 function invalid(message) {
   throw new VibeError3({ code: "VIBE_VALIDATION", message });
 }
@@ -691,7 +816,7 @@ function snapshotSqlValue(value, ancestors = new Set, isHandle) {
   };
   if (isSqlParam(value))
     return invalid("SQL input tokens are valid only in admitted reusable builder positions");
-  if (isHandle !== undefined && typeof value === "object" && value !== null && isHandle(value))
+  if (typeof value === "object" && value !== null && (isSqlHandle(value) || isHandle?.(value)))
     return invalid("SQL builder, plan, template, input and fragment handles are not execution values");
   if (value === undefined)
     return invalid("SQL values cannot be undefined; omit a defaulted column or use null");
@@ -700,7 +825,7 @@ function snapshotSqlValue(value, ancestors = new Set, isHandle) {
   if (typeof value === "number")
     return value;
   if (value instanceof Date)
-    return Number.isFinite(value.getTime()) ? new Date(value.getTime()) : invalid("SQL dates must be finite");
+    return Number.isFinite(value.getTime()) ? cloneTimestampDate({ date: value }) : invalid("SQL dates must be finite");
   if (value instanceof Uint8Array)
     return new Uint8Array(value);
   if (typeof value !== "object")
@@ -1244,6 +1369,7 @@ var sqliteDialect = {
   rowLockSyntax: null,
   advisoryLockFunctions: null,
   rowDefaultKeyword: false,
+  emptyInsert: { form: "defaultValues", conflictClause: false },
   statementChain: null,
   paramBudget: 900,
   booleanLiteral: { true: "1", false: "0" },
@@ -1407,6 +1533,7 @@ var SQLITE_SESSION_SQL = Object.freeze({
 // packages/sql/src/composable.ts
 import { VibeError as VibeError9 } from "@vibeorm/schema";
 var fragments = new WeakMap;
+registerSqlHandleCheck({ check: (value) => fragments.has(value) });
 function invalid3(message) {
   throw new VibeError9({ code: "VIBE_VALIDATION", message });
 }
@@ -1492,7 +1619,7 @@ function renderSqlFragment(params) {
   const encode = (part) => {
     if (part.value === undefined)
       invalid3("SQL parameters cannot be undefined; use null explicitly");
-    return snapshotSqlValue(part.decoder === undefined ? part.value : part.decoder.encode({ value: part.value, dialect: dialect.name }));
+    return snapshotSqlValue(part.decoder === undefined ? part.value : part.decoder.encode({ value: snapshotSqlValue(part.value), dialect: dialect.name }));
   };
   const recording = isSqlBindingCollector({ collector });
   const recordValue = (part) => recordSqlBinding({
@@ -1580,6 +1707,7 @@ var queries = new WeakMap;
 var commands = new WeakMap;
 var reusableQueries = new WeakMap;
 var reusableCommands = new WeakMap;
+registerSqlHandleCheck({ check: (value) => queries.has(value) || commands.has(value) || reusableQueries.has(value) || reusableCommands.has(value) });
 function invalid4(message) {
   throw new VibeError10({ code: "VIBE_VALIDATION", message });
 }
@@ -2249,7 +2377,7 @@ function assertInt32(params) {
 var JSON_TRANSPORT = Object.freeze({ chunkSize: 100 });
 function projectionOutputName(params) {
   const { column } = params;
-  return column.transform === undefined || column.transform === "jsonText" ? column.alias ?? column.name : column.name;
+  return column.alias ?? column.name;
 }
 // packages/sql/src/dialects/postgres.ts
 var postgresDialect = {
@@ -2306,6 +2434,7 @@ var postgresDialect = {
     keyCast: Object.freeze({ single: "::bigint", pair: "::int4" })
   },
   rowDefaultKeyword: true,
+  emptyInsert: { form: "defaultValues", conflictClause: true },
   statementChain: "dataModifyingCte",
   paramBudget: 30000,
   booleanLiteral: { true: "true", false: "false" },
@@ -2368,6 +2497,7 @@ var mysqlDialect = {
   },
   advisoryLockFunctions: null,
   rowDefaultKeyword: true,
+  emptyInsert: { form: "emptyRow" },
   statementChain: null,
   paramBudget: 1e4,
   booleanLiteral: { true: "1", false: "0" },
@@ -2398,6 +2528,20 @@ var SQL_DIALECTS = {
 function getSqlDialect(params) {
   return SQL_DIALECTS[params.dialect];
 }
+// packages/sql/src/dialects/sqlite-json-equality.ts
+function renderSqliteJsonEquality(params) {
+  const q = (name) => params.dialect.quoteIdent({ name });
+  const values = q("__vibe_json_values");
+  const tree = q("__vibe_json_tree");
+  const paths = q("__vibe_json_paths");
+  const child = q("__vibe_json_child");
+  const parent = q("__vibe_json_parent");
+  const [side, id, parentId, key, type, atom, path] = ["side", "id", "parent", "key", "type", "atom", "path"].map(q);
+  const left = `${values}.${q("left")}`;
+  const right = `${values}.${q("right")}`;
+  return `(SELECT CASE WHEN ${left} IS NULL THEN NULL ELSE NOT EXISTS (` + `WITH RECURSIVE ${tree} AS (` + `SELECT 1 AS ${side}, ${id}, ${parentId}, ${key}, ${type}, ${atom} FROM json_tree(CASE WHEN json_valid(${left}) THEN ${left} ELSE 'null' END) ` + `UNION ALL SELECT -1 AS ${side}, ${id}, ${parentId}, ${key}, ${type}, ${atom} FROM json_tree(${right})` + `), ${paths} (${side}, ${id}, ${path}, ${type}, ${atom}) AS (` + `SELECT ${side}, ${id}, json_array(), ${type}, ${atom} FROM ${tree} WHERE ${parentId} IS NULL ` + `UNION ALL SELECT ${child}.${side}, ${child}.${id}, json_insert(${parent}.${path}, '$[#]', ${child}.${key}), ${child}.${type}, ${child}.${atom} ` + `FROM ${tree} AS ${child} JOIN ${paths} AS ${parent} ON ${child}.${side} = ${parent}.${side} AND ${child}.${parentId} = ${parent}.${id}` + `) SELECT 1 FROM ${paths} GROUP BY ${path}, CASE WHEN ${type} IN ('integer', 'real') THEN 'number' ELSE ${type} END, ${atom} HAVING SUM(${side}) <> 0` + `) END FROM (SELECT ${params.left} AS ${q("left")}, ${params.right} AS ${q("right")}) AS ${values})`;
+}
+
 // packages/sql/src/dialects/diagnostics.ts
 import { unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 var QUERIES = Object.freeze({
@@ -2501,7 +2645,7 @@ function requireArg(params) {
 import { unsupportedCapability as unsupportedCapability15 } from "@vibeorm/schema";
 
 // packages/sql/src/dialects/postgres-rls.ts
-import { RlsContextError, VibeError as VibeError14, assertValidSchemaIR, unsupportedCapability as unsupportedCapability14, validateRlsContextIR } from "@vibeorm/schema";
+import { RlsContextError, VibeError as VibeError14, assertNativeRlsAdmission, assertValidSchemaIR, unsupportedCapability as unsupportedCapability14, validateRlsContextIR } from "@vibeorm/schema";
 var NATIVE_RLS = Object.freeze({ policyName: "vibeorm_managed", tableSchema: "public", settingPrefix: "vibeorm.", parentAlias: "parent" });
 var COLUMN_TYPES = {
   String: { default: "text", native: { text: "text", varchar: "varchar", charactervarying: "varchar", uuid: "uuid" } },
@@ -2570,6 +2714,7 @@ function renderRlsColumnType(params) {
 }
 function protectedModel(params) {
   requireRls(params);
+  assertNativeRlsAdmission({ schema: params.schema, dialect: params.dialect.name });
   assertValidSchemaIR({ schema: params.schema });
   const model = params.schema.models.find((entry) => entry.name === params.model);
   if (model === undefined || model.rls === undefined || model.rls === "unprotected") {
@@ -2948,15 +3093,18 @@ function quoteProjection(dialect, column) {
     const alias = dialect.quoteIdent({ name: column.alias ?? column.name });
     return `${dialect.jsonTextProjection({ expression: ref })} AS ${alias}`;
   }
-  if (dialect.name !== "postgres") {
-    throw internalError2({ message: "ColRef.transform is a postgres construct" });
-  }
   const ref = quoteCol(dialect, column);
-  const alias = dialect.quoteIdent({ name: column.name });
+  const alias = dialect.quoteIdent({ name: column.alias ?? column.name });
   if (column.transform === "castText")
-    return `${ref}::text AS ${alias}`;
+    return `${textProjection({ dialect, expression: ref })} AS ${alias}`;
+  if (dialect.name !== "postgres") {
+    throw internalError2({ message: "encodeBase64 is a postgres construct" });
+  }
   return `encode(${ref}, 'base64') AS ${alias}`;
 }
+function textProjection(params) {
+  return params.dialect.name === "postgres" ? `${params.expression}::text` : `CAST(${params.expression} AS ${params.dialect.name === "mysql" ? "CHAR" : "TEXT"})`;
+}
 function renderProjection(params) {
   const { dialect, columns } = params;
   return columns.map((column) => quoteProjection(dialect, column)).join(", ");
@@ -3277,8 +3425,8 @@ function renderJsonFilter(params) {
       if (value !== null) {
         const target = `json_extract(${column}, ${collector.add(path)})`;
         const bound = typeof value === "boolean" ? value ? 1 : 0 : value;
-        const operand = typeof value === "object" ? `json(${collector.add(JSON.stringify(value))})` : collector.add(bound);
-        base = `(${guard} AND ${target} = ${operand})`;
+        const comparison = typeof value === "object" ? renderSqliteJsonEquality({ dialect, left: target, right: collector.add(JSON.stringify(value)) }) : `${target} = ${collector.add(bound)}`;
+        base = `(${guard} AND ${comparison})`;
       }
       return expr.negate === true ? `NOT (${base})` : base;
     };
@@ -3443,11 +3591,8 @@ function applyReturning(params) {
       const name = dialect.quoteIdent({ name: column.name });
       return `${dialect.jsonTextProjection({ expression: name })} AS ${name}`;
     }
-    if (dialect.name !== "postgres") {
-      throw internalError2({ message: "a castText RETURNING column is a postgres construct" });
-    }
     const name = dialect.quoteIdent({ name: column.name });
-    return `${name}::text AS ${name}`;
+    return `${textProjection({ dialect, expression: name })} AS ${name}`;
   }).join(", ");
   return { suffix: ` RETURNING ${columns}`, status: "native" };
 }
@@ -3484,6 +3629,10 @@ function renderKeyTableJoin(params) {
       switch (member.kind) {
         case "integer":
           return dialect.name === "mysql" ? `CAST(${placeholder} AS SIGNED)` : `CAST(${placeholder} AS bigint)`;
+        case "timestamp":
+          return `CAST(${placeholder} AS DATETIME(6))`;
+        case "time":
+          return `CAST(${placeholder} AS TIME(6))`;
         case "decimal":
           return `CAST(${placeholder} AS DECIMAL(65,${member.scale}))`;
         case "citext":
@@ -3513,7 +3662,9 @@ function renderSelect(params) {
   }
   if (statement.aggregates !== undefined) {
     for (const selection of statement.aggregates) {
-      columnList.push(`${renderAggRef(dialect, selection.agg)} AS ${dialect.quoteIdent({ name: selection.alias })}`);
+      const expression = renderAggRef(dialect, selection.agg);
+      const projected = selection.castText === true ? textProjection({ dialect, expression }) : expression;
+      columnList.push(`${projected} AS ${dialect.quoteIdent({ name: selection.alias })}`);
     }
   }
   if (statement.countSubqueries !== undefined) {
@@ -3610,12 +3761,20 @@ function renderSelect(params) {
 }
 function renderInsert(params) {
   const { dialect, statement, collector } = params;
-  if (statement.columns.length === 0) {
-    throw internalError2({ message: "insert requires at least one column" });
-  }
   if (statement.rows.length === 0) {
     throw internalError2({ message: "insert requires at least one row" });
   }
+  const defaultValues = statement.columns.length === 0 && dialect.emptyInsert.form === "defaultValues";
+  if (defaultValues && statement.rows.length !== 1) {
+    throw internalError2({ message: `${dialect.name} inserts an all-default row as DEFAULT VALUES, one row per statement` });
+  }
+  if (defaultValues && statement.onConflict !== undefined && !(dialect.emptyInsert.form === "defaultValues" && dialect.emptyInsert.conflictClause)) {
+    throw unsupportedCapability16({
+      dialect: dialect.name,
+      feature: "a conflict clause on an all-default row (DEFAULT VALUES)",
+      hint: "supply at least one column value, or drop the conflict clause"
+    });
+  }
   for (const row of statement.rows) {
     if (row.length !== statement.columns.length) {
       throw internalError2({
@@ -3642,7 +3801,7 @@ function renderInsert(params) {
     }
     return "DEFAULT";
   }).join(", ")})`).join(", ");
-  let text = `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) VALUES ${rowsSql}`;
+  let text = defaultValues ? `${insertKeyword} ${renderTable(dialect, statement.table)} DEFAULT VALUES` : `${insertKeyword} ${renderTable(dialect, statement.table)} (${columnList}) VALUES ${rowsSql}`;
   if (onConflict !== undefined && !("doNothing" in onConflict) && dialect.excludedRowRef.form === "rowAlias" && Object.values(onConflict.update).some((value) => isExcludedRef(value) || isSqlFragment(value) && sqlUsesIncoming({ fragment: value }))) {
     text += ` AS ${dialect.quoteIdent({ name: dialect.excludedRowRef.alias })}`;
   }
@@ -4417,8 +4576,13 @@ function renderIndexStateQuery(params) {
     text: `SELECT c.relname::text AS "index",
        t.relname::text AS "table",
        am.amname::text AS "method",
-       i.indisunique AS "unique",
-       i.indisvalid AS "valid",
+        i.indisunique AS "unique",
+        i.indnullsnotdistinct AS "nullsNotDistinct",
+        pg_catalog.array_to_json(ARRAY(SELECT pg_catalog.pg_get_indexdef(i.indexrelid, k.k, true)
+          FROM pg_catalog.generate_series(1, i.indnkeyatts) AS k(k) ORDER BY k.k))::text AS "keyColumns",
+        pg_catalog.array_to_json(ARRAY(SELECT pg_catalog.pg_get_indexdef(i.indexrelid, k.k, true)
+          FROM pg_catalog.generate_series(i.indnkeyatts + 1, i.indnatts) AS k(k) ORDER BY k.k))::text AS "includedColumns",
+        i.indisvalid AS "valid",
        i.indisready AS "ready",
        pg_catalog.pg_get_expr(i.indpred, i.indrelid) AS "predicate",
        pg_catalog.pg_get_indexdef(i.indexrelid) AS "definition",
@@ -4510,6 +4674,8 @@ export {
   SQL_DIALECTS,
   assertSqlParamBuilding,
   chainVetoToken,
+  cloneTimestampDate,
+  compareTimestampDates,
   compileExclusion,
   compileReusableSqlCommand,
   compileReusableSqlQuery,
@@ -4567,6 +4733,7 @@ export {
   projectionOutputName,
   recordSqlBinding,
   recordSqlBindingCheck,
+  registerSqlHandleCheck,
   renderAdvisoryLock,
   renderCheckProbe,
   renderColumnStateQuery,
@@ -4632,6 +4799,7 @@ export {
   renderStatement,
   resultScalarContract,
   returningColumnName,
+  sameResultDecoder,
   sealSqlInputScope,
   shortestFloat32,
   snapshotSqlValue,
@@ -4648,7 +4816,9 @@ export {
   strictMatchPattern,
   tableDefinitionParts,
   timeOfDayCodec,
+  timestampIdentityKey,
+  timestampIdentityText,
   toPgArrayLiteral
 };
 
-//# debugId=B8D70B32D9F5E99064756E2164756E21
+//# debugId=71705578A45D011664756E2164756E21