effect-qb 0.12.3

package/src/mysql/errors/fields.ts

@@ -0,0 +1,21 @@
+/** Common MySQL driver error fields surfaced by the normalizer when present. */
+export interface MysqlErrorFields {
+  readonly errno?: number
+  readonly sqlState?: string
+  readonly sqlMessage?: string
+  readonly fatal?: boolean
+  readonly sql?: string
+  readonly syscall?: string
+  readonly address?: string
+  readonly port?: number
+  readonly hostname?: string
+}
+
+/** Rendered SQL context attached to normalized MySQL execution failures. */
+export interface MysqlQueryContext {
+  readonly sql: string
+  readonly params: readonly unknown[]
+}
+
+export type MySqlErrorFields = MysqlErrorFields
+export type MySqlQueryContext = MysqlQueryContext

package/src/mysql/errors/index.ts

@@ -0,0 +1,18 @@
+export * from "./catalog.js"
+export * from "./fields.js"
+export * from "./normalize.js"
+export * from "./requirements.js"
+
+export {
+  findMysqlErrorDescriptorsByNumber as findMySqlErrorDescriptorsByNumber,
+  getMysqlErrorDescriptor as getMySqlErrorDescriptor,
+  isMysqlErrorNumber as isMySqlErrorNumber,
+  isMysqlErrorSymbol as isMySqlErrorSymbol
+} from "./catalog.js"
+
+export {
+  hasNumber as hasErrorNumber,
+  hasSymbol as hasErrorSymbol,
+  isMysqlErrorLike as isMySqlErrorLike,
+  normalizeMysqlDriverError as normalizeMySqlDriverError
+} from "./normalize.js"

package/src/mysql/errors/normalize.ts

