effect-qb 0.19.0 → 4.0.0-beta.92

package/src/mysql/column.ts

@@ -16,7 +16,7 @@ import {
 import { mysqlDatatypes } from "./datatypes/index.js"
 
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -41,11 +41,11 @@ const renderNumericDdlType = (
     : `${kind}(${options.precision},${options.scale})`
 }
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: enrichDbType(mysqlDatatypes, dbType),
     nullable: false,
     hasDefault: false,
@@ -57,7 +57,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, mysqlDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), mysqlDatatypes.uuid())
 export const text = () => primitive(Schema.String, mysqlDatatypes.text())
 export const int = () => primitive(Schema.Int, mysqlDatatypes.int())
 export const number = (options?: BaseColumn.NumericOptions) =>
@@ -76,8 +76,8 @@ export const boolean = () => primitive(Schema.Boolean, mysqlDatatypes.boolean())
 export const date = () => primitive(LocalDateStringSchema, mysqlDatatypes.date())
 export const datetime = () => primitive(LocalDateTimeStringSchema, mysqlDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, mysqlDatatypes.timestamp())
-export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: { ...mysqlDatatypes.json(), variant: "json" } as Expression.DbType.Json<"mysql", "json">,
     nullable: false,
     hasDefault: false,

package/src/mysql/datatypes/index.ts

@@ -15,6 +15,7 @@ const withMetadata = <Kind extends keyof typeof mysqlDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }

package/src/mysql/datatypes/spec.ts

