effect-qb 0.15.0 → 0.16.0

package/dist/mysql.js

@@ -24,6 +24,7 @@ __export(exports_column, {
   json: () => json,
   int: () => int,
   generated: () => generated2,
+  driverValueMapping: () => driverValueMapping2,
   default: () => default_2,
   datetime: () => datetime,
   date: () => date,
@@ -76,6 +77,7 @@ var makeColumnDefinition = (schema, metadata) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
     kind: "scalar",
@@ -95,6 +97,7 @@ var makeColumnDefinition = (schema, metadata) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -111,6 +114,7 @@ var remapColumnDefinition = (column, options = {}) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect
   };
@@ -129,6 +133,7 @@ var remapColumnDefinition = (column, options = {}) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -150,6 +155,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
     runtime: undefined,
     dbType: column.metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: column.metadata.driverValueMapping,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     kind: "scalar",
@@ -238,6 +244,10 @@ var ddlType = (sqlType) => (column) => mapColumn(column, {
   ...column.metadata,
   ddlType: sqlType
 });
+var driverValueMapping = (mapping) => (column) => mapColumn(column, {
+  ...column.metadata,
+  driverValueMapping: mapping
+});
 var array = (options) => (column) => remapColumnDefinition(column, {
   schema: Schema2.Array(options?.nullableElements ? Schema2.NullOr(column.schema) : column.schema),
   metadata: {
@@ -600,6 +610,7 @@ var primaryKey2 = primaryKey;
 var unique2 = unique;
 var default_2 = default_;
 var generated2 = generated;
+var driverValueMapping2 = driverValueMapping;
 var references2 = references;
 var schema2 = schema;
 // src/mysql/errors/index.ts
@@ -110274,6 +110285,7 @@ var emptyContext = () => ({
   nullKeys: new Set,
   eqLiterals: new Map,
   neqLiterals: new Map,
+  literalSets: new Map,
   sourceNames: new Set,
   contradiction: false,
   unknown: false
@@ -110283,6 +110295,7 @@ var cloneContext = (context) => ({
   nullKeys: new Set(context.nullKeys),
   eqLiterals: new Map(context.eqLiterals),
   neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
+  literalSets: new Map(Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
@@ -110316,7 +110329,12 @@ var addEqLiteral = (context, key, value) => {
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
+  const existingSet = context.literalSets.get(key);
+  if (existingSet !== undefined && !existingSet.has(value)) {
+    context.contradiction = true;
+  }
   context.eqLiterals.set(key, value);
+  context.literalSets.set(key, new Set([value]));
 };
 var addNeqLiteral = (context, key, value) => {
   addNonNull(context, key);
@@ -110327,6 +110345,18 @@ var addNeqLiteral = (context, key, value) => {
   values.add(value);
   context.neqLiterals.set(key, values);
 };
+var addLiteralSet = (context, key, values) => {
+  addNonNull(context, key);
+  const existingEq = context.eqLiterals.get(key);
+  if (existingEq !== undefined && !values.has(existingEq)) {
+    context.contradiction = true;
+  }
+  const existing = context.literalSets.get(key);
+  context.literalSets.set(key, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
+  if (context.literalSets.get(key)?.size === 0) {
+    context.contradiction = true;
+  }
+};
 var applyEqColumn = (context, left, right) => {
   const leftValue = context.eqLiterals.get(left);
   const rightValue = context.eqLiterals.get(right);
@@ -110366,6 +110396,9 @@ var applyAtom = (context, atom) => {
     case "neq-literal":
       addNeqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addLiteralSet(context, atom.key, new Set(atom.values));
+      return;
     case "eq-column":
       applyEqColumn(context, atom.left, atom.right);
       return;
@@ -110388,6 +110421,9 @@ var applyNegativeAtom = (context, atom) => {
     case "neq-literal":
       addEqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addNonNull(context, atom.key);
+      return;
     case "eq-column":
       addNonNull(context, atom.left);
       addNonNull(context, atom.right);
@@ -110420,6 +110456,17 @@ var intersectNeqLiterals = (left, right) => {
   }
   return result;
 };
+var unionLiteralSets = (left, right) => {
+  const result = new Map;
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key);
+    if (rightValues === undefined) {
+      continue;
+    }
+    result.set(key, new Set([...leftValues, ...rightValues]));
+  }
+  return result;
+};
 var intersectContexts = (left, right) => {
   if (left.contradiction) {
     return cloneContext(right);
@@ -110432,6 +110479,7 @@ var intersectContexts = (left, right) => {
     nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    literalSets: unionLiteralSets(left.literalSets, right.literalSets),
     sourceNames: new Set(Array.from(left.sourceNames).filter((name) => right.sourceNames.has(name))),
     contradiction: false,
     unknown: left.unknown || right.unknown
@@ -110505,6 +110553,45 @@ var columnKeyOfExpression = (value) => {
   const ast = astOf(value);
   return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
 };
+var sameDbType = (left, right) => left.dialect === right.dialect && left.kind === right.kind;
+var jsonPathPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  switch (ast.kind) {
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText": {
+      const jsonAst = ast;
+      const segments = jsonAst.segments;
+      if (segments.length === 0 || segments.length > 8) {
+        return;
+      }
+      const path = [];
+      for (const segment of segments) {
+        if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
+          return;
+        }
+        path.push(segment.key);
+      }
+      if (path.length === 0) {
+        return;
+      }
+      const baseKey = columnKeyOfExpression(jsonAst.base);
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.join(".")}`;
+    }
+    default:
+      return;
+  }
+};
+var predicateKeyOfExpression = (value) => columnKeyOfExpression(value) ?? castPredicateKeyOfExpression(value) ?? jsonPathPredicateKeyOfExpression(value);
+var castPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  if (ast.kind !== "cast") {
+    return;
+  }
+  const source = ast.value;
+  return sameDbType(source[TypeId].dbType, ast.target) ? predicateKeyOfExpression(source) : undefined;
+};
 var valueKeyOfLiteral = (value) => {
   if (typeof value === "string") {
     return `string:${value}`;
@@ -110524,7 +110611,7 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = columnKeyOfExpression(value);
+  const key = predicateKeyOfExpression(value);
   return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
 };
 var combineFacts = (left, right) => {
@@ -110537,8 +110624,8 @@ var combineFacts = (left, right) => {
   return andFormula(left, right);
 };
 var formulaOfEq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110585,8 +110672,8 @@ var formulaOfEq = (left, right) => {
   });
 };
 var formulaOfNeq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110629,8 +110716,8 @@ var formulaOfNeq = (left, right) => {
   return combineFacts(nonNullFactsOfExpression(left), nonNullFactsOfExpression(right));
 };
 var formulaOfIsNotDistinctFrom = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -110736,11 +110823,11 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
     }
     case "isNotNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
     }
     case "not":
@@ -110759,7 +110846,15 @@ var formulaOfExpression = (value) => {
       return anyFormula(ast.values.map((value2) => formulaOfExpression(value2)));
     case "in": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? falseFormula() : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      if (left === undefined) {
+        return falseFormula();
+      }
+      const key = predicateKeyOfExpression(left);
+      const literalValues = rest.map((entry) => {
+        const entryAst = astOf(entry);
+        return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined;
+      });
+      return key !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
@@ -110823,6 +110918,7 @@ var makeExpression = (state, ast) => {
     runtime: state.runtime,
     dbType: state.dbType,
     runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
     nullability: state.nullability,
     dialect: state.dialect,
     kind: state.kind ?? "scalar",
@@ -110831,7 +110927,7 @@ var makeExpression = (state, ast) => {
   expression[TypeId2] = ast;
   return expression;
 };
-var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState) => {
+var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState, _facts) => {
   const plan = Object.create(PlanProto);
   Object.defineProperty(plan, "pipe", {
     configurable: true,
@@ -110847,6 +110943,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     availableNames: undefined,
     grouped: undefined,
     assumptions: _assumptions ?? trueFormula(),
+    facts: _facts ?? undefined,
     capabilities: undefined,
     statement: _statement ?? "select",
     target: _target ?? undefined,
@@ -112326,6 +112423,34 @@ var toDialectExpression = (value) => {
   }
   return literal(value);
 };
+var retargetLiteralExpression = (value, target) => {
+  const ast = value[TypeId2];
+  if (ast.kind !== "literal") {
+    return value;
+  }
+  const targetState = target[TypeId];
+  return makeExpression({
+    runtime: value[TypeId].runtime,
+    dbType: targetState.dbType,
+    runtimeSchema: targetState.runtimeSchema,
+    driverValueMapping: targetState.driverValueMapping,
+    nullability: value[TypeId].nullability,
+    dialect: targetState.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast);
+};
+var alignBinaryPredicateExpressions = (left, right) => {
+  const leftAst = left[TypeId2];
+  const rightAst = right[TypeId2];
+  if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+    return [retargetLiteralExpression(left, right), right];
+  }
+  if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+    return [left, retargetLiteralExpression(right, left)];
+  }
+  return [left, right];
+};
 var toDialectStringExpression = (value) => typeof value === "string" ? literal(value) : value;
 var toDialectNumericExpression = (value) => typeof value === "number" ? literal(value) : value;
 var flattenVariadicBooleanExpressions = (kind, values) => {
@@ -112394,8 +112519,7 @@ var extractRequiredFromDialectNumericInputRuntime = (value) => {
   return Object.keys(expression[TypeId].dependencies);
 };
 var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
-  const leftExpression = toDialectExpression(left);
-  const rightExpression = toDialectExpression(right);
+  const [leftExpression, rightExpression] = alignBinaryPredicateExpressions(toDialectExpression(left), toDialectExpression(right));
   return makeExpression({
     runtime: true,
     dbType: profile.boolDb,
@@ -112411,16 +112535,18 @@ var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
 };
 var buildVariadicPredicate = (values, kind) => {
   const expressions = values.map((value) => toDialectExpression(value));
+  const [head, ...tail] = expressions;
+  const alignedExpressions = head !== undefined && (kind === "in" || kind === "notIn" || kind === "between") ? [head, ...tail.map((value) => retargetLiteralExpression(value, head))] : expressions;
   return makeExpression({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "maybe",
-    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+    dialect: alignedExpressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
     kind: "scalar",
-    dependencies: mergeManyDependencies(expressions)
+    dependencies: mergeManyDependencies(alignedExpressions)
   }, {
     kind,
-    values: expressions
+    values: alignedExpressions
   });
 };
 var eq = (...args) => {
@@ -112541,6 +112667,7 @@ var cast = (value, target) => {
     runtime: undefined,
     dbType: target,
     runtimeSchema: undefined,
+    driverValueMapping: target.driverValueMapping,
     nullability: expression[TypeId].nullability,
     dialect: expression[TypeId].dialect,
     kind: expression[TypeId].kind,
@@ -112590,6 +112717,10 @@ var custom2 = (kind) => ({
   dialect: profile.dialect,
   kind
 });
+var driverValueMapping3 = (dbType, mapping) => ({
+  ...dbType,
+  driverValueMapping: mapping
+});
 var type = {
   ...profile.type,
   array: array2,
@@ -112599,7 +112730,8 @@ var type = {
   domain,
   enum: enum_,
   set,
-  custom: custom2
+  custom: custom2,
+  driverValueMapping: driverValueMapping3
 };
 var makeJsonDb = (kind) => ({
   dialect: profile.dialect,
@@ -113112,6 +113244,8 @@ var scalar = (plan) => {
   return makeExpression({
     runtime: undefined,
     dbType: expression[TypeId].dbType,
+    runtimeSchema: expression[TypeId].runtimeSchema,
+    driverValueMapping: expression[TypeId].driverValueMapping,
     nullability: "maybe",
     dialect: profile.dialect,
     kind: "scalar",
@@ -113340,6 +113474,7 @@ var excluded = (value) => {
     runtime: undefined,
     dbType: value[TypeId].dbType,
     runtimeSchema: value[TypeId].runtimeSchema,
+    driverValueMapping: value[TypeId].driverValueMapping,
     nullability: value[TypeId].nullability,
     dialect: profile.dialect,
     kind: "scalar",
@@ -113351,11 +113486,13 @@ var excluded = (value) => {
 };
 var toMutationValueExpression = (value, column2) => {
   if (value !== null && typeof value === "object" && TypeId in value) {
-    return value;
+    return retargetLiteralExpression(value, column2);
   }
   return makeExpression({
     runtime: value,
     dbType: column2[TypeId].dbType,
+    runtimeSchema: column2[TypeId].runtimeSchema,
+    driverValueMapping: column2[TypeId].driverValueMapping,
     nullability: value === null ? "always" : "never",
     dialect: column2[TypeId].dialect,
     kind: "scalar",
@@ -113397,6 +113534,7 @@ var makeColumnReferenceSelection = (alias2, selection) => {
       runtime: undefined,
       dbType: state.dbType,
       runtimeSchema: state.runtimeSchema,
+      driverValueMapping: state.driverValueMapping,
       nullability: state.nullability,
       dialect: state.dialect,
       kind: "scalar",
@@ -113785,10 +113923,13 @@ import * as Stream2 from "effect/Stream";
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import * as Schema8 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 import * as SqlClient from "@effect/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
+// src/internal/runtime/driver-value-mapping.ts
+import * as Schema7 from "effect/Schema";
+
 // src/internal/runtime/normalize.ts
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var pad = (value, width = 2) => value.toString().padStart(width, "0");
@@ -114080,20 +114221,141 @@ var normalizeDbValue = (dbType, value) => {
   }
 };
 
+// src/internal/runtime/driver-value-mapping.ts
+var runtimeTagOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base);
+  }
+  if ("element" in dbType) {
+    return "array";
+  }
+  if ("fields" in dbType) {
+    return "record";
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json";
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string";
+  }
+  return dbType.runtime;
+};
+var familyOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base);
+  }
+  return dbType.family;
+};
+var mappingCandidates = (context) => {
+  const dbType = context.dbType;
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  const family = familyOfDbType(dbType);
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ];
+};
+var findMapping = (context, key2) => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key2];
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return;
+};
+var encodeWithSchema = (schema4, value) => {
+  if (schema4 === undefined) {
+    return { value, encoded: false };
+  }
+  if (!Schema7.is(schema4)(value)) {
+    return { value, encoded: false };
+  }
+  return {
+    value: Schema7.encodeUnknownSync(schema4)(value),
+    encoded: true
+  };
+};
+var toDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const encoded = encodeWithSchema(context.runtimeSchema, value);
+  let current = encoded.value;
+  const custom3 = findMapping(context, "toDriver");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(current, dbType);
+  }
+  return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
+};
+var fromDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "fromDriver");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(value, dbType);
+  }
+  return dbType === undefined ? value : normalizeDbValue(dbType, value);
+};
+var textCast = (sql) => `(${sql})::text`;
+var postgresJsonSql = (sql, dbType) => {
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  switch (runtimeTag) {
+    case "bigintString":
+    case "decimalString":
+    case "localDate":
+    case "localTime":
+    case "offsetTime":
+    case "localDateTime":
+    case "instant":
+    case "year":
+      return textCast(sql);
+    case "bytes":
+      return `encode(${sql}, 'base64')`;
+    default:
+      return sql;
+  }
+};
+var renderSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "selectSql");
+  return custom3 !== undefined && dbType !== undefined ? custom3(sql, dbType) : sql;
+};
+var renderJsonSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom3 = findMapping(context, "jsonSelectSql");
+  if (custom3 !== undefined && dbType !== undefined) {
+    return custom3(sql, dbType);
+  }
+  return context.dialect === "postgres" && dbType !== undefined ? postgresJsonSql(sql, dbType) : sql;
+};
+
 // src/internal/runtime/schema.ts
-import * as Schema7 from "effect/Schema";
+import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema7.String;
+      return Schema8.String;
     case "number":
-      return Schema7.Number;
+      return Schema8.Number;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema7.Boolean;
+      return Schema8.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -114111,16 +114373,16 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema7.Uint8ArrayFromSelf;
+      return Schema8.Uint8ArrayFromSelf;
     case "array":
-      return Schema7.Array(Schema7.Unknown);
+      return Schema8.Array(Schema8.Unknown);
     case "record":
-      return Schema7.Record({
-        key: Schema7.String,
-        value: Schema7.Unknown
+      return Schema8.Record({
+        key: Schema8.String,
+        value: Schema8.Unknown
       });
     case "null":
-      return Schema7.Null;
+      return Schema8.Null;
     case "unknown":
       return;
   }
@@ -114133,22 +114395,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema7.Array(runtimeSchemaForDbType(dbType.element) ?? Schema7.Unknown);
+    return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema7.Unknown]));
-    return Schema7.Struct(fields2);
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
+    return Schema8.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema7.String;
+    return Schema8.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema7.make(ast);
+var makeSchemaFromAst = (ast) => Schema8.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -114246,7 +114508,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema7.Union(...resolved);
+  return Schema8.Union(...resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -114281,9 +114543,9 @@ var jsonCompatibleSchema = (schema4) => {
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
-  return Schema7.Struct(fields2);
+  return Schema8.Struct(fields2);
 };
-var buildTupleSchema = (values2, context) => Schema7.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema8.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -114323,10 +114585,10 @@ var deriveRuntimeSchema = (expression, context) => {
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema7.Null;
+        return Schema8.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema7.Literal(ast.value);
+        return Schema8.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -114362,7 +114624,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema7.Boolean;
+      return Schema8.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -114371,10 +114633,10 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema7.String;
+      return Schema8.String;
     case "count":
     case "jsonLength":
-      return Schema7.Number;
+      return Schema8.Number;
     case "max":
     case "min":
       return expressionRuntimeSchema(ast.value, context);
@@ -114387,7 +114649,7 @@ var deriveRuntimeSchema = (expression, context) => {
       return selection === undefined ? undefined : expressionRuntimeSchema(selection, context);
     }
     case "window":
-      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : Schema7.Number;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : Schema8.Number;
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -114419,7 +114681,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonToJsonb":
       return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema7.Array(Schema7.String);
+      return Schema8.Array(Schema8.String);
   }
 };
 var expressionRuntimeSchema = (expression, context) => {
@@ -114522,11 +114784,17 @@ var effectiveRuntimeNullability = (expression, scope) => {
   }
   return hasOptionalSourceDependency(expression, scope) ? "maybe" : nullability;
 };
-var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode) => {
+var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode, valueMappings) => {
   let normalized = raw;
   if (driverMode === "raw") {
     try {
-      normalized = normalizeDbValue(expression[TypeId].dbType, raw);
+      normalized = fromDriverValue(raw, {
+        dialect: rendered.dialect,
+        dbType: expression[TypeId].dbType,
+        runtimeSchema: expression[TypeId].runtimeSchema,
+        driverValueMapping: expression[TypeId].driverValueMapping,
+        valueMappings
+      });
     } catch (cause) {
       throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
     }
@@ -114545,11 +114813,11 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (schema4 === undefined) {
     return normalized;
   }
-  if (Schema8.is(schema4)(normalized)) {
+  if (Schema9.is(schema4)(normalized)) {
     return normalized;
   }
   try {
-    return Schema8.decodeUnknownSync(schema4)(normalized);
+    return Schema9.decodeUnknownSync(schema4)(normalized);
   } catch (cause) {
     throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
   }
@@ -114558,6 +114826,7 @@ var makeRowDecoder = (rendered, plan, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
   const byAlias = new Map(projections.map((projection) => [projection.alias, projection.expression]));
   const driverMode = options2.driverMode ?? "raw";
+  const valueMappings = options2.valueMappings ?? rendered.valueMappings;
   const scope = resolveImplicationScope(plan[TypeId3].available, getQueryState(plan).assumptions);
   return (row) => {
     const decoded = {};
@@ -114569,7 +114838,7 @@ var makeRowDecoder = (rendered, plan, options2 = {}) => {
       if (expression === undefined) {
         continue;
       }
-      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode));
+      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode, valueMappings));
     }
     return decoded;
   };
@@ -114628,6 +114897,7 @@ function make5(dialect, render) {
         sql: rendered.sql,
         params: rendered.params ?? [],
         projections,
+        valueMappings: rendered.valueMappings,
         dialect,
         [TypeId8]: {
           row: undefined,
@@ -114640,14 +114910,19 @@ function make5(dialect, render) {
 
 // src/mysql/internal/dialect.ts
 var quoteIdentifier = (value) => `\`${value.replaceAll("`", "``")}\``;
-var renderLiteral = (value, state) => {
-  if (value === null) {
+var renderLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "mysql",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
     return "null";
   }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false";
   }
-  state.params.push(value);
+  state.params.push(driverValue);
   return "?";
 };
 var mysqlDialect = {
@@ -114941,6 +115216,21 @@ var renderPostgresJsonValue = (value, state, dialect) => {
   const rendered = renderExpression(value, state, dialect);
   return value[TypeId].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
+var expressionDriverContext = (expression, state, dialect) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[TypeId].dbType,
+  runtimeSchema: expression[TypeId].runtimeSchema,
+  driverValueMapping: expression[TypeId].driverValueMapping
+});
+var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
+var encodeArrayValues = (values2, column2, state, dialect) => values2.map((value) => toDriverValue(value, {
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: column2.metadata.dbType,
+  runtimeSchema: column2.schema,
+  driverValueMapping: column2.metadata.driverValueMapping
+}));
 var renderPostgresJsonKind = (value) => value[TypeId].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue2(value)) {
@@ -115069,7 +115359,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       const entries = Array.isArray(ast.entries) ? ast.entries : [];
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ]);
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`;
@@ -115081,7 +115371,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonBuildArray": {
       const values2 = Array.isArray(ast.values) ? ast.values : [];
-      const renderedValues = values2.map((value) => renderExpression(value, state, dialect)).join(", ");
+      const renderedValues = values2.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -115095,7 +115385,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`;
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -115106,7 +115396,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`;
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -115293,7 +115583,7 @@ var renderSelectionList = (selection, state, dialect, validateAggregation) => {
   }
   const flattened = flattenSelection(selection);
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
+  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
     sql,
     projections
@@ -115373,11 +115663,11 @@ var renderQueryAst = (ast, state, dialect) => {
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields2 = table[TypeId4].fields;
-          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields2[entry.columnName].metadata.dbType)}[])`).join(", ");
+          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields2[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index4) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index4], state)).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index4) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index4], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -115638,7 +115928,7 @@ var renderExpression = (expression, state, dialect) => {
     case "column":
       return ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
     case "literal":
-      return dialect.renderLiteral(ast.value, state);
+      return dialect.renderLiteral(ast.value, state, expression[TypeId]);
     case "excluded":
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
     case "cast":
@@ -115774,9 +116064,10 @@ var renderExpression = (expression, state, dialect) => {
 };
 
 // src/mysql/internal/renderer.ts
-var renderMysqlPlan = (plan) => {
+var renderMysqlPlan = (plan, options2 = {}) => {
   const state = {
     params: [],
+    valueMappings: options2.valueMappings,
     ctes: [],
     cteNames: new Set
   };
@@ -115784,7 +116075,8 @@ var renderMysqlPlan = (plan) => {
   return {
     sql: rendered.sql,
     params: state.params,
-    projections: rendered.projections
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
   };
 };
 
@@ -115794,12 +116086,12 @@ var withSavepoint2 = withSavepoint;
 function driver2(executeOrHandlers) {
   return driver("mysql", executeOrHandlers);
 }
-var fromDriver = (renderer, sqlDriver, driverMode = "raw") => ({
+var fromDriver = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
   dialect: "mysql",
   execute(plan) {
     const rendered = renderer.render(plan);
     return Effect2.mapError(Effect2.flatMap(sqlDriver.execute(rendered), (rows) => Effect2.try({
-      try: () => decodeRows(rendered, plan, rows, { driverMode }),
+      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -115812,7 +116104,7 @@ var fromDriver = (renderer, sqlDriver, driverMode = "raw") => ({
   stream(plan) {
     const rendered = renderer.render(plan);
     return Stream2.mapError(Stream2.mapChunksEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeChunk(rendered, plan, rows, { driverMode }),
+      try: () => decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -115829,9 +116121,9 @@ var sqlClientDriver = () => driver2({
 });
 function make6(options2 = {}) {
   if (options2.driver) {
-    return fromDriver(options2.renderer ?? make5("mysql", renderMysqlPlan), options2.driver, options2.driverMode);
+    return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), options2.driver, options2.driverMode, options2.valueMappings);
   }
-  return fromDriver(options2.renderer ?? make5("mysql", renderMysqlPlan), sqlClientDriver(), options2.driverMode);
+  return fromDriver(options2.renderer ?? make5("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options2.valueMappings })), sqlClientDriver(), options2.driverMode, options2.valueMappings);
 }
 var custom3 = (execute) => make4("mysql", execute);
 // src/mysql/query.ts
@@ -115967,7 +116259,7 @@ __export(exports_renderer2, {
   make: () => make8,
   TypeId: () => TypeId8
 });
-var make8 = () => make5("mysql", renderMysqlPlan);
+var make8 = (options3 = {}) => make5("mysql", (plan) => renderMysqlPlan(plan, options3));
 var mysql = make8();
 export {
   exports_table2 as Table,