@@ -0,0 +1,232 @@
+import type * as Renderer from "../../internal/renderer.js"
+import {
+  findMysqlErrorDescriptorsByNumberLoose,
+  getMysqlErrorDescriptor,
+  isMysqlErrorNumber,
+  isMysqlErrorSymbol,
+  type MysqlErrorDescriptor,
+  type MysqlErrorNumber,
+  type MysqlErrorSymbol,
+  type MysqlErrorTag
+} from "./catalog.js"
+import type {
+  MysqlErrorFields,
+  MysqlQueryContext
+} from "./fields.js"
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+const asString = (value: unknown): string | undefined =>
+  typeof value === "string" ? value : undefined
+
+const asBoolean = (value: unknown): boolean | undefined =>
+  typeof value === "boolean" ? value : undefined
+
+const asNumber = (value: unknown): number | undefined => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value)
+    return Number.isFinite(parsed) ? parsed : undefined
+  }
+  return undefined
+}
+
+const normalizeFields = (error: Record<string, unknown>): MysqlErrorFields => ({
+  errno: asNumber(error.errno),
+  sqlState: asString(error.sqlState),
+  sqlMessage: asString(error.sqlMessage),
+  fatal: asBoolean(error.fatal),
+  sql: asString(error.sql),
+  syscall: asString(error.syscall),
+  address: asString(error.address),
+  port: asNumber(error.port),
+  hostname: asString(error.hostname)
+})
+
+/** Raw MySQL-like error shape as commonly exposed by client libraries. */
+export interface MysqlErrorLike {
+  readonly code?: string
+  readonly errno?: string | number
+  readonly sqlState?: string
+  readonly sqlMessage?: string
+  readonly message?: string
+  readonly fatal?: boolean
+  readonly sql?: string
+  readonly syscall?: string
+  readonly address?: string
+  readonly port?: string | number
+  readonly hostname?: string
+}
+
+/** Structured known MySQL error derived from the generated official catalog. */
+export type KnownMysqlError<Symbol extends MysqlErrorSymbol = MysqlErrorSymbol> = Readonly<{
+  readonly _tag: MysqlErrorTag<Symbol>
+  readonly category: MysqlErrorDescriptor<Symbol>["category"]
+  readonly number: MysqlErrorDescriptor<Symbol>["number"]
+  readonly symbol: Symbol
+  readonly documentedSqlState: MysqlErrorDescriptor<Symbol>["sqlState"]
+  readonly messageTemplate: MysqlErrorDescriptor<Symbol>["messageTemplate"]
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly raw: MysqlErrorLike
+} & MysqlErrorFields>
+
+/** Extracts the normalized MySQL error variant for a specific symbol. */
+export type KnownMysqlErrorBySymbol<Symbol extends MysqlErrorSymbol> = KnownMysqlError<Symbol>
+
+/** MySQL-like error whose symbol or number is not in the current catalog. */
+export type UnknownMysqlCodeError = Readonly<{
+  readonly _tag: "@mysql/unknown/code"
+  readonly code?: string
+  readonly errno?: string | number
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly raw: MysqlErrorLike
+} & MysqlErrorFields>
+
+/** Fallback for non-MySQL driver failures in the MySQL executor path. */
+export type UnknownMysqlDriverError = Readonly<{
+  readonly _tag: "@mysql/unknown/driver"
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly cause: unknown
+}>
+
+/** Any MySQL-specific driver failure surfaced by the MySQL executor. */
+export type MysqlDriverError =
+  | KnownMysqlError
+  | UnknownMysqlCodeError
+  | UnknownMysqlDriverError
+
+/** Runtime guard for objects that look like MySQL driver errors. */
+export const isMysqlErrorLike = (value: unknown): value is MysqlErrorLike =>
+  isRecord(value) &&
+  (
+    typeof value.code === "string" ||
+    typeof value.errno === "string" ||
+    typeof value.errno === "number" ||
+    typeof value.sqlState === "string" ||
+    typeof value.sqlMessage === "string" ||
+    typeof value.message === "string" ||
+    typeof value.fatal === "boolean"
+  )
+
+const errorMessageOf = (error: MysqlErrorLike): string =>
+  error.sqlMessage ?? error.message ?? "MySQL driver error"
+
+const numberOf = (error: MysqlErrorLike): string | undefined => {
+  if (typeof error.errno === "number" && Number.isFinite(error.errno)) {
+    return String(error.errno)
+  }
+  if (typeof error.errno === "string" && error.errno.trim() !== "") {
+    return error.errno
+  }
+  return undefined
+}
+
+const findDescriptor = (error: MysqlErrorLike): MysqlErrorDescriptor | undefined => {
+  if (typeof error.code === "string" && isMysqlErrorSymbol(error.code)) {
+    return getMysqlErrorDescriptor(error.code)
+  }
+  if (typeof error.code === "string" && isMysqlErrorNumber(error.code)) {
+    const matches = findMysqlErrorDescriptorsByNumberLoose(error.code)
+    if (matches?.length === 1) {
+      return matches[0]
+    }
+  }
+  const number = numberOf(error)
+  if (number !== undefined) {
+    const matches = findMysqlErrorDescriptorsByNumberLoose(number)
+    if (!matches || matches.length === 0) {
+      return undefined
+    }
+    if (matches.length === 1) {
+      return matches[0]
+    }
+    if (typeof error.code === "string") {
+      return matches.find((descriptor) => descriptor.symbol === error.code)
+    }
+  }
+  return undefined
+}
+
+const makeKnownMysqlError = <Symbol extends MysqlErrorSymbol>(
+  descriptor: MysqlErrorDescriptor<Symbol>,
+  raw: MysqlErrorLike,
+  query?: MysqlQueryContext
+): KnownMysqlError<Symbol> => ({
+  _tag: descriptor.tag,
+  category: descriptor.category,
+  number: descriptor.number,
+  symbol: descriptor.symbol,
+  documentedSqlState: descriptor.sqlState,
+  messageTemplate: descriptor.messageTemplate,
+  message: errorMessageOf(raw),
+  query,
+  raw,
+  ...normalizeFields(raw as Record<string, unknown>),
+  sqlState: asString(raw.sqlState) ?? descriptor.sqlState
+}) as KnownMysqlError<Symbol>
+
+/** Normalizes an unknown failure into a structured MySQL driver error. */
+export const normalizeMysqlDriverError = (
+  cause: unknown,
+  query?: MysqlQueryContext | Renderer.RenderedQuery<any, "mysql">
+): MysqlDriverError => {
+  const context = query === undefined
+    ? undefined
+    : "sql" in query
+      ? { sql: query.sql, params: query.params }
+      : query
+
+  if (!isMysqlErrorLike(cause)) {
+    return {
+      _tag: "@mysql/unknown/driver",
+      message: cause instanceof Error ? cause.message : "Unknown MySQL driver failure",
+      query: context,
+      cause
+    } as UnknownMysqlDriverError
+  }
+
+  const descriptor = findDescriptor(cause)
+  if (descriptor !== undefined) {
+    return makeKnownMysqlError(descriptor, cause, context)
+  }
+
+  if (typeof cause.code === "string" || numberOf(cause) !== undefined) {
+    return {
+      _tag: "@mysql/unknown/code",
+      code: asString(cause.code),
+      errno: cause.errno,
+      message: errorMessageOf(cause),
+      query: context,
+      raw: cause,
+      ...normalizeFields(cause as Record<string, unknown>)
+    } as UnknownMysqlCodeError
+  }
+
+  return {
+    _tag: "@mysql/unknown/driver",
+    message: errorMessageOf(cause),
+    query: context,
+    cause
+  } as UnknownMysqlDriverError
+}
+
+/** Type guard for a specific MySQL catalog symbol. */
+export const hasSymbol = <Symbol extends MysqlErrorSymbol>(
+  error: MysqlDriverError | { readonly symbol?: string },
+  symbol: Symbol
+): error is KnownMysqlErrorBySymbol<Symbol> =>
+  "symbol" in error && error.symbol === symbol
+
+/** Type guard for a specific documented MySQL error number. */
+export const hasNumber = <Number extends MysqlErrorNumber>(
+  error: MysqlDriverError | { readonly number?: string; readonly errno?: string | number },
+  number: Number
+): error is KnownMysqlError & { readonly number: Number } =>
+  ("number" in error && error.number === number) ||
+  ("errno" in error && String(error.errno) === number)