@@ -1,180 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  mysqlDatatypeFamilies as matrixMysqlDatatypeFamilies,
+  mysqlDatatypeKinds as matrixMysqlDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const mysqlDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "datetime",
-      "timestamp",
-      "year",
-      "binary",
-      "json",
-      "bit",
-      "enum",
-      "set",
-      "null"
-    ],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "text", "boolean", "date", "time", "datetime", "timestamp", "year", "bit"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "text", "numeric"],
-    traits: {}
-  },
-  bit: {
-    compareGroup: "bit",
-    castTargets: ["bit", "text", "numeric"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "datetime", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "datetime", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  datetime: {
-    compareGroup: "datetime",
-    castTargets: ["datetime", "timestamp", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  timestamp: {
-    compareGroup: "timestamp",
-    castTargets: ["timestamp", "datetime", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  year: {
-    compareGroup: "year",
-    castTargets: ["year", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  binary: {
-    compareGroup: "binary",
-    castTargets: ["binary", "text"],
-    traits: {}
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  spatial: {
-    compareGroup: "spatial",
-    castTargets: ["spatial", "text"],
-    traits: {}
-  },
-  enum: {
-    compareGroup: "enum",
-    castTargets: ["enum", "text"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  set: {
-    compareGroup: "set",
-    castTargets: ["set", "text"],
-    traits: {
-      textual: true
-    }
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "bit",
-      "date",
-      "time",
-      "datetime",
-      "timestamp",
-      "year",
-      "binary",
-      "json",
-      "spatial",
-      "enum",
-      "set",
-      "null"
-    ],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const mysqlDatatypeKinds = {
-  char: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  tinytext: { family: "text", runtime: "string" },
-  text: { family: "text", runtime: "string" },
-  mediumtext: { family: "text", runtime: "string" },
-  longtext: { family: "text", runtime: "string" },
-  tinyint: { family: "numeric", runtime: "number" },
-  smallint: { family: "numeric", runtime: "number" },
-  mediumint: { family: "numeric", runtime: "number" },
-  int: { family: "numeric", runtime: "number" },
-  integer: { family: "numeric", runtime: "number" },
-  bigint: { family: "numeric", runtime: "bigintString" },
-  decimal: { family: "numeric", runtime: "decimalString" },
-  dec: { family: "numeric", runtime: "decimalString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  fixed: { family: "numeric", runtime: "decimalString" },
-  float: { family: "numeric", runtime: "number" },
-  double: { family: "numeric", runtime: "number" },
-  real: { family: "numeric", runtime: "number" },
-  bool: { family: "boolean", runtime: "boolean" },
-  boolean: { family: "boolean", runtime: "boolean" },
-  bit: { family: "bit", runtime: "string" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  datetime: { family: "datetime", runtime: "localDateTime" },
-  timestamp: { family: "timestamp", runtime: "localDateTime" },
-  year: { family: "year", runtime: "year" },
-  binary: { family: "binary", runtime: "bytes" },
-  varbinary: { family: "binary", runtime: "bytes" },
-  tinyblob: { family: "binary", runtime: "bytes" },
-  blob: { family: "binary", runtime: "bytes" },
-  mediumblob: { family: "binary", runtime: "bytes" },
-  longblob: { family: "binary", runtime: "bytes" },
-  json: { family: "json", runtime: "json" },
-  geometry: { family: "spatial", runtime: "unknown" },
-  point: { family: "spatial", runtime: "unknown" },
-  linestring: { family: "spatial", runtime: "unknown" },
-  polygon: { family: "spatial", runtime: "unknown" },
-  multipoint: { family: "spatial", runtime: "unknown" },
-  multilinestring: { family: "spatial", runtime: "unknown" },
-  multipolygon: { family: "spatial", runtime: "unknown" },
-  geometrycollection: { family: "spatial", runtime: "unknown" },
-  enum: { family: "enum", runtime: "string" },
-  set: { family: "set", runtime: "string" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const mysqlDatatypeFamilies = matrixMysqlDatatypeFamilies
+export const mysqlDatatypeKinds = matrixMysqlDatatypeKinds
 
 export type MysqlDatatypeFamily = keyof typeof mysqlDatatypeFamilies
 export type MysqlDatatypeKind = keyof typeof mysqlDatatypeKinds

package/src/mysql/executor.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect"
-import * as SqlClient from "@effect/sql/SqlClient"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
 import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
@@ -41,8 +41,6 @@ export type MysqlQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any,
 
 /** Runs an effect within the ambient MySQL SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested MySQL SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** MySQL executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -133,10 +131,10 @@ const fromDriver = <
   stream(plan) {
     const rendered = renderer.render(plan)
     return Stream.mapError(
-      Stream.mapChunksEffect(
+      Stream.mapArrayEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -166,7 +164,7 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard MySQL executor pipeline.
  *
  * By default this uses the built-in MySQL renderer plus the ambient
- * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * `effect/unstable/sql` `SqlClient`. Advanced callers can override the renderer,
  * driver, or both.
  */
 export function make(): QueryExecutor<SqlClient.SqlClient>

package/src/mysql/function/temporal.ts

@@ -35,7 +35,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,

package/src/mysql/internal/dsl.ts

@@ -1573,11 +1573,11 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
 
   const literalSchemaOf = <Value extends LiteralValue>(
     value: Value
-  ): Schema.Schema.Any | undefined => {
+  ): Schema.Top | undefined => {
     if (value === null || value instanceof Date) {
       return undefined
     }
-    return Schema.Literal(value) as Schema.Schema.Any
+    return Schema.Literal(value) as unknown as Schema.Top
   }
 
   const literal = <const Value extends LiteralValue>(
@@ -4504,6 +4504,83 @@ type ValidateTargetColumnInput<
   Columns extends DdlColumnInput
 > = ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>> extends never ? never : Columns
 
+type SameColumnSet<
+  Left extends readonly string[],
+  Right extends readonly string[]
+> = string extends Left[number] | Right[number]
+  ? false
+  : Exclude<Left[number], Right[number]> extends never
+    ? Exclude<Right[number], Left[number]> extends never
+      ? true
+      : false
+    : false
+
+type ConflictArbitersOf<Target extends MutationTargetLike> =
+  Target[typeof Table.TypeId]["conflictArbiters"][number]
+
+type MatchingConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[],
+  AllowPartial extends boolean
+> = ConflictArbitersOf<Target> extends infer Arbiter extends Table.ConflictArbiter
+  ? Arbiter extends Table.ConflictArbiter
+    ? SameColumnSet<Arbiter["columns"], Columns> extends true
+      ? Arbiter["scope"] extends "unconditional"
+        ? true
+        : AllowPartial extends true ? true : never
+      : never
+    : never
+  : never
+
+type HasInlineConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[]
+> = Columns extends readonly [infer Column extends Extract<keyof Target[typeof Table.TypeId]["fields"], string>]
+  ? Target[typeof Table.TypeId]["fields"][Column] extends { readonly metadata: { readonly primaryKey: true } | { readonly unique: true } }
+    ? true
+    : false
+  : false
+
+type HasConflictArbiter<
+  Target extends MutationTargetLike,
+  Columns extends readonly string[],
+  AllowPartial extends boolean
+> = string extends Extract<keyof Target[typeof Table.TypeId]["fields"], string>
+  ? true
+  : HasInlineConflictArbiter<Target, Columns> extends true
+    ? true
+  : true extends MatchingConflictArbiter<Target, Columns, AllowPartial> ? true : false
+
+type ConflictTargetArbiterError<
+  Columns,
+  AllowPartial extends boolean
+> = {
+  readonly __effect_qb_error__: "effect-qb: conflict target columns must match a primary key, unique constraint, or unique index"
+  readonly __effect_qb_conflict_columns__: Columns
+  readonly __effect_qb_partial_target__: AllowPartial
+  readonly __effect_qb_hint__: "Declare the target columns as primaryKey/unique, add a table-level Unique.make(...), or use a simple Pg.Index.uniqueIndex(...)"
+}
+
+type ValidateConflictColumnInput<
+  Target extends MutationTargetLike,
+  Columns extends DdlColumnInput,
+  AllowPartial extends boolean
+> = ValidateTargetColumnInput<Target, Columns> extends never
+  ? never
+  : HasConflictArbiter<Target, NormalizeDdlColumns<Columns>, AllowPartial> extends true
+    ? Columns
+    : ConflictTargetArbiterError<NormalizeDdlColumns<Columns>, AllowPartial>
+
+type ConflictColumnPlanConstraint<
+  Target extends MutationTargetLike,
+  Columns extends DdlColumnInput,
+  AllowPartial extends boolean
+> = ValidateTargetColumnInput<Target, Columns> extends never
+  ? never
+  : HasConflictArbiter<Target, NormalizeDdlColumns<Columns>, AllowPartial> extends true
+    ? unknown
+    : ConflictTargetArbiterError<NormalizeDdlColumns<Columns>, AllowPartial>
+
 type CreateIndexOptions<Name extends string = string> = {
   readonly name?: NonEmptyStringInput<Name>
   readonly unique?: boolean
@@ -4947,6 +5024,21 @@ type ConflictConstraintNameConstraint<Target> =
     ? { readonly constraint: NonEmptyStringInput<Constraint> }
     : unknown
 
+type ConflictTargetHasPredicate<Target> =
+  Target extends { readonly where: PredicateInput } ? true : false
+
+type ConflictTargetPlanConstraint<
+  Target extends MutationTargetLike,
+  ConflictTarget
+> =
+  ConflictTarget extends { readonly constraint: string }
+    ? unknown
+    : ConflictTarget extends { readonly columns: infer Columns extends DdlColumnInput }
+      ? ConflictColumnPlanConstraint<Target, Columns, ConflictTargetHasPredicate<ConflictTarget>>
+      : ConflictTarget extends DdlColumnInput
+        ? ConflictColumnPlanConstraint<Target, ConflictTarget, false>
+        : unknown
+
 type ConflictActionInput<
   Target extends MutationTargetLike,
   Dialect extends string,
@@ -5095,6 +5187,11 @@ type MutationTargetTupleDialectConstraint<
   Dialect extends string
 > = Exclude<TableDialectOf<Targets[number]>, Dialect | "standard"> extends never ? unknown : never
 
+type TableDialectConstraint<
+  Target extends TableLike,
+  Dialect extends string
+> = Exclude<TableDialectOf<Target>, Dialect> extends never ? unknown : never
+
 type DuplicateMutationTargetSourceName<
   Targets extends readonly MutationTargetLike[],
   Seen extends string = never
@@ -6212,7 +6309,7 @@ type AsCurriedResult<
 
   export interface InsertApi {
     <Target extends MutationTargetLike>(
-      target: Target
+      target: Target & TableDialectConstraint<Target, Dialect>
     ): QueryPlan<
       {},
       never,
@@ -6229,7 +6326,7 @@ type AsCurriedResult<
       EmptyFacts
     >
     <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
-      target: Target,
+      target: Target & TableDialectConstraint<Target, Dialect>,
       values: MutationValuesInput<"insert", Target, Values> & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     ): QueryPlan<
       {},
@@ -6262,9 +6359,9 @@ type AsCurriedResult<
   >(
     target: ConflictTarget & ConflictConstraintNameConstraint<ConflictTarget>,
     options?: Options & ConflictActionUpdateNonEmptyConstraint<Options>
-  ) =>
+	  ) =>
     <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & RequireInsertStatement<PlanValue>
+      plan: PlanValue & RequireInsertStatement<PlanValue> & ConflictTargetPlanConstraint<MutationTargetOfPlan<PlanValue>, ConflictTarget>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
       Exclude<RequiredOfPlan<PlanValue> | ConflictRequired<UpdateValues, Options, ConflictTarget>, AvailableNames<AvailableOfPlan<PlanValue>>>,
@@ -6301,7 +6398,7 @@ type AsCurriedResult<
       EmptyFacts
     >
     <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
-      target: Target,
+      target: Target & TableDialectConstraint<Target, Dialect>,
       values: MutationValuesInput<"update", Target, Values> & UpdateValuesNonEmptyConstraint<Values> & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     ): QueryPlan<
       {},
@@ -6326,9 +6423,9 @@ type AsCurriedResult<
     const Columns extends DdlColumnInput,
     UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = undefined
   >(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     values: Values & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    conflictColumns: ValidateTargetColumnInput<Target, Columns>,
+    conflictColumns: ValidateConflictColumnInput<Target, Columns, false>,
     updateValues?: UpdateValues & UpdateValuesNonEmptyConstraint<Exclude<UpdateValues, undefined>> & MutationValuesDialectConstraint<Exclude<UpdateValues, undefined>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
   ) => QueryPlan<
     {},
@@ -6350,7 +6447,7 @@ type AsCurriedResult<
 
   interface DeleteApi {
     <Target extends MutationTargetLike>(
-      target: Target
+      target: Target & TableDialectConstraint<Target, Dialect>
     ): QueryPlan<
       {},
       never,
@@ -6386,7 +6483,7 @@ type AsCurriedResult<
   }
 
   type TruncateApi = <Target extends MutationTargetLike>(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     options?: TruncateOptions
   ) => QueryPlan<
     {},
@@ -6419,7 +6516,7 @@ type AsCurriedResult<
     MatchedPredicate extends PredicateInput | undefined = undefined,
     NotMatchedPredicate extends PredicateInput | undefined = undefined
   >(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     source: Source & (
       SourceRequiredOf<Source> extends never ? unknown : SourceRequirementError<Source>
     ) & SourceDialectConstraint<Source, Dialect>,
@@ -6676,7 +6773,7 @@ type AsCurriedResult<
   >
 
   type CreateTableApi = <Target extends SchemaTableLike>(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     options?: CreateTableOptions
   ) => QueryPlan<
     {},
@@ -6692,7 +6789,7 @@ type AsCurriedResult<
   >
 
   type DropTableApi = <Target extends SchemaTableLike>(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     options?: DropTableOptions
   ) => QueryPlan<
     {},
@@ -6708,7 +6805,7 @@ type AsCurriedResult<
   >
 
   type CreateIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput, Name extends string = string>(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     columns: Columns & ValidateDdlColumnInput<Target, Columns>,
     options?: CreateIndexOptions<Name>
   ) => QueryPlan<
@@ -6725,7 +6822,7 @@ type AsCurriedResult<
   >
 
   type DropIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput, Name extends string = string>(
-    target: Target,
+    target: Target & TableDialectConstraint<Target, Dialect>,
     columns: Columns & ValidateDdlColumnInput<Target, Columns>,
     options?: DropIndexOptions<Name>
   ) => QueryPlan<

package/src/mysql/json.ts

@@ -1,39 +1,7 @@
-/** MySQL JSON expression helpers. */
-export { json } from "./internal/dsl.js"
+/** MySQL-specific JSON expression helpers. Portable JSON helpers are exported from `effect-qb`. */
 import { json } from "./internal/dsl.js"
 
-export const key = json.key
-export const index = json.index
-export const wildcard = json.wildcard
-export const slice = json.slice
-export const descend = json.descend
-export const path = json.path
-export const get = json.get
-export const access = json.access
-export const traverse = json.traverse
-export const text = json.text
-export const accessText = json.accessText
-export const traverseText = json.traverseText
-export const contains = json.contains
-export const containedBy = json.containedBy
-export const hasKey = json.hasKey
-export const keyExists = json.keyExists
-export const hasAnyKeys = json.hasAnyKeys
-export const hasAllKeys = json.hasAllKeys
-export const delete_ = json.delete
-export { delete_ as delete }
-export const remove = json.remove
-export const set = json.set
-export const insert = json.insert
-export const concat = json.concat
-export const merge = json.merge
-export const buildObject = json.buildObject
-export const buildArray = json.buildArray
-export const toJson = json.toJson
-export const toJsonb = json.toJsonb
 export const typeOf = json.typeOf
 export const length = json.length
-export const keys = json.keys
 export const stripNulls = json.stripNulls
-export const pathExists = json.pathExists
 export const pathMatch = json.pathMatch

package/src/mysql/renderer.ts

@@ -20,6 +20,9 @@ export type ValueMappings = Expression.DriverValueMappingsFor<MysqlDatatypeKind
 
 export interface MakeOptions {
   readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
   readonly casing?: Casing.Options
 }
 
@@ -33,19 +36,23 @@ const RendererProto = {
 }
 
 /** Creates the built-in MySQL renderer. */
-export const make = (options: MakeOptions = {}): Renderer => {
-  const renderer = CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, options))
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, state))
   return Object.assign(Object.create(RendererProto), renderer, {
     [Casing.TypeId]: {
-      casing: options.casing
+      casing: state.casing
     },
     withCasing: (override: Casing.Options) =>
-      make({
-        ...options,
-        casing: Casing.merge(options.casing, override)
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
       })
   }) as Renderer
 }
 
+/** Creates the built-in MySQL renderer. */
+export const make = (options: MakeOptions = {}): Renderer =>
+  makeWithState({ valueMappings: options.valueMappings })
+
 /** Shared built-in MySQL renderer instance. */
 export const mysql = make()

package/src/mysql/type.ts

@@ -0,0 +1,60 @@
+import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  mysqlSpecificDatatypeKeys,
+  pickDatatypeConstructors,
+  type MysqlSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
+import { mysqlDatatypes } from "./datatypes/index.js"
+
+type MysqlSpecificDatatypes = Pick<typeof mysqlDatatypes, MysqlSpecificDatatypeKey>
+
+type MysqlTypeNamespace = MysqlSpecificDatatypes & {
+  readonly enum: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Enum<"mysql", Kind>
+  readonly set: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Set<"mysql", Kind>
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"mysql", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
+}
+
+const enum_ = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Enum<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind,
+  variant: "enum"
+})
+
+const set = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Set<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind,
+  variant: "set"
+})
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
+/** MySQL-only database-type constructors for casts and typed column references. */
+export const type: MysqlTypeNamespace = {
+  ...pickDatatypeConstructors(mysqlDatatypes, mysqlSpecificDatatypeKeys),
+  enum: enum_,
+  set,
+  custom,
+  driverValueMapping
+}