package/src/mysql/errors/requirements.ts

@@ -0,0 +1,73 @@
+import { read_query_capabilities, type QueryCapability, type QueryRequirement } from "../../internal/query-requirements.js"
+import type { MysqlQueryContext } from "./fields.js"
+import type {
+  KnownMysqlError,
+  MysqlDriverError,
+  UnknownMysqlCodeError,
+  UnknownMysqlDriverError
+} from "./normalize.js"
+
+export type MysqlQueryRequirement = Extract<QueryRequirement, "write" | "ddl" | "transaction" | "locking">
+
+export const mysql_requirements_by_sqlstate_prefix = {
+  "23": ["write"]
+} as const satisfies Partial<Record<string, readonly MysqlQueryRequirement[]>>
+
+export type MysqlQueryRequirementsError = Readonly<{
+  readonly _tag: "@mysql/unknown/query-requirements"
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly requiredCapabilities: readonly MysqlQueryRequirement[]
+  readonly actualCapabilities: readonly QueryCapability[]
+  readonly cause: MysqlDriverError
+}>
+
+type WriteRequiredMysqlSqlState = `23${string}`
+
+export type MysqlReadQueryError =
+  | Exclude<KnownMysqlError, { readonly documentedSqlState: WriteRequiredMysqlSqlState }>
+  | UnknownMysqlCodeError
+  | UnknownMysqlDriverError
+  | MysqlQueryRequirementsError
+
+const requiresWriteMysqlError = (error: MysqlDriverError): boolean =>
+  requirements_of_mysql_error(error).length > 0
+
+const lookup_mysql_requirements = (
+  sqlState: string
+): readonly MysqlQueryRequirement[] => {
+  const prefix = sqlState.slice(0, 2)
+  return prefix in mysql_requirements_by_sqlstate_prefix
+    ? mysql_requirements_by_sqlstate_prefix[prefix as keyof typeof mysql_requirements_by_sqlstate_prefix]
+    : []
+}
+
+export const requirements_of_mysql_error = (
+  error: MysqlDriverError
+): readonly MysqlQueryRequirement[] => {
+  if ("documentedSqlState" in error && typeof error.documentedSqlState === "string") {
+    return lookup_mysql_requirements(error.documentedSqlState)
+  }
+  if ("sqlState" in error && typeof error.sqlState === "string") {
+    return lookup_mysql_requirements(error.sqlState)
+  }
+  return []
+}
+
+export const narrowMysqlDriverErrorForReadQuery = (
+  error: MysqlDriverError
+): MysqlReadQueryError => {
+  const requiredCapabilities = requirements_of_mysql_error(error)
+  if (!requiresWriteMysqlError(error)) {
+    return error as MysqlReadQueryError
+  }
+
+  return {
+    _tag: "@mysql/unknown/query-requirements",
+    message: "MySQL driver error requires query capabilities not provided by this plan",
+    query: error.query,
+    requiredCapabilities,
+    actualCapabilities: read_query_capabilities,
+    cause: error
+  } satisfies MysqlQueryRequirementsError
+}

package/src/mysql/executor.ts

@@ -0,0 +1,134 @@
+import * as Effect from "effect/Effect"
+import * as SqlClient from "@effect/sql/SqlClient"
+
+import * as CoreExecutor from "../internal/executor.js"
+import * as Query from "./query.js"
+import * as Renderer from "./renderer.js"
+import {
+  narrowMysqlDriverErrorForReadQuery,
+  normalizeMysqlDriverError,
+  type MysqlDriverError,
+  type MysqlReadQueryError
+} from "./errors/index.js"
+
+/** MySQL-specialized flat row returned by SQL drivers. */
+export type FlatRow = CoreExecutor.FlatRow
+/** Runtime decode failure raised after SQL execution but before row remapping. */
+export type RowDecodeError = CoreExecutor.RowDecodeError
+/** MySQL-specialized rendered-query driver. */
+export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"mysql", Error, Context>
+/** MySQL-specialized executor contract. */
+export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"mysql", Error, Context>
+/** Optional renderer / driver overrides for the standard MySQL executor pipeline. */
+export interface MakeOptions<Error = never, Context = never> {
+  readonly renderer?: Renderer.Renderer
+  readonly driver?: Driver<Error, Context>
+  readonly driverMode?: CoreExecutor.DriverMode
+}
+/** Standard composed error shape for MySQL executors. */
+export type MysqlExecutorError = MysqlDriverError | RowDecodeError
+/** Read-query error surface emitted by built-in MySQL executors. */
+export type MysqlQueryError<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  Exclude<Query.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? MysqlReadQueryError : MysqlExecutorError
+
+/** 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> {
+  readonly dialect: "mysql"
+  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
+  ): Effect.Effect<Query.ResultRows<PlanValue>, MysqlQueryError<PlanValue>, Context>
+}
+
+/** Constructs a MySQL-specialized SQL driver. */
+export const driver = <
+  Error = never,
+  Context = never
+>(
+  execute: <Row>(
+    query: Renderer.RenderedQuery<Row>
+  ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+): Driver<Error, Context> =>
+  CoreExecutor.driver("mysql", execute)
+
+const fromDriver = <
+  Error = never,
+  Context = never
+>(
+  renderer: Renderer.Renderer,
+  sqlDriver: Driver<Error, Context>,
+  driverMode: CoreExecutor.DriverMode = "raw"
+): QueryExecutor<Context> => ({
+  dialect: "mysql",
+  execute(plan) {
+    const rendered = renderer.render(plan)
+    return Effect.mapError(
+      Effect.flatMap(
+        sqlDriver.execute(rendered),
+        (rows) => Effect.try({
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode }),
+          catch: (error) => error as RowDecodeError
+        })
+      ),
+      (error) => {
+        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+          return error as RowDecodeError
+        }
+        const normalized = normalizeMysqlDriverError(error, rendered)
+        return CoreExecutor.hasWriteCapability(plan)
+          ? normalized
+          : narrowMysqlDriverErrorForReadQuery(normalized)
+      }
+    ) as Effect.Effect<any, any, Context>
+  }
+})
+
+const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
+  driver((query) =>
+    Effect.flatMap(SqlClient.SqlClient, (sql) =>
+      sql.unsafe<FlatRow>(query.sql, [...query.params])))
+
+/**
+ * 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,
+ * driver, or both.
+ */
+export function make(): QueryExecutor<SqlClient.SqlClient>
+export function make(
+  options: {
+    readonly renderer?: Renderer.Renderer
+    readonly driverMode?: CoreExecutor.DriverMode
+  }
+): QueryExecutor<SqlClient.SqlClient>
+export function make<Error = never, Context = never>(
+  options: {
+    readonly renderer?: Renderer.Renderer
+    readonly driver: Driver<Error, Context>
+    readonly driverMode?: CoreExecutor.DriverMode
+  }
+): QueryExecutor<Context>
+export function make<Error = never, Context = never>(
+  options: MakeOptions<Error, Context> = {}
+): QueryExecutor<any> {
+  if (options.driver) {
+    return fromDriver(options.renderer ?? Renderer.make(), options.driver, options.driverMode)
+  }
+  return fromDriver(options.renderer ?? Renderer.make(), sqlClientDriver(), options.driverMode)
+}
+
+/** Creates a MySQL-specialized executor from a typed implementation callback. */
+export const custom = <
+  Error = never,
+  Context = never
+>(
+  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
+  ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+): Executor<Error, Context> =>
+  CoreExecutor.make("mysql", execute as any) as Executor<Error, Context>

package/src/mysql/query.ts

@@ -0,0 +1,189 @@
+import * as Expression from "../internal/expression.js"
+import { mysqlDatatypes } from "./datatypes/index.js"
+import {
+  type CapabilitiesOfPlan,
+  type CompletePlan,
+  type DialectCompatiblePlan,
+  type DerivedSourceRequiredError,
+  type CteSource,
+  type EffectiveNullability,
+  type ExpressionInput,
+  type ExpressionOutput,
+  type GroupByInput,
+  type MergeCapabilities,
+  type MergeCapabilityTuple,
+  type HavingPredicateInput,
+  type OrderDirection,
+  type OutputOfSelection,
+  type MutationInputOf,
+  type MutationTargetLike,
+  type NumericExpressionInput,
+  type PredicateInput,
+  type QueryCapability,
+  type QueryPlan,
+  type QueryRequirement,
+  type SetCompatiblePlan,
+  type SetCompatibleRightPlan,
+  type SetOperator,
+  type QueryStatement,
+  type ResultRow,
+  type ResultRows,
+  type RuntimeResultRow,
+  type RuntimeResultRows,
+  type SchemaTableLike,
+  type SourceCapabilitiesOf,
+  type SourceRequiredOf,
+  type SourceRequirementError,
+  type StatementOfPlan,
+  type StringExpressionInput
+} from "../internal/query.js"
+import { makeDialectQuery } from "../internal/query-factory.js"
+
+const mysqlQuery = makeDialectQuery({
+  dialect: "mysql",
+  textDb: { dialect: "mysql", kind: "text" } as Expression.DbType.MySqlText,
+  numericDb: { dialect: "mysql", kind: "double" } as Expression.DbType.MySqlDouble,
+  boolDb: { dialect: "mysql", kind: "boolean" } as Expression.DbType.MySqlBool,
+  timestampDb: { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+  nullDb: { dialect: "mysql", kind: "null" } as Expression.DbType.Base<"mysql", "null">,
+  type: mysqlDatatypes
+})
+
+export const literal = mysqlQuery.literal
+export const cast = mysqlQuery.cast
+export const type = mysqlQuery.type
+export const json = mysqlQuery.json
+export const eq = mysqlQuery.eq
+export const neq = mysqlQuery.neq
+export const lt = mysqlQuery.lt
+export const lte = mysqlQuery.lte
+export const gt = mysqlQuery.gt
+export const gte = mysqlQuery.gte
+export const isNull = mysqlQuery.isNull
+export const isNotNull = mysqlQuery.isNotNull
+export const upper = mysqlQuery.upper
+export const lower = mysqlQuery.lower
+export const like = mysqlQuery.like
+export const ilike = mysqlQuery.ilike
+export const and = mysqlQuery.and
+export const or = mysqlQuery.or
+export const not = mysqlQuery.not
+export const all = mysqlQuery.all
+export const any = mysqlQuery.any
+const case_ = mysqlQuery.case
+export const match = mysqlQuery.match
+export const coalesce = mysqlQuery.coalesce
+export const in_ = mysqlQuery.in
+export const notIn = mysqlQuery.notIn
+export const between = mysqlQuery.between
+export const contains = mysqlQuery.contains
+export const containedBy = mysqlQuery.containedBy
+export const overlaps = mysqlQuery.overlaps
+export const concat = mysqlQuery.concat
+export const exists = mysqlQuery.exists
+export const over = mysqlQuery.over
+export const rowNumber = mysqlQuery.rowNumber
+export const rank = mysqlQuery.rank
+export const denseRank = mysqlQuery.denseRank
+export const count = mysqlQuery.count
+export const max = mysqlQuery.max
+export const min = mysqlQuery.min
+export const isDistinctFrom = mysqlQuery.isDistinctFrom
+export const isNotDistinctFrom = mysqlQuery.isNotDistinctFrom
+export const excluded = mysqlQuery.excluded
+export const as = mysqlQuery.as
+export const with_ = mysqlQuery.with
+export const withRecursive = mysqlQuery.withRecursive
+export const lateral = mysqlQuery.lateral
+export const scalar = mysqlQuery.scalar
+export const inSubquery = mysqlQuery.inSubquery
+export const compareAny = mysqlQuery.compareAny
+export const compareAll = mysqlQuery.compareAll
+export const values = mysqlQuery.values
+export const unnest = mysqlQuery.unnest
+export const generateSeries = mysqlQuery.generateSeries
+export const returning = mysqlQuery.returning
+export const defaultValues = mysqlQuery.defaultValues
+export const onConflict = mysqlQuery.onConflict
+export const insert = mysqlQuery.insert
+export const update = mysqlQuery.update
+export const upsert = mysqlQuery.upsert
+export const delete_ = mysqlQuery.delete
+export const truncate = mysqlQuery.truncate
+export const merge = mysqlQuery.merge
+export const transaction = mysqlQuery.transaction
+export const commit = mysqlQuery.commit
+export const rollback = mysqlQuery.rollback
+export const savepoint = mysqlQuery.savepoint
+export const rollbackTo = mysqlQuery.rollbackTo
+export const releaseSavepoint = mysqlQuery.releaseSavepoint
+export const createTable = mysqlQuery.createTable
+export const dropTable = mysqlQuery.dropTable
+export const createIndex = mysqlQuery.createIndex
+export const dropIndex = mysqlQuery.dropIndex
+export const union = mysqlQuery.union
+export const unionAll = mysqlQuery.unionAll
+export const intersect = mysqlQuery.intersect
+export const intersectAll = mysqlQuery.intersectAll
+export const except = mysqlQuery.except
+export const exceptAll = mysqlQuery.exceptAll
+export const select = mysqlQuery.select
+export const where = mysqlQuery.where
+export const having = mysqlQuery.having
+export const from = mysqlQuery.from
+export const innerJoin = mysqlQuery.innerJoin
+export const leftJoin = mysqlQuery.leftJoin
+export const rightJoin = mysqlQuery.rightJoin
+export const fullJoin = mysqlQuery.fullJoin
+export const crossJoin = mysqlQuery.crossJoin
+export const distinct = mysqlQuery.distinct
+export const distinctOn = mysqlQuery.distinctOn
+export const limit = mysqlQuery.limit
+export const offset = mysqlQuery.offset
+export const lock = mysqlQuery.lock
+export const orderBy = mysqlQuery.orderBy
+export const groupBy = mysqlQuery.groupBy
+export { case_ as case }
+export { in_ as in }
+export { with_ as with }
+export { delete_ as delete }
+
+export type {
+  CapabilitiesOfPlan,
+  CompletePlan,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  CteSource,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  HavingPredicateInput,
+  OrderDirection,
+  OutputOfSelection,
+  MutationInputOf,
+  MutationTargetLike,
+  NumericExpressionInput,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryStatement,
+  QueryRequirement,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+}
+
+export { union_query_capabilities } from "../internal/query.js"

package/src/mysql/renderer.ts

@@ -0,0 +1,19 @@
+import * as CoreRenderer from "../internal/renderer.js"
+import { renderMysqlPlan } from "../internal/mysql-renderer.js"
+
+/** MySQL-specialized rendered query shape. */
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "mysql">
+/** Extracts the row type carried by a MySQL rendered query. */
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+/** MySQL-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"mysql">
+
+export { TypeId } from "../internal/renderer.js"
+export type { Projection } from "../internal/renderer.js"
+
+/** Creates the built-in MySQL renderer. */
+export const make = (): Renderer =>
+  CoreRenderer.make("mysql", renderMysqlPlan)
+
+/** Shared built-in MySQL renderer instance. */
+export const mysql = make()