effect-qb 0.16.0 → 0.19.0

package/src/mysql/internal/dsl.ts

@@ -1,4 +1,4 @@
-import { pipeArguments } from "effect/Pipeable"
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
 import { mysqlDatatypes } from "../datatypes/index.js"
@@ -6,9 +6,16 @@ import { mysqlDatatypes } from "../datatypes/index.js"
 import * as Expression from "../../internal/scalar.js"
 import * as Plan from "../../internal/row-set.js"
 import * as Table from "../../internal/table.js"
+import type {
+  LiteralStringInput,
+  NonEmptyStringInput,
+  SafeSqlIdentifierInput,
+  SafeSqlIdentifierPathInput
+} from "../../internal/table-options.js"
 import type { CastTargetError, OperandCompatibilityError } from "../../internal/coercion/errors.js"
 import type { RuntimeOfDbType } from "../../internal/coercion/analysis.js"
 import type { CanCastDbType, CanCompareDbTypes, CanContainDbTypes, CanTextuallyCoerceDbType } from "../../internal/coercion/rules.js"
+import { normalizeDbValue } from "../../internal/runtime/normalize.js"
 import {
   currentRequiredList,
   extractRequiredRuntime,
@@ -30,11 +37,15 @@ import {
   type AssumptionsOfPlan,
   type AvailableOfPlan,
   type CapabilitiesOfPlan,
+  type CommonSetFacts,
   type DialectCompatibleNestedPlan,
   type DependenciesOf,
   type DependencyRecord,
   type DialectOf,
   type DerivedSelectionOf,
+  type DerivedTableCompatiblePlan,
+  type LateralSourceCompatiblePlan,
+  type DerivedSourceCompatiblePlan,
   type DerivedSource,
   type CompletePlan,
   type ExpressionInput,
@@ -66,6 +77,7 @@ import {
   type ScopedNamesOfPlan,
   type SelectionOfPlan,
   type SelectionShape,
+  type SelectionProjectionAliasCollisionConstraint,
   type SetCompatiblePlan,
   type SetCompatibleRightPlan,
   type SchemaTableLike,
@@ -75,10 +87,8 @@ import {
   type TableDialectOf,
   type StatementOfPlan,
   type MutationInputOf,
-  type MutationTargetLike,
   type MutationTargetOfPlan,
   type MergeCapabilities,
-  type MutationTargetInput,
   type MutationValuesInput,
   type SourceDialectOf,
   type SourceLike,
@@ -95,7 +105,6 @@ import {
   type TableLike,
   type UpdateInputOfTarget,
   type MutationTargetNamesOf,
-  type MutationTargetTuple,
   type TupleDependencies,
   type TupleDialect,
   type ResultRow
@@ -133,6 +142,10 @@ import * as ProjectionAlias from "../../internal/projection-alias.js"
 import * as QueryAst from "../../internal/query-ast.js"
 import { normalizeColumnList } from "../../internal/table-options.js"
 
+type MutationTargetLike = Table.AnyTable<Dialect | "standard">
+type MutationTargetTuple = readonly [MutationTargetLike, MutationTargetLike, ...MutationTargetLike[]]
+type MutationTargetInput = MutationTargetLike | MutationTargetTuple
+
 /**
  * Dialect-specific DB type profile used to specialize the shared query
  * operator surface.
@@ -217,6 +230,13 @@ type DialectAsExpression<
   ? Value
   : DialectLiteralExpression<Extract<Value, LiteralValue>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 
+type ProjectionAliasedExpression<
+  Value extends Expression.Any,
+  Alias extends string
+> = Value & {
+  readonly [ProjectionAlias.TypeId]: ProjectionAlias.State<Alias>
+}
+
 /** Normalizes a generic string-capable input into the expression form used internally. */
 type DialectAsStringExpression<
   Value extends ExpressionInput,
@@ -690,6 +710,21 @@ type DialectOfDialectNumericInput<
   NullDb extends Expression.DbType.Any
 > = DialectOf<DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
 
+type NumericExpressionDialectInput<
+  Value extends NumericExpressionInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Exclude<DialectOfDialectNumericInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Dialect | "standard"> extends never
+  ? unknown
+  : {
+      readonly __effect_qb_error__: "effect-qb: numeric expressions cannot mix dialects"
+      readonly __effect_qb_dialect__: DialectOfDialectNumericInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    }
+
 /** Dependency map carried by a numeric-clause input after coercion. */
 type DependenciesOfDialectNumericInput<
   Value extends NumericExpressionInput,
@@ -776,6 +811,35 @@ type DialectExpressionArray<
   ? Tuple
   : never
 
+type ExtractFunctionFieldInput<
+  Value extends ExpressionInput
+> = Value extends string
+  ? SafeSqlIdentifierInput<Value>
+  : Value extends { readonly [ExpressionAst.TypeId]: ExpressionAst.LiteralNode<infer Field extends string> }
+    ? SafeSqlIdentifierInput<Field> extends never ? never : Value
+  : never
+
+type GenericFunctionNameInput<Name extends string> =
+  Name extends "current_date" | "extract" ? never : SafeSqlIdentifierPathInput<Name>
+
+type FunctionCallApi = {
+  (name: "current_date"): Expression.Any
+  <Field extends string, Source extends ExpressionInput>(
+    name: "extract",
+    field: SafeSqlIdentifierInput<Field>,
+    source: Source
+  ): Expression.Any
+  <Field extends Expression.Any, Source extends ExpressionInput>(
+    name: "extract",
+    field: Field & ExtractFunctionFieldInput<Field>,
+    source: Source
+  ): Expression.Any
+  <Name extends string, Args extends readonly ExpressionInput[]>(
+    name: GenericFunctionNameInput<Name>,
+    ...args: Args
+  ): Expression.Any
+}
+
 /** Normalized expression tuple for generic string operator inputs. */
 type DialectStringExpressionTuple<
   Values extends readonly ExpressionInput[],
@@ -1042,6 +1106,9 @@ type JsonPathInput = JsonPath.Path<any> | JsonPath.CanonicalSegment
 
 type JsonQueryInput = JsonPath.Path<any> | StringExpressionInput
 
+type JsonQueryValue<Query extends JsonQueryInput> =
+  Query extends string ? LiteralStringInput<Query> : Query
+
 type JsonPathOutputOf<
   Root,
   Target extends JsonPathInput,
@@ -1073,6 +1140,16 @@ type JsonSetOutputOf<
     ? JsonSetAtPath<Root, JsonPath.Path<[Target]>, Next, Operation>
     : never
 
+type JsonSetOutputWithCreateMissing<
+  Root,
+  Target extends JsonPathInput,
+  Next,
+  Operation extends string,
+  CreateMissing extends boolean
+> = false extends CreateMissing
+  ? Root | JsonSetOutputOf<Root, Target, Next, Operation>
+  : JsonSetOutputOf<Root, Target, Next, Operation>
+
 type JsonInsertOutputOf<
   Root,
   Target extends JsonPathInput,
@@ -1085,6 +1162,27 @@ type JsonInsertOutputOf<
     ? JsonInsertAtPath<Root, JsonPath.Path<[Target]>, Next, InsertAfter, Operation>
     : never
 
+type MySqlJsonLengthResult<Value> =
+  JsonLengthResult<Value> extends null ? number : JsonLengthResult<Value>
+
+type MySqlJsonTypeName<Value> =
+  JsonTypeName<Value> extends "object" ? "OBJECT" :
+    JsonTypeName<Value> extends "array" ? "ARRAY" :
+      JsonTypeName<Value> extends "string" ? "STRING" :
+        JsonTypeName<Value> extends "number" ? "INTEGER" | "DOUBLE" | "DECIMAL" :
+          JsonTypeName<Value> extends "boolean" ? "BOOLEAN" :
+            JsonTypeName<Value> extends "null" ? "NULL" :
+              JsonTypeName<Value>
+
+type MySqlUnsupportedJsonFeatureUsageError<Feature extends string> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported mysql json feature"
+  readonly __effect_qb_json_feature__: Feature
+}
+
+type MySqlUnsupportedJsonFeature<Feature extends string> = (
+  feature: MySqlUnsupportedJsonFeatureUsageError<Feature>
+) => never
+
 type JsonPathGuard<
   Root,
   Target extends JsonPathInput,
@@ -1468,7 +1566,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   type: mysqlDatatypes
 }
   const ValuesInputProto = {
-    pipe(this: unknown) {
+    pipe(this: Pipeable) {
       return pipeArguments(this, arguments)
     }
   }
@@ -1479,7 +1577,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     if (value === null || value instanceof Date) {
       return undefined
     }
-    return Schema.Literal(value) as unknown as Schema.Schema.Any
+    return Schema.Literal(value) as Schema.Schema.Any
   }
 
   const literal = <const Value extends LiteralValue>(
@@ -1566,7 +1664,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     value: Expression.Any,
     target: Expression.Any
   ): Expression.Any => {
-    const ast = (value as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    const ast = (value as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
     if (ast.kind !== "literal") {
       return value
     }
@@ -1587,8 +1685,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     left: Expression.Any,
     right: Expression.Any
   ): readonly [Expression.Any, Expression.Any] => {
-    const leftAst = (left as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
-    const rightAst = (right as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    const leftAst = (left as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+    const rightAst = (right as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
     if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
       return [retargetLiteralExpression(left, right), right]
     }
@@ -1621,7 +1719,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   ): readonly Expression.Any[] => {
     const flattened: Array<Expression.Any> = []
     for (const value of values) {
-      const ast = (value as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+      const ast = (value as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
       if (ast.kind === kind) {
         flattened.push(...ast.values)
       } else {
@@ -1667,7 +1765,33 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
         if (operations.every((operation) => typeof operation === "function")) {
           return pipeArguments(this, arguments)
         }
-        throw new TypeError(`Cannot mix query expressions and pipe functions inside ${kind}(...).pipe(...)`)
+        const valuesForMixedPipe = (value: unknown): readonly Expression.Any[] => {
+          if (typeof value !== "object" || value === null || !(Expression.TypeId in value)) {
+            return []
+          }
+          const expression = value as Expression.Any & {
+            readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+          }
+          const ast = expression[ExpressionAst.TypeId]
+          if (ast.kind === kind) {
+            return (ast as {
+              readonly values: readonly Expression.Any[]
+            }).values
+          }
+          return [expression]
+        }
+        let current: unknown = this
+        for (const operation of operations) {
+          if (typeof operation === "function") {
+            current = (operation as (value: unknown) => unknown)(current)
+            continue
+          }
+          current = makeVariadicBooleanExpression(
+            kind,
+            [...valuesForMixedPipe(current), toDialectExpression(operation as ExpressionInput)] as const
+          )
+        }
+        return current
       }
     })
 
@@ -1686,10 +1810,13 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     spec: WindowSpecInput<PartitionBy, OrderBy> | OrderedWindowSpecInput<PartitionBy, Extract<OrderBy, NonEmptyWindowOrderTerms>> | undefined
   ) => {
     const partitionBy = [...(spec?.partitionBy ?? [])] as unknown as PartitionBy
-    const orderBy = (spec?.orderBy ?? []).map((term) => ({
-      value: term.value,
-      direction: term.direction ?? "asc"
-    })) as {
+    const orderBy = (spec?.orderBy ?? []).map((term) => {
+      const direction = term.direction ?? "asc"
+      return {
+        value: term.value,
+        direction
+      }
+    }) as {
       readonly [K in keyof OrderBy]: OrderBy[K] extends WindowOrderTermInput<infer Value extends WindowOrderInput>
         ? { readonly value: Value; readonly direction: OrderDirection }
         : never
@@ -1825,7 +1952,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "eq">
   ): BinaryPredicateExpression<Left, Right, "eq"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "eq")
   }
 
@@ -1835,7 +1963,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "neq">
   ): BinaryPredicateExpression<Left, Right, "neq"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "neq")
   }
 
@@ -1845,7 +1974,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "lt">
   ): BinaryPredicateExpression<Left, Right, "lt"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "lt")
   }
 
@@ -1855,7 +1985,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "lte">
   ): BinaryPredicateExpression<Left, Right, "lte"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "lte")
   }
 
@@ -1865,7 +1996,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "gt">
   ): BinaryPredicateExpression<Left, Right, "gt"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "gt")
   }
 
@@ -1875,7 +2007,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "gte">
   ): BinaryPredicateExpression<Left, Right, "gte"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "gte")
   }
 
@@ -1885,7 +2018,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "like">
   ): BinaryPredicateExpression<Left, Right, "like"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "like")
   }
 
@@ -1895,7 +2029,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "ilike">
   ): BinaryPredicateExpression<Left, Right, "ilike"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "ilike")
   }
 
@@ -1905,7 +2040,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexMatch">
   ): BinaryPredicateExpression<Left, Right, "regexMatch"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexMatch")
   }
 
@@ -1915,7 +2051,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexIMatch">
   ): BinaryPredicateExpression<Left, Right, "regexIMatch"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexIMatch")
   }
 
@@ -1925,7 +2062,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotMatch">
   ): BinaryPredicateExpression<Left, Right, "regexNotMatch"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotMatch")
   }
 
@@ -1935,7 +2073,8 @@ type BinaryPredicateExpression<
   >(
     ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotIMatch">
   ): BinaryPredicateExpression<Left, Right, "regexNotIMatch"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotIMatch")
   }
 
@@ -1945,7 +2084,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "isDistinctFrom">
   ): BinaryPredicateExpression<Left, Right, "isDistinctFrom", "never"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isDistinctFrom", "never")
   }
 
@@ -1955,7 +2095,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ComparableArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "isNotDistinctFrom">
   ): BinaryPredicateExpression<Left, Right, "isNotDistinctFrom", "never"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "isNotDistinctFrom", "never")
   }
 
@@ -2106,62 +2247,62 @@ type BinaryPredicateExpression<
   })
 
   const range = <Kind extends string, Subtype extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     subtype: Subtype
   ): Expression.DbType.Range<Dialect, Subtype, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     subtype
   })
 
   const multirange = <Kind extends string, Subtype extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     subtype: Subtype
   ): Expression.DbType.Multirange<Dialect, Subtype, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     subtype
   })
 
   const record = <Kind extends string, Fields extends Record<string, Expression.DbType.Any>>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     fields: Fields
   ): Expression.DbType.Composite<Dialect, Fields, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     fields
   })
 
   const domain = <Kind extends string, Base extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     base: Base
   ): Expression.DbType.Domain<Dialect, Base, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     base
   })
 
   const enum_ = <Kind extends string>(
-    kind: Kind
+    kind: NonEmptyStringInput<Kind>
   ): Expression.DbType.Enum<Dialect, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     variant: "enum"
   })
 
   const set = <Kind extends string>(
-    kind: Kind
+    kind: NonEmptyStringInput<Kind>
   ): Expression.DbType.Set<Dialect, Kind> => ({
     dialect: profile.dialect,
-    kind,
+    kind: kind as Kind,
     variant: "set"
   })
 
   const custom = <Kind extends string>(
-    kind: Kind
+    kind: NonEmptyStringInput<Kind>
   ): Expression.DbType.Base<Dialect, Kind> => ({
     dialect: profile.dialect,
-    kind
+    kind: kind as Kind
   })
 
   const driverValueMapping = <Db extends Expression.DbType.Any>(
@@ -2655,18 +2796,19 @@ type BinaryPredicateExpression<
   const jsonSet = <
     Base extends JsonExpressionLike<any>,
     Target extends JsonPathInput,
-    Next extends JsonValueInput
+    Next extends JsonValueInput,
+    CreateMissing extends boolean = true
   >(
     base: Base,
-    target: Target & JsonSetGuard<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+    target: Target & JsonSetGuard<Expression.RuntimeOf<Base>, Target, NoInfer<Next>, "json.set">,
     next: Next,
     options: {
-      readonly createMissing?: boolean
+      readonly createMissing?: CreateMissing
     } = {}
   ): JsonExpression<
-    JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+    JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>,
     JsonDbOfExpression<Base>,
-    JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
+    JsonNullabilityOf<JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>>,
     DialectOf<Base>,
     KindOf<Base>,
     DependenciesOf<Base>,
@@ -2677,9 +2819,9 @@ type BinaryPredicateExpression<
     return buildJsonNodeExpression(
       [base, newValue],
       {
-        runtime: undefined as unknown as JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+        runtime: undefined as unknown as JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>,
         dbType: jsonDbTypeOf(base),
-        nullability: undefined as unknown as JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>
+        nullability: undefined as unknown as JsonNullabilityOf<JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>>
       },
       {
         kind: "jsonSet",
@@ -2689,9 +2831,9 @@ type BinaryPredicateExpression<
         createMissing: options.createMissing ?? true
       }
     ) as JsonExpression<
-      JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
+      JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>,
       JsonDbOfExpression<Base>,
-      JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
+      JsonNullabilityOf<JsonSetOutputWithCreateMissing<Expression.RuntimeOf<Base>, Target, Next, "json.set", CreateMissing>>,
       DialectOf<Base>,
       KindOf<Base>,
       DependenciesOf<Base>,
@@ -2706,7 +2848,7 @@ type BinaryPredicateExpression<
     InsertAfter extends boolean = false
   >(
     base: Base,
-    target: Target & JsonInsertGuard<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
+    target: Target & JsonInsertGuard<Expression.RuntimeOf<Base>, Target, NoInfer<Next>, NoInfer<InsertAfter>, "json.insert">,
     next: Next,
     options: {
       readonly insertAfter?: InsertAfter
@@ -2928,7 +3070,7 @@ type BinaryPredicateExpression<
   ) => buildJsonNodeExpression(
     [base],
     {
-      runtime: undefined as unknown as JsonTypeName<Expression.RuntimeOf<Base>>,
+      runtime: undefined as unknown as MySqlJsonTypeName<Expression.RuntimeOf<Base>>,
       dbType: profile.textDb as TextDb,
       nullability: base[Expression.TypeId].nullability
     },
@@ -2943,9 +3085,9 @@ type BinaryPredicateExpression<
   ) => buildJsonNodeExpression(
     [base],
     {
-      runtime: undefined as unknown as JsonLengthResult<Expression.RuntimeOf<Base>>,
+      runtime: undefined as unknown as MySqlJsonLengthResult<Expression.RuntimeOf<Base>>,
       dbType: profile.numericDb as NumericDb,
-      nullability: undefined as unknown as JsonNullabilityOf<JsonLengthResult<Expression.RuntimeOf<Base>>>
+      nullability: undefined as unknown as JsonNullabilityOf<MySqlJsonLengthResult<Expression.RuntimeOf<Base>>>
     },
     {
       kind: "jsonLength",
@@ -2968,9 +3110,12 @@ type BinaryPredicateExpression<
     }
   )
 
-  const jsonPathExists = <Base extends JsonExpressionLike<any>>(
+  const jsonPathExists = <
+    Base extends JsonExpressionLike<any>,
+    Query extends JsonQueryInput
+  >(
     base: Base,
-    query: JsonQueryInput
+    query: JsonQueryValue<Query>
   ) => {
     if (isJsonPathValue(query)) {
       return buildJsonNodeExpression(
@@ -3018,9 +3163,12 @@ type BinaryPredicateExpression<
     }
   )
 
-  const jsonPathMatch = <Base extends JsonExpressionLike<any>>(
+  const jsonPathMatch = <
+    Base extends JsonExpressionLike<any>,
+    Query extends JsonQueryInput
+  >(
     base: Base,
-    query: JsonQueryInput
+    query: JsonQueryValue<Query>
   ) => {
     if (isJsonPathValue(query)) {
       return buildJsonNodeExpression(
@@ -3085,9 +3233,9 @@ type BinaryPredicateExpression<
     typeOf: jsonTypeOf,
     length: jsonLength,
     keys: jsonKeys,
-    stripNulls: jsonStripNulls,
+    stripNulls: jsonStripNulls as unknown as MySqlUnsupportedJsonFeature<"json.stripNulls">,
     pathExists: jsonPathExists,
-    pathMatch: jsonPathMatch
+    pathMatch: jsonPathMatch as unknown as MySqlUnsupportedJsonFeature<"json.pathMatch">
   }
 
   const jsonb = {
@@ -3247,7 +3395,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ContainmentArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "contains">
   ): BinaryPredicateExpression<Left, Right, "contains"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "contains")
   }
 
@@ -3257,7 +3406,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ContainmentArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "containedBy">
   ): BinaryPredicateExpression<Left, Right, "containedBy"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "containedBy")
   }
 
@@ -3267,7 +3417,8 @@ type BinaryPredicateExpression<
   >(
     ...args: ContainmentArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "overlaps">
   ): BinaryPredicateExpression<Left, Right, "overlaps"> => {
-    const [left, right] = args as unknown as [Left, Right]
+    const left = args[0] as Left
+    const right = args[1] as Right
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "overlaps")
   }
 
@@ -3694,12 +3845,9 @@ type BinaryPredicateExpression<
     >
   }
 
-  const call = <
-    Name extends string,
-    Args extends readonly ExpressionInput[]
-  >(
-    name: Name,
-    ...args: Args
+  const call: FunctionCallApi = (
+    name: string,
+    ...args: readonly ExpressionInput[]
   ): Expression.Any => {
     const expressions = args.map((value) => toDialectExpression(value)) as readonly Expression.Any[]
     return makeExpression({
@@ -3920,7 +4068,9 @@ type BinaryPredicateExpression<
       string,
       "scalar",
       Expression.BindingId
-    >
+    > & {
+      readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<any, string>
+    }
   >(
     value: Value
   ): AstBackedExpression<
@@ -3933,9 +4083,6 @@ type BinaryPredicateExpression<
     ExpressionAst.ExcludedNode<AstOf<Value> extends ExpressionAst.ColumnNode<any, infer ColumnName extends string> ? ColumnName : string>
   > => {
     const ast = ((value as unknown) as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
-    if (ast.kind !== "column") {
-      throw new Error("excluded(...) only accepts bound table columns")
-    }
     return makeExpression({
       runtime: undefined as Expression.RuntimeOf<Value>,
       dbType: value[Expression.TypeId].dbType as Expression.DbTypeOf<Value>,
@@ -3948,7 +4095,7 @@ type BinaryPredicateExpression<
       dependencies: {}
     }, {
       kind: "excluded",
-      columnName: ast.columnName
+      columnName: (ast as ExpressionAst.ColumnNode<any, string>).columnName
     }) as unknown as AstBackedExpression<
       Expression.RuntimeOf<Value>,
       Expression.DbTypeOf<Value>,
@@ -3964,22 +4111,56 @@ type BinaryPredicateExpression<
     value: Value,
     column: Expression.Any
   ): Expression.Any => {
+    const columnState = column[Expression.TypeId]
+    const normalizeMutationValue = (candidate: unknown): unknown => {
+      if (candidate === null && columnState.nullability !== "never") {
+        return null
+      }
+      const runtimeSchemaAccepts = columnState.runtimeSchema !== undefined &&
+        (Schema.is(columnState.runtimeSchema) as (input: unknown) => boolean)(candidate)
+      if (runtimeSchemaAccepts) {
+        return candidate
+      }
+      const normalized = normalizeDbValue(columnState.dbType, candidate)
+      return columnState.runtimeSchema === undefined
+        ? normalized
+        : (Schema.decodeUnknownSync as any)(columnState.runtimeSchema)(normalized)
+    }
     if (value !== null && typeof value === "object" && Expression.TypeId in value) {
+      const expression = value as unknown as Expression.Any
+      const ast = (expression as Expression.Any & { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+      if (ast.kind === "literal") {
+        const normalizedValue = normalizeMutationValue(ast.value)
+        return makeExpression({
+          runtime: normalizedValue,
+          dbType: columnState.dbType,
+          runtimeSchema: columnState.runtimeSchema,
+          driverValueMapping: columnState.driverValueMapping,
+          nullability: normalizedValue === null ? "always" : "never",
+          dialect: columnState.dialect,
+          kind: "scalar",
+          dependencies: {}
+        }, {
+          kind: "literal",
+          value: normalizedValue
+        })
+      }
       return retargetLiteralExpression(value as unknown as Expression.Any, column)
     }
+    const normalizedValue = normalizeMutationValue(value)
     return makeExpression({
-      runtime: value as Value,
-      dbType: column[Expression.TypeId].dbType,
-      runtimeSchema: column[Expression.TypeId].runtimeSchema,
-      driverValueMapping: column[Expression.TypeId].driverValueMapping,
-      nullability: value === null ? "always" : "never",
-      dialect: column[Expression.TypeId].dialect,
+      runtime: normalizedValue as Value,
+      dbType: columnState.dbType,
+      runtimeSchema: columnState.runtimeSchema,
+      driverValueMapping: columnState.driverValueMapping,
+      nullability: normalizedValue === null ? "always" : "never",
+      dialect: columnState.dialect,
       kind: "scalar",
 
       dependencies: {}
     }, {
       kind: "literal",
-      value
+      value: normalizedValue
     })
   }
 
@@ -4016,8 +4197,8 @@ type BinaryPredicateExpression<
               : ">="
 
   const targetSourceDetails = (table: MutationTargetLike | SchemaTableLike) => {
-    const sourceName = (table as unknown as TableLike)[Table.TypeId].name
-    const sourceBaseName = (table as unknown as TableLike)[Table.TypeId].baseName
+    const sourceName = (table as TableLike)[Table.TypeId].name
+    const sourceBaseName = (table as TableLike)[Table.TypeId].baseName
     return {
       sourceName,
       sourceBaseName
@@ -4067,16 +4248,16 @@ type BinaryPredicateExpression<
     Alias extends string
   >(
     rows: readonly [Record<string, Expression.Any>, ...Record<string, Expression.Any>[]],
-    selection: ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    selection: ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     alias: Alias
   ): ValuesSource<
     Rows,
-    ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Alias,
     Dialect
   > => {
     const columns = makeColumnReferenceSelection(alias, selection as Record<string, Expression.Any>) as unknown as ValuesOutputShape<
-      Rows[0],
+      Rows,
       Dialect,
       TextDb,
       NumericDb,
@@ -4094,7 +4275,7 @@ type BinaryPredicateExpression<
     }
     return Object.assign(source, columns) as unknown as ValuesSource<
       Rows,
-      ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       Alias,
       Dialect
     >
@@ -4150,6 +4331,11 @@ type BinaryPredicateExpression<
     })
   ) as unknown as AddAvailableMany<{}, MutationTargetNamesOf<Target>, Mode>
 
+  const getMutationColumn = (
+    columns: Record<string, unknown>,
+    columnName: string
+  ): Expression.Any => columns[columnName] as Expression.Any
+
   const buildMutationAssignments = <Target extends MutationTargetInput, Values>(
     target: Target,
     values: Values
@@ -4159,18 +4345,18 @@ type BinaryPredicateExpression<
       const columns = target as unknown as Record<string, Expression.Any>
       return Object.entries(values as Record<string, unknown>).map(([columnName, value]) => ({
         columnName,
-        value: toMutationValueExpression(value, columns[columnName]!)
+        value: toMutationValueExpression(value, getMutationColumn(columns, columnName))
       }))
     }
     const valueMap = values as Record<string, Record<string, unknown> | undefined>
     return targets.flatMap((table) => {
-      const targetName = (table as unknown as TableLike)[Table.TypeId].name
+      const targetName = (table as TableLike)[Table.TypeId].name
       const scopedValues = valueMap[targetName] ?? {}
       const columns = table as unknown as Record<string, Expression.Any>
       return Object.entries(scopedValues).map(([columnName, value]) => ({
         tableName: targetName,
         columnName,
-        value: toMutationValueExpression(value, columns[columnName]!)
+        value: toMutationValueExpression(value, getMutationColumn(columns, columnName))
       }))
     })
   }
@@ -4185,20 +4371,17 @@ type BinaryPredicateExpression<
   } => {
     const firstRow = rows[0]
     const firstColumns = Object.keys(firstRow)
-    if (firstColumns.length === 0) {
-      throw new Error("values(...) rows must specify at least one column; use insert(target) for default-only inserts instead")
-    }
     const columns = firstColumns as [string, ...string[]]
-    const normalizedRows = rows.map((row) => {
-      const rowKeys = Object.keys(row)
-      if (rowKeys.length !== columns.length || columns.some((column) => !(column in row))) {
-        throw new Error("All values(...) rows must project the same columns in the same shape")
-      }
+    const normalizeRow = (row: InsertRowInput<Target>) => {
       const assignments = buildMutationAssignments(target, row) as readonly QueryAst.AssignmentClause[]
       return {
         values: columns.map((columnName) => assignments.find((assignment) => assignment.columnName === columnName)!)
       } satisfies QueryAst.InsertValuesRowClause
-    }) as unknown as [QueryAst.InsertValuesRowClause, ...QueryAst.InsertValuesRowClause[]]
+    }
+    const normalizedRows: readonly [QueryAst.InsertValuesRowClause, ...QueryAst.InsertValuesRowClause[]] = [
+      normalizeRow(rows[0]),
+      ...rows.slice(1).map(normalizeRow)
+    ]
     const required = normalizedRows.flatMap((row) =>
       row.values.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
     )
@@ -4213,9 +4396,6 @@ type BinaryPredicateExpression<
     selection: Record<string, Expression.Any>
   ): readonly [string, ...string[]] => {
     const columns = Object.keys(selection)
-    if (columns.length === 0) {
-      throw new Error("insert(...).pipe(from(subquery)) requires at least one projected column")
-    }
     return columns as [string, ...string[]]
   }
 
@@ -4230,41 +4410,33 @@ type BinaryPredicateExpression<
     }[]
   } => {
     const entries = Object.entries(values)
-    if (entries.length === 0) {
-      throw new Error("unnest(...) requires at least one column array")
-    }
     const columns = entries.map(([columnName]) => columnName) as [string, ...string[]]
-    const normalized = entries.map(([columnName, items]) => {
-      if (!Array.isArray(items)) {
-        throw new Error("unnest(...) expects every value to be an array")
-      }
-      return {
-        columnName,
-        values: items
-      }
-    })
-    const expectedLength = normalized[0]!.values.length
-    if (normalized.some((entry) => entry.values.length !== expectedLength)) {
-      throw new Error("unnest(...) expects every column array to have the same length")
-    }
-    const knownColumns = new Set(Object.keys(target[Table.TypeId].fields))
-    if (columns.some((columnName) => !knownColumns.has(columnName))) {
-      throw new Error("unnest(...) received a column that does not exist on the target table")
-    }
+    const normalized = entries.map(([columnName, items]) => ({
+      columnName,
+      values: items
+    }))
     return {
       columns,
       values: normalized
     }
   }
 
+  const normalizeConflictColumns = <Target extends MutationTargetLike>(
+    target: Target,
+    columnsInput: string | readonly string[]
+  ): readonly [string, ...string[]] => {
+    const columns = normalizeColumnList(columnsInput) as readonly [string, ...string[]]
+    return columns
+  }
+
   const buildConflictTarget = <Target extends MutationTargetLike>(
     target: Target,
-    input: readonly string[] | { readonly columns: readonly string[]; readonly where?: PredicateInput } | { readonly constraint: string }
+    input: string | readonly string[] | { readonly columns: string | readonly string[]; readonly where?: PredicateInput } | { readonly constraint: string }
   ): QueryAst.ConflictTargetClause => {
-    if (Array.isArray(input)) {
+    if (typeof input === "string" || Array.isArray(input)) {
       return {
         kind: "columns",
-        columns: normalizeColumnList(input) as readonly [string, ...string[]]
+        columns: normalizeConflictColumns(target, input)
       }
     }
     if (!Array.isArray(input) && "constraint" in input) {
@@ -4274,12 +4446,12 @@ type BinaryPredicateExpression<
       }
     }
     const columnTarget = input as {
-      readonly columns: readonly string[]
+      readonly columns: string | readonly string[]
       readonly where?: PredicateInput
     }
     return {
       kind: "columns",
-      columns: normalizeColumnList(columnTarget.columns) as readonly [string, ...string[]],
+      columns: normalizeConflictColumns(target, columnTarget.columns),
       where: columnTarget.where === undefined ? undefined : toDialectExpression(columnTarget.where)
     }
   }
@@ -4317,20 +4489,30 @@ type ValidateDdlColumns<
   Columns extends readonly string[]
 > = Exclude<Columns[number], SchemaColumnNames<Target>> extends never ? Columns : never
 
+type ValidateDdlColumnInput<
+  Target extends SchemaTableLike,
+  Columns extends DdlColumnInput
+> = ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>> extends never ? never : Columns
+
 type ValidateTargetColumns<
   Target extends MutationTargetLike,
   Columns extends readonly string[]
 > = Exclude<Columns[number], Extract<keyof Target[typeof Table.TypeId]["fields"], string>> extends never ? Columns : never
 
-type CreateIndexOptions = {
-  readonly name?: string
+type ValidateTargetColumnInput<
+  Target extends MutationTargetLike,
+  Columns extends DdlColumnInput
+> = ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>> extends never ? never : Columns
+
+type CreateIndexOptions<Name extends string = string> = {
+  readonly name?: NonEmptyStringInput<Name>
   readonly unique?: boolean
-  readonly ifNotExists?: boolean
+  readonly ifNotExists?: never
 }
 
-type DropIndexOptions = {
-  readonly name?: string
-  readonly ifExists?: boolean
+type DropIndexOptions<Name extends string = string> = {
+  readonly name?: NonEmptyStringInput<Name>
+  readonly ifExists?: never
 }
 
 type CreateTableOptions = {
@@ -4342,8 +4524,8 @@ type DropTableOptions = {
 }
 
 type TruncateOptions = {
-  readonly restartIdentity?: boolean
-  readonly cascade?: boolean
+  readonly restartIdentity?: never
+  readonly cascade?: never
 }
 
 type TransactionOptions = {
@@ -4351,10 +4533,15 @@ type TransactionOptions = {
   readonly readOnly?: boolean
 }
 
-type LockOptions = {
-  readonly nowait?: boolean
-  readonly skipLocked?: boolean
-}
+type LockOptions =
+  | {
+    readonly nowait?: boolean
+    readonly skipLocked?: false
+  }
+  | {
+    readonly nowait?: false
+    readonly skipLocked?: boolean
+  }
 
 type UpsertConflictOptions = {
   readonly update?: Record<string, unknown>
@@ -4369,14 +4556,133 @@ type InsertRowInput<Target extends MutationTargetLike> = MutationInputOf<Table.I
 type ValuesRowInput = Record<string, ExpressionInput>
 type ValuesRowsInput = readonly [ValuesRowInput, ...ValuesRowInput[]]
 
+type ValuesColumnInput<Row, Key extends PropertyKey> =
+  Row extends ValuesRowInput
+    ? Key extends keyof Row ? Row[Key] : never
+    : never
+
+type ValuesRowShapeMismatch<
+  First extends ValuesRowInput,
+  Row extends ValuesRowInput
+> =
+  | Exclude<Extract<keyof Row, string>, Extract<keyof First, string>>
+  | Exclude<Extract<keyof First, string>, Extract<keyof Row, string>>
+
+type ValuesRowsShapeMismatchesFor<
+  First extends ValuesRowInput,
+  Row
+> = Row extends ValuesRowInput ? ValuesRowShapeMismatch<First, Row> : never
+
+type ValuesRowsShapeMismatches<Rows extends ValuesRowsInput> =
+  Rows extends readonly [infer First extends ValuesRowInput, ...infer Rest extends ValuesRowInput[]]
+    ? ValuesRowsShapeMismatchesFor<First, Rest[number]>
+    : never
+
+type ValuesRowsColumnKeys<Rows extends ValuesRowsInput> =
+  Rows extends readonly [infer First extends ValuesRowInput, ...ValuesRowInput[]]
+    ? Extract<keyof First, string>
+    : never
+
+type ValuesRowsShapeInput<Rows extends ValuesRowsInput> =
+  [ValuesRowsColumnKeys<Rows>] extends [never]
+    ? {
+        readonly __effect_qb_error__: "effect-qb: values rows must project at least one column"
+      }
+    : [ValuesRowsShapeMismatches<Rows>] extends [never]
+      ? unknown
+    : {
+        readonly __effect_qb_error__: "effect-qb: values rows must project the same columns"
+        readonly __effect_qb_mismatched_columns__: ValuesRowsShapeMismatches<Rows>
+      }
+
+type ValuesRowsDialect<
+  Rows extends ValuesRowsInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Rows[number][keyof Rows[number]] extends infer Value extends ExpressionInput
+  ? DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  : never
+
+type ValuesRowsDialectInput<
+  Rows extends ValuesRowsInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Exclude<ValuesRowsDialect<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Dialect | "standard"> extends never
+  ? unknown
+  : {
+      readonly __effect_qb_error__: "effect-qb: values rows cannot mix dialects"
+      readonly __effect_qb_dialect__: ValuesRowsDialect<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    }
+
 type UnnestColumnsInput = Record<string, readonly [ExpressionInput, ...ExpressionInput[]]>
 
+type IsNever<Value> = [Value] extends [never] ? true : false
+
+type IsUnion<Value, All = Value> = Value extends any
+  ? ([All] extends [Value] ? false : true)
+  : never
+
+type UnnestColumnKeys<Columns extends UnnestColumnsInput> =
+  Extract<keyof Columns, string>
+
+type UnnestColumnLengths<Columns extends UnnestColumnsInput> =
+  Columns[UnnestColumnKeys<Columns>]["length"]
+
+type UnnestColumnsShapeInput<Columns extends UnnestColumnsInput> =
+  IsNever<UnnestColumnKeys<Columns>> extends true
+    ? {
+        readonly __effect_qb_error__: "effect-qb: unnest requires at least one column array"
+      }
+    : number extends UnnestColumnLengths<Columns>
+      ? unknown
+      : IsUnion<UnnestColumnLengths<Columns>> extends true
+        ? {
+            readonly __effect_qb_error__: "effect-qb: unnest column arrays must have the same length"
+            readonly __effect_qb_column_lengths__: UnnestColumnLengths<Columns>
+          }
+        : unknown
+
+type UnnestColumnsDialect<
+  Columns extends UnnestColumnsInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Columns[UnnestColumnKeys<Columns>][number] extends infer Value extends ExpressionInput
+  ? DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  : never
+
+type UnnestColumnsDialectInput<
+  Columns extends UnnestColumnsInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Exclude<UnnestColumnsDialect<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Dialect | "standard"> extends never
+  ? unknown
+  : {
+      readonly __effect_qb_error__: "effect-qb: unnest columns cannot mix dialects"
+      readonly __effect_qb_dialect__: UnnestColumnsDialect<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    }
+
 type UnnestRowShape<Shape extends Record<string, readonly unknown[]>> = {
   readonly [K in keyof Shape]: Shape[K] extends readonly (infer Item)[] ? Item : never
 }
 
 type ValuesOutputShape<
-  Row extends ValuesRowInput,
+  Rows extends ValuesRowsInput,
   Dialect extends string,
   TextDb extends Expression.DbType.Any,
   NumericDb extends Expression.DbType.Any,
@@ -4384,7 +4690,7 @@ type ValuesOutputShape<
   TimestampDb extends Expression.DbType.Any,
   NullDb extends Expression.DbType.Any
 > = {
-  readonly [K in keyof Row]: DialectAsExpression<Row[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  readonly [K in keyof Rows[0]]: DialectAsExpression<ValuesColumnInput<Rows[number], K>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 }
 
 type UnnestOutputShape<
@@ -4423,19 +4729,44 @@ type DistinctOnUnsupportedError<Dialect extends string> = {
   readonly __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
 }
 
+type FullJoinUnsupportedError<Dialect extends string> = {
+  readonly __effect_qb_error__: "effect-qb: fullJoin(...) is only supported by the postgres dialect"
+  readonly __effect_qb_dialect__: Dialect
+  readonly __effect_qb_hint__: "Use leftJoin/rightJoin with nullable handling or switch to postgres.Query.fullJoin(...)"
+}
+
+type ReturningUnsupportedError<Dialect extends string> = {
+  readonly __effect_qb_error__: "effect-qb: returning(...) is only supported by the postgres dialect"
+  readonly __effect_qb_dialect__: Dialect
+  readonly __effect_qb_hint__: "Use postgres.Query.returning(...) or run a follow-up select after MySQL mutations"
+}
+
+type MysqlCteStatementError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  PlanValue & {
+    readonly __effect_qb_error__: "effect-qb: mysql cte sources only accept select-like query plans"
+    readonly __effect_qb_statement__: StatementOfPlan<PlanValue>
+    readonly __effect_qb_hint__: "Use select(...) or a set operator before wrapping a MySQL plan in with(...)"
+  }
+
+type MysqlCteCompatiblePlan<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
+> = StatementOfPlan<PlanValue> extends "select" | "set"
+  ? DerivedSourceCompatiblePlan<PlanValue>
+  : MysqlCteStatementError<PlanValue>
+
 type DistinctOnApi<Dialect extends string> = Dialect extends "postgres"
-  ? <Values extends readonly ExpressionInput[]>(
+  ? <Values extends readonly [ExpressionInput, ...ExpressionInput[]]>(
       ...values: Values
     ) => <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
-      RequiredOfPlan<PlanValue>,
+      AddExpressionRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Values[number]>,
       AvailableOfPlan<PlanValue>,
-      PlanDialectOf<PlanValue>,
+      PlanDialectOf<PlanValue> | DialectOfDialectInput<Values[number], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue>,
-      OutstandingOfPlan<PlanValue>,
+      AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Values[number]>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
       StatementOfPlan<PlanValue>
@@ -4468,6 +4799,27 @@ type MysqlConflictWhereError<Values> = Values & {
   readonly __effect_qb_hint__: "Move the condition into the update assignment expressions or use the Postgres dialect"
 }
 
+type UpdateValuesNonEmptyError<Values> = Values & {
+  readonly __effect_qb_error__: "effect-qb: update statements require at least one assignment"
+}
+
+type UpdateValuesNonEmptyConstraint<Values> =
+  [Extract<keyof Values, string>] extends [never]
+    ? UpdateValuesNonEmptyError<Values>
+    : unknown
+
+type NestedUpdateValuesNonEmptyConstraint<Values> =
+  [Extract<keyof Values, string>] extends [never]
+    ? UpdateValuesNonEmptyError<Values>
+    : true extends {
+      [K in Extract<keyof Values, string>]:
+        Values[K] extends Record<string, unknown>
+          ? [Extract<keyof Values[K], string>] extends [never] ? false : true
+          : false
+    }[Extract<keyof Values, string>]
+      ? unknown
+      : UpdateValuesNonEmptyError<Values>
+
 type InsertShapeExtraKeys<TargetShape, SourceShape> = Exclude<Extract<keyof SourceShape, string>, Extract<keyof TargetShape, string>>
 type InsertShapeMissingKeys<TargetShape, SourceShape> = Exclude<RequiredKeys<TargetShape>, Extract<keyof SourceShape, string>>
 type InsertShapeMismatchedKeys<TargetShape, SourceShape> = Extract<{
@@ -4561,10 +4913,15 @@ type InsertSourceRequired<Source> =
       Source extends QueryPlan<any, any, any, any, any, any, any, any, any, any> ? RequiredOfPlan<Source> :
         never
 
+type InsertSourceDialect<Source> =
+  Source extends QueryPlan<any, any, any, any, any, any, any, any, any, any> ? PlanDialectOf<Source> :
+    Source extends SourceLike ? SourceDialectOf<Source> :
+      never
+
 type ConflictColumnTarget<
   Target extends MutationTargetLike,
   Columns extends DdlColumnInput
-> = ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>>
+> = ValidateTargetColumnInput<Target, Columns>
 
 type ConflictTargetInput<
   Target extends MutationTargetLike,
@@ -4585,6 +4942,11 @@ type ConflictTargetInput<
           readonly constraint?: string
         }>)
 
+type ConflictConstraintNameConstraint<Target> =
+  Target extends { readonly constraint: infer Constraint extends string }
+    ? { readonly constraint: NonEmptyStringInput<Constraint> }
+    : unknown
+
 type ConflictActionInput<
   Target extends MutationTargetLike,
   Dialect extends string,
@@ -4594,6 +4956,55 @@ type ConflictActionInput<
   readonly where?: Dialect extends "postgres" ? PredicateInput : MysqlConflictWhereError<PredicateInput>
 }
 
+type ConflictActionUpdateNonEmptyConstraint<Options> =
+  Options extends { readonly update: infer Values }
+    ? UpdateValuesNonEmptyConstraint<Values>
+    : unknown
+
+type ConflictTargetPredicate<Target> =
+  Target extends { readonly where?: infer Predicate } ? Extract<Predicate, PredicateInput> : never
+
+type ConflictActionPredicate<Options> =
+  Options extends { readonly where?: infer Predicate } ? Extract<Predicate, PredicateInput> : never
+
+type MutationDialectFromValues<
+  Values extends Record<string, unknown>,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = {
+  [K in keyof Values]: Values[K] extends ExpressionInput
+    ? DialectOfDialectInput<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    : never
+}[keyof Values]
+
+type ConflictRequired<
+  UpdateValues extends MutationInputOf<any> | undefined,
+  Options,
+  ConflictTarget
+> =
+  | MutationRequiredFromValues<Exclude<UpdateValues, undefined>>
+  | RequiredFromInput<ConflictActionPredicate<Options>>
+  | RequiredFromInput<ConflictTargetPredicate<ConflictTarget>>
+
+type ConflictDialect<
+  UpdateValues extends MutationInputOf<any> | undefined,
+  Options,
+  ConflictTarget,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> =
+  | MutationDialectFromValues<Exclude<UpdateValues, undefined>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  | DialectOfDialectInput<ConflictActionPredicate<Options>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+  | DialectOfDialectInput<ConflictTargetPredicate<ConflictTarget>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+
 type MergeWhenMatchedDelete<
   Predicate extends PredicateInput | undefined = undefined
 > = {
@@ -4621,16 +5032,33 @@ type MergeWhenNotMatched<
   readonly predicate?: Predicate
 }
 
+type MergeMatchedOption<
+  Target extends MutationTargetLike,
+  MatchedValues extends MutationInputOf<Table.UpdateOf<Target>>,
+  MatchedPredicate extends PredicateInput | undefined = undefined
+> = MergeWhenMatchedDelete<MatchedPredicate> | MergeWhenMatchedUpdate<Target, MatchedValues, MatchedPredicate>
+
+type MergeNotMatchedOption<
+  Target extends MutationTargetLike,
+  InsertValues extends MutationInputOf<Table.InsertOf<Target>>,
+  NotMatchedPredicate extends PredicateInput | undefined = undefined
+> = MergeWhenNotMatched<Target, InsertValues, NotMatchedPredicate>
+
 type MergeOptions<
   Target extends MutationTargetLike,
   MatchedValues extends MutationInputOf<Table.UpdateOf<Target>>,
   InsertValues extends MutationInputOf<Table.InsertOf<Target>>,
   MatchedPredicate extends PredicateInput | undefined = undefined,
   NotMatchedPredicate extends PredicateInput | undefined = undefined
-> = {
-  readonly whenMatched?: MergeWhenMatchedDelete<MatchedPredicate> | MergeWhenMatchedUpdate<Target, MatchedValues, MatchedPredicate>
-  readonly whenNotMatched?: MergeWhenNotMatched<Target, InsertValues, NotMatchedPredicate>
-}
+> =
+  | {
+    readonly whenMatched: MergeMatchedOption<Target, MatchedValues, MatchedPredicate>
+    readonly whenNotMatched?: MergeNotMatchedOption<Target, InsertValues, NotMatchedPredicate>
+  }
+  | {
+    readonly whenMatched?: MergeMatchedOption<Target, MatchedValues, MatchedPredicate>
+    readonly whenNotMatched: MergeNotMatchedOption<Target, InsertValues, NotMatchedPredicate>
+  }
 
 type RequireSelectStatement<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
   StatementOfPlan<PlanValue> extends "select" ? unknown : never
@@ -4662,6 +5090,38 @@ type MutationOrderLimitSupported<PlanValue extends QueryPlan<any, any, any, any,
       ? StatementOfPlan<PlanValue> extends "update" | "delete" ? unknown : never
       : never
 
+type MutationTargetTupleDialectConstraint<
+  Targets extends MutationTargetTuple,
+  Dialect extends string
+> = Exclude<TableDialectOf<Targets[number]>, Dialect | "standard"> extends never ? unknown : never
+
+type DuplicateMutationTargetSourceName<
+  Targets extends readonly MutationTargetLike[],
+  Seen extends string = never
+> = Targets extends readonly [infer Head extends MutationTargetLike, ...infer Tail extends readonly MutationTargetLike[]]
+  ? SourceNameOf<Head> extends infer Name extends string
+    ? string extends Name
+      ? DuplicateMutationTargetSourceName<Tail, Seen>
+      : Name extends Seen
+        ? Name
+        : DuplicateMutationTargetSourceName<Tail, Seen | Name>
+    : never
+  : never
+
+type MutationTargetTupleDuplicateNameError<Name extends string> = {
+  readonly __effect_qb_error__: "effect-qb: mutation target source names must be unique"
+  readonly __effect_qb_duplicate_source_name__: Name
+  readonly __effect_qb_hint__: "Alias duplicate mutation targets with Table.alias(...)"
+}
+
+type MutationTargetTupleUniqueNamesConstraint<
+  Targets extends MutationTargetTuple
+> = DuplicateMutationTargetSourceName<Targets> extends infer Name extends string
+  ? [Name] extends [never]
+    ? unknown
+    : MutationTargetTupleDuplicateNameError<Name>
+  : unknown
+
 type MutationRequiredFromValues<Values extends Record<string, unknown>> = {
   [K in keyof Values]: Values[K] extends Expression.Any ? RequiredFromDependencies<DependenciesOf<Values[K]>> : never
 }[keyof Values]
@@ -4675,6 +5135,59 @@ type NestedMutationRequiredFromValues<Values> =
         }[keyof Values]
       : never
 
+type NestedMutationDialectFromValues<
+  Values,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> =
+  Values extends ExpressionInput
+    ? DialectOfDialectInput<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    : Values extends Record<string, unknown>
+      ? {
+          [K in keyof Values]: NestedMutationDialectFromValues<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+        }[keyof Values]
+      : never
+
+type KnownMutationDialectFromValues<
+  Values,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = NestedMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> extends infer Current
+  ? Current extends string
+    ? string extends Current ? never : Current
+    : never
+  : never
+
+type KnownIncompatibleMutationDialectFromValues<
+  Values,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Exclude<KnownMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Dialect | "standard">
+
+type MutationValuesDialectConstraint<
+  Values,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = KnownIncompatibleMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> extends never
+  ? unknown
+  : never
+
 type MutationAssignments<Shape extends Record<string, unknown>> = {
   readonly [K in keyof Shape]: QueryAst.AssignmentClause
 }
@@ -4708,12 +5221,40 @@ type InsertDirectSource =
 
 type FromInput = SourceLike | InsertDirectSource
 
+type SourceDialectConstraint<
+  CurrentSource extends SourceLike,
+  Dialect extends string
+> = [SourceDialectOf<CurrentSource>] extends [never]
+  ? unknown
+  : Exclude<SourceDialectOf<CurrentSource>, Dialect | "standard"> extends never
+    ? unknown
+    : Dialect extends "standard"
+      ? unknown
+      : never
+
+type SourceRequirementConstraint<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  CurrentSource extends SourceLike
+> = [SourceRequiredOf<CurrentSource>] extends [never]
+  ? unknown
+  : Exclude<SourceRequiredOf<CurrentSource>, ScopedNamesOfPlan<PlanValue>> extends never
+    ? unknown
+    : SourceRequirementError<CurrentSource>
+
 type SelectFromConstraint<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   CurrentSource extends SourceLike
 > =
   RequireSelectStatement<PlanValue> &
-  (SourceNameOf<CurrentSource> extends OutstandingOfPlan<PlanValue> ? unknown : never) &
+  (
+    SourceNameOf<CurrentSource> extends OutstandingOfPlan<PlanValue>
+      ? unknown
+      : [OutstandingOfPlan<PlanValue>] extends [never]
+        ? [ScopedNamesOfPlan<PlanValue>] extends [never]
+          ? unknown
+          : never
+        : never
+  ) &
   (SourceRequiredOf<CurrentSource> extends never ? unknown : SourceRequirementError<CurrentSource>)
 
 type UpdateFromConstraint<
@@ -4730,7 +5271,7 @@ type InsertFromConstraint<
   Dialect extends string
 > =
   RequirePendingInsertStatement<PlanValue> &
-  (InsertSourceOfPlanInput<PlanValue, CurrentSource, Dialect> extends CurrentSource
+  (CurrentSource extends InsertSourceOfPlanInput<PlanValue, CurrentSource, Dialect>
     ? unknown
     : InsertSourceOfPlanInput<PlanValue, CurrentSource, Dialect>)
 
@@ -4784,12 +5325,12 @@ type InsertFromResult<
   Dialect extends string
 > = QueryPlan<
   SelectionOfPlan<PlanValue>,
-  Exclude<InsertSourceRequired<CurrentSource>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+  InsertSourceRequired<CurrentSource>,
   AvailableOfPlan<PlanValue>,
-  PlanDialectOf<PlanValue>,
+  PlanDialectOf<PlanValue> | InsertSourceDialect<CurrentSource>,
   GroupedOfPlan<PlanValue>,
   ScopedNamesOfPlan<PlanValue>,
-  Exclude<InsertSourceRequired<CurrentSource>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+  InsertSourceRequired<CurrentSource>,
   AssumptionsOfPlan<PlanValue>,
   CurrentSource extends QueryPlan<any, any, any, any, any, any, any, any, any, any>
     ? MergeCapabilities<CapabilitiesOfPlan<PlanValue>, CapabilitiesOfPlan<CurrentSource>>
@@ -4806,15 +5347,17 @@ type FromPlanConstraint<
   Dialect extends string
 > =
   CurrentSource extends SourceLike
-    ? StatementOfPlan<PlanValue> extends "select"
-      ? SelectFromConstraint<PlanValue, CurrentSource>
-      : StatementOfPlan<PlanValue> extends "update"
-        ? UpdateFromConstraint<PlanValue, CurrentSource>
-        : StatementOfPlan<PlanValue> extends "insert"
-          ? CurrentSource extends AnyValuesSource | AnyUnnestSource
-            ? InsertFromConstraint<PlanValue, CurrentSource, Dialect>
-            : never
-          : never
+    ? SourceDialectConstraint<CurrentSource, Dialect> & (
+        StatementOfPlan<PlanValue> extends "select"
+          ? SelectFromConstraint<PlanValue, CurrentSource>
+          : StatementOfPlan<PlanValue> extends "update"
+            ? UpdateFromConstraint<PlanValue, CurrentSource>
+            : StatementOfPlan<PlanValue> extends "insert"
+              ? CurrentSource extends AnyValuesSource | AnyUnnestSource
+                ? InsertFromConstraint<PlanValue, CurrentSource, Dialect>
+                : never
+              : never
+      )
     : CurrentSource extends InsertDirectSource
       ? StatementOfPlan<PlanValue> extends "insert"
         ? InsertFromConstraint<PlanValue, CurrentSource, Dialect>
@@ -4869,7 +5412,10 @@ export type PublicStructuredFromResult<
         Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
         AssumptionsOfPlan<PlanValue>,
         MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
-        StatementOfPlan<PlanValue>
+        StatementOfPlan<PlanValue>,
+        MutationTargetOfPlan<PlanValue>,
+        InsertSourceStateOfPlan<PlanValue>,
+        FactsOfPlan<PlanValue>
       >
     : StatementOfPlan<PlanValue> extends "update"
       ? QueryPlan<
@@ -4882,7 +5428,10 @@ export type PublicStructuredFromResult<
           Exclude<OutstandingOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
           AssumptionsOfPlan<PlanValue>,
           MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentSource>>,
-          StatementOfPlan<PlanValue>
+          StatementOfPlan<PlanValue>,
+          MutationTargetOfPlan<PlanValue>,
+          InsertSourceStateOfPlan<PlanValue>,
+          FactsOfPlan<PlanValue>
         >
       : StatementOfPlan<PlanValue> extends "insert"
       ? CurrentSource extends AnyValuesSource | AnyUnnestSource
@@ -4890,7 +5439,7 @@ export type PublicStructuredFromResult<
             SelectionOfPlan<PlanValue>,
             never,
             AvailableOfPlan<PlanValue>,
-            PlanDialectOf<PlanValue>,
+            PlanDialectOf<PlanValue> | SourceDialectOf<CurrentSource>,
             GroupedOfPlan<PlanValue>,
             ScopedNamesOfPlan<PlanValue>,
             never,
@@ -4898,7 +5447,8 @@ export type PublicStructuredFromResult<
             CapabilitiesOfPlan<PlanValue>,
             StatementOfPlan<PlanValue>,
             MutationTargetOfPlan<PlanValue>,
-            "ready"
+            "ready",
+            FactsOfPlan<PlanValue>
           >
         : FromPlanResult<PlanValue, CurrentSource, Dialect>
       : FromPlanResult<PlanValue, CurrentSource, Dialect>
@@ -4944,7 +5494,7 @@ type AsCurriedResult<
   function as<
     Alias extends string
   >(
-    alias: Alias
+    alias: LiteralStringInput<Alias>
   ): <Value extends AsCurriedInput<Dialect>>(
     value: Value
   ) => AsCurriedResult<Value, Alias, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
@@ -4953,21 +5503,21 @@ type AsCurriedResult<
     Alias extends string
   >(
     value: Value,
-    alias: Alias
-  ): DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    alias: LiteralStringInput<Alias>
+  ): ProjectionAliasedExpression<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Alias>
   function as<
     Rows extends ValuesRowsInput,
     Alias extends string
   >(
     value: ValuesInput<
       Rows,
-      ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       Dialect
     >,
-    alias: Alias
+    alias: LiteralStringInput<Alias>
   ): ValuesSource<
     Rows,
-    ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Alias,
     Dialect
   >
@@ -4975,12 +5525,12 @@ type AsCurriedResult<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
-    value: CompletePlan<PlanValue>,
-    alias: Alias
+    value: DerivedTableCompatiblePlan<PlanValue>,
+    alias: LiteralStringInput<Alias>
   ): DerivedSource<PlanValue, Alias>
   function as(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
-      return (value: unknown) => as(value as any, valueOrAlias as string)
+      return (value: unknown) => as(value as any, valueOrAlias as never)
     }
     const resolvedAlias = alias
     const value = valueOrAlias
@@ -5020,20 +5570,20 @@ type AsCurriedResult<
   function with_<
     Alias extends string
   >(
-    alias: Alias
+    alias: LiteralStringInput<Alias>
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    value: CompletePlan<PlanValue>
+    value: MysqlCteCompatiblePlan<PlanValue>
   ) => import("../../internal/query.js").CteSource<PlanValue, Alias>
   function with_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
-    value: CompletePlan<PlanValue>,
-    alias: Alias
+    value: MysqlCteCompatiblePlan<PlanValue>,
+    alias: LiteralStringInput<Alias>
   ): import("../../internal/query.js").CteSource<PlanValue, Alias>
   function with_(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
-      return (value: unknown) => with_(value as any, valueOrAlias as string)
+      return (value: unknown) => with_(value as any, valueOrAlias as never)
     }
     return makeCteSource(
       valueOrAlias as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>,
@@ -5044,20 +5594,20 @@ type AsCurriedResult<
   function withRecursive_<
     Alias extends string
   >(
-    alias: Alias
+    alias: LiteralStringInput<Alias>
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    value: CompletePlan<PlanValue>
+    value: MysqlCteCompatiblePlan<PlanValue>
   ) => import("../../internal/query.js").CteSource<PlanValue, Alias>
   function withRecursive_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
-    value: CompletePlan<PlanValue>,
-    alias: Alias
+    value: MysqlCteCompatiblePlan<PlanValue>,
+    alias: LiteralStringInput<Alias>
   ): import("../../internal/query.js").CteSource<PlanValue, Alias>
   function withRecursive_(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
-      return (value: unknown) => withRecursive_(value as any, valueOrAlias as string)
+      return (value: unknown) => withRecursive_(value as any, valueOrAlias as never)
     }
     return makeCteSource(
       valueOrAlias as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>,
@@ -5069,20 +5619,20 @@ type AsCurriedResult<
   function lateral<
     Alias extends string
   >(
-    alias: Alias
+    alias: LiteralStringInput<Alias>
   ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-    value: PlanValue
+    value: LateralSourceCompatiblePlan<PlanValue>
   ) => import("../../internal/query.js").LateralSource<PlanValue, Alias>
   function lateral<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
-    value: PlanValue,
-    alias: Alias
+    value: LateralSourceCompatiblePlan<PlanValue>,
+    alias: LiteralStringInput<Alias>
   ): import("../../internal/query.js").LateralSource<PlanValue, Alias>
   function lateral(valueOrAlias: unknown, alias?: string): unknown {
     if (alias === undefined) {
-      return (value: unknown) => lateral(value as any, valueOrAlias as string)
+      return (value: unknown) => lateral(value as any, valueOrAlias as never)
     }
     return makeLateralSource(
       valueOrAlias as QueryPlan<any, any, any, any, any, any, any, any, any, any>,
@@ -5094,9 +5644,11 @@ type AsCurriedResult<
     Rows extends ValuesRowsInput
   >(
     rows: Rows
+      & ValuesRowsShapeInput<Rows>
+      & ValuesRowsDialectInput<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
   ) => ValuesInput<
     Rows,
-    ValuesOutputShape<Rows[0], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    ValuesOutputShape<Rows, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Dialect
   >
 
@@ -5104,8 +5656,10 @@ type AsCurriedResult<
     Columns extends UnnestColumnsInput,
     Alias extends string
   >(
-    columns: Columns,
-    alias: Alias
+    columns: Columns
+      & UnnestColumnsShapeInput<Columns>
+      & UnnestColumnsDialectInput<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    alias: LiteralStringInput<Alias>
   ) => UnnestSource<
     UnnestOutputShape<Columns, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     Alias,
@@ -5118,10 +5672,10 @@ type AsCurriedResult<
     Step extends NumericExpressionInput | undefined = undefined,
     Alias extends string = "series"
   >(
-    start: Start,
-    stop: Stop,
-    step?: Step,
-    alias?: Alias
+    start: Start & NumericExpressionDialectInput<Start, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    stop: Stop & NumericExpressionDialectInput<Stop, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    step?: Step & (Step extends NumericExpressionInput ? NumericExpressionDialectInput<Step, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> : unknown),
+    alias?: LiteralStringInput<Alias>
   ) => Dialect extends "postgres"
     ? TableFunctionSource<
         GenerateSeriesOutputShape<Start, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
@@ -5131,8 +5685,45 @@ type AsCurriedResult<
       >
     : GenerateSeriesUnsupportedError<Dialect>
 
-  export type SelectApi = <Selection extends SelectionShape>(
-    selection: Selection
+  type SelectSelectionNonEmptyError<Selection> = Selection & {
+    readonly __effect_qb_error__: "effect-qb: mysql select statements require at least one selected expression"
+  }
+
+  type SelectionRootObjectError<Selection> = Selection & {
+    readonly __effect_qb_error__: "effect-qb: selections must be projection objects"
+    readonly __effect_qb_hint__: "Use select({ value: expression }) or returning({ value: expression })"
+  }
+
+  type SelectionRootObjectConstraint<Selection> =
+    Selection extends Expression.Any ? SelectionRootObjectError<Selection> : unknown
+
+  type SelectionNestedEmptyError<Selection> = Selection & {
+    readonly __effect_qb_error__: "effect-qb: projection objects cannot contain empty nested selections"
+  }
+
+  type SelectionHasEmptyNestedObject<Selection, IsRoot extends boolean> =
+    Selection extends Expression.Any
+      ? false
+      : Selection extends Record<string, any>
+        ? [Extract<keyof Selection, string>] extends [never]
+          ? IsRoot extends true ? false : true
+          : true extends {
+              [K in Extract<keyof Selection, string>]: SelectionHasEmptyNestedObject<Selection[K], false>
+            }[Extract<keyof Selection, string>]
+            ? true
+            : false
+        : false
+
+  type SelectionNestedNonEmptyConstraint<Selection> =
+    SelectionHasEmptyNestedObject<Selection, true> extends true ? SelectionNestedEmptyError<Selection> : unknown
+
+  type SelectSelectionNonEmptyConstraint<Selection> =
+    [Extract<keyof Selection, string>] extends [never]
+      ? SelectSelectionNonEmptyError<Selection>
+      : unknown
+
+  export type SelectApi = <const Selection extends SelectionShape>(
+    selection: Selection & SelectionRootObjectConstraint<Selection> & SelectionNestedNonEmptyConstraint<Selection> & SelectSelectionNonEmptyConstraint<Selection> & SelectionProjectionAliasCollisionConstraint<Selection>
   ) => QueryPlan<
     Selection,
     ExtractRequired<Selection>,
@@ -5169,7 +5760,7 @@ type AsCurriedResult<
     getQueryState,
     currentRequiredList,
     dedupeGroupedExpressions
-  }) as {
+  }) as unknown as {
     readonly values: ValuesApi
     readonly unnest: UnnestApi
     readonly generateSeries: GenerateSeriesApi
@@ -5191,7 +5782,10 @@ type AsCurriedResult<
     never,
     TrueFormula,
     CapabilitiesOfPlan<LeftPlanValue> | CapabilitiesOfPlan<RightPlanValue>,
-    "set"
+    "set",
+    any,
+    "ready",
+    CommonSetFacts<LeftPlanValue, RightPlanValue>
   >
 
   type SetOperationApi = <
@@ -5259,10 +5853,10 @@ type AsCurriedResult<
         keyof AvailableOfPlan<PlanValue> extends never ? never : unknown
       ) & (
         SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
-      )
+      ) & SourceRequirementConstraint<PlanValue, CurrentTable> & SourceDialectConstraint<CurrentTable, Dialect>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
-      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross">,
+      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross", SourceRequiredOf<CurrentTable>>,
       AddAvailable<
         AvailableOfPlan<PlanValue>,
         SourceNameOf<CurrentTable>,
@@ -5273,10 +5867,13 @@ type AsCurriedResult<
       PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
-      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross">,
+      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross", SourceRequiredOf<CurrentTable>>,
       AssumptionsOfPlan<PlanValue>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
-      StatementOfPlan<PlanValue>
+      StatementOfPlan<PlanValue>,
+      MutationTargetOfPlan<PlanValue>,
+      InsertSourceStateOfPlan<PlanValue>,
+      FactsOfPlan<PlanValue>
     >
 
   type JoinApi = <
@@ -5293,10 +5890,10 @@ type AsCurriedResult<
         keyof AvailableOfPlan<PlanValue> extends never ? never : unknown
       ) & (
         SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
-      )
+      ) & SourceRequirementConstraint<PlanValue, CurrentTable> & SourceDialectConstraint<CurrentTable, Dialect>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
-      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind, SourceRequiredOf<CurrentTable>>,
       AvailableAfterJoin<
         AvailableOfPlan<PlanValue>,
         SourceNameOf<CurrentTable>,
@@ -5307,7 +5904,7 @@ type AsCurriedResult<
       PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
-      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind, SourceRequiredOf<CurrentTable>>,
       PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
       StatementOfPlan<PlanValue>,
@@ -5328,10 +5925,10 @@ type AsCurriedResult<
         keyof AvailableOfPlan<PlanValue> extends never ? never : unknown
       ) & (
         SourceNameOf<CurrentTable> extends ScopedNamesOfPlan<PlanValue> ? never : unknown
-      )
+      ) & SourceRequirementConstraint<PlanValue, CurrentTable> & SourceDialectConstraint<CurrentTable, Dialect>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
-      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind, SourceRequiredOf<CurrentTable>>,
       AvailableAfterJoin<
         AvailableOfPlan<PlanValue>,
         SourceNameOf<CurrentTable>,
@@ -5342,7 +5939,7 @@ type AsCurriedResult<
       PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
-      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
+      AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind, SourceRequiredOf<CurrentTable>>,
       PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
       StatementOfPlan<PlanValue>,
@@ -5351,6 +5948,8 @@ type AsCurriedResult<
       PlanFactsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     >
 
+  type FullJoinApi = Dialect extends "postgres" ? BinaryJoinApi<"full"> : FullJoinUnsupportedError<Dialect>
+
   type OrderByApi = <Value extends ExpressionInput>(
     value: Value,
     direction?: OrderDirection
@@ -5548,7 +6147,7 @@ type AsCurriedResult<
 
   const rightJoin = ((table, on) => (join as any)("right", table, on)) as BinaryJoinApi<"right">
 
-  const fullJoin = ((table, on) => (join as any)("full", table, on)) as BinaryJoinApi<"full">
+  const fullJoin = ((table: any, on: any) => (join as any)("full", table, on)) as unknown as FullJoinApi
 
   const distinctOn = {
     __effect_qb_error__: "effect-qb: distinctOn(...) is only supported by the postgres dialect",
@@ -5577,26 +6176,39 @@ type AsCurriedResult<
       FactsOfPlan<PlanValue>
     >
 
-  type ReturningApi = <Selection extends SelectionShape>(
-    selection: Selection
-  ) =>
-    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & RequireMutationStatement<PlanValue>
-    ) => QueryPlan<
-      Selection,
-      Exclude<RequiredOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-      AvailableOfPlan<PlanValue>,
-      PlanDialectOf<PlanValue> | ExtractDialect<Selection>,
-      GroupedOfPlan<PlanValue>,
-      ScopedNamesOfPlan<PlanValue>,
-      Exclude<OutstandingOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-      AssumptionsOfPlan<PlanValue>,
-      CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>,
-      MutationTargetOfPlan<PlanValue>,
-      InsertSourceStateOfPlan<PlanValue>,
-      FactsOfPlan<PlanValue>
-    >
+  type ReturningSelectionNonEmptyError<Selection> = Selection & {
+    readonly __effect_qb_error__: "effect-qb: returning(...) requires at least one selected expression"
+  }
+
+  type ReturningSelectionNonEmptyConstraint<Selection> =
+    Selection extends Expression.Any
+      ? unknown
+      : [Extract<keyof Selection, string>] extends [never]
+        ? ReturningSelectionNonEmptyError<Selection>
+        : unknown
+
+  type ReturningApi = Dialect extends "postgres"
+    ? <const Selection extends SelectionShape>(
+        selection: Selection & SelectionRootObjectConstraint<Selection> & SelectionNestedNonEmptyConstraint<Selection> & ReturningSelectionNonEmptyConstraint<Selection> & SelectionProjectionAliasCollisionConstraint<Selection>
+      ) =>
+        <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+          plan: PlanValue & RequireMutationStatement<PlanValue>
+        ) => QueryPlan<
+          Selection,
+          Exclude<RequiredOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+          AvailableOfPlan<PlanValue>,
+          PlanDialectOf<PlanValue> | ExtractDialect<Selection>,
+          GroupedOfPlan<PlanValue>,
+          ScopedNamesOfPlan<PlanValue>,
+          Exclude<OutstandingOfPlan<PlanValue> | ExtractRequired<Selection>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+          AssumptionsOfPlan<PlanValue>,
+          CapabilitiesOfPlan<PlanValue>,
+          StatementOfPlan<PlanValue>,
+          MutationTargetOfPlan<PlanValue>,
+          InsertSourceStateOfPlan<PlanValue>,
+          FactsOfPlan<PlanValue>
+        >
+    : ReturningUnsupportedError<Dialect>
 
   export interface InsertApi {
     <Target extends MutationTargetLike>(
@@ -5618,12 +6230,12 @@ type AsCurriedResult<
     >
     <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
       target: Target,
-      values: MutationValuesInput<"insert", Target, Values>
+      values: MutationValuesInput<"insert", Target, Values> & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     ): QueryPlan<
       {},
       Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
       AddAvailable<{}, SourceNameOf<Target>>,
-      TableDialectOf<Target>,
+      TableDialectOf<Target> | KnownMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       never,
       SourceNameOf<Target>,
       Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
@@ -5645,21 +6257,22 @@ type AsCurriedResult<
     Target extends MutationTargetLike,
     const Columns extends DdlColumnInput,
     UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = MutationInputOf<Table.UpdateOf<Target>> | undefined,
-    Options extends ConflictActionInput<Target, Dialect, UpdateValues> = ConflictActionInput<Target, Dialect, UpdateValues>
+    Options extends ConflictActionInput<Target, Dialect, UpdateValues> = ConflictActionInput<Target, Dialect, UpdateValues>,
+    const ConflictTarget extends ConflictTargetInput<Target, Dialect, Columns> = ConflictTargetInput<Target, Dialect, Columns>
   >(
-    target: ConflictTargetInput<Target, Dialect, Columns>,
-    options?: Options
+    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>
     ) => QueryPlan<
       SelectionOfPlan<PlanValue>,
-      Exclude<RequiredOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+      Exclude<RequiredOfPlan<PlanValue> | ConflictRequired<UpdateValues, Options, ConflictTarget>, AvailableNames<AvailableOfPlan<PlanValue>>>,
       AvailableOfPlan<PlanValue>,
-      PlanDialectOf<PlanValue>,
+      PlanDialectOf<PlanValue> | ConflictDialect<UpdateValues, Options, ConflictTarget, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue>,
-      Exclude<OutstandingOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
+      Exclude<OutstandingOfPlan<PlanValue> | ConflictRequired<UpdateValues, Options, ConflictTarget>, AvailableNames<AvailableOfPlan<PlanValue>>>,
       AssumptionsOfPlan<PlanValue>,
       CapabilitiesOfPlan<PlanValue>,
       StatementOfPlan<PlanValue>,
@@ -5670,13 +6283,13 @@ type AsCurriedResult<
 
   interface UpdateApi {
     <Targets extends MutationTargetTuple, Values extends UpdateInputOfTarget<Targets>>(
-      target: Dialect extends "mysql" ? Targets : never,
-      values: Values
+      target: Dialect extends "mysql" ? Targets & MutationTargetTupleDialectConstraint<Targets, Dialect> & MutationTargetTupleUniqueNamesConstraint<Targets> : never,
+      values: Values & NestedUpdateValuesNonEmptyConstraint<Values> & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     ): QueryPlan<
       {},
       Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
       AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
-      TableDialectOf<Targets[0]>,
+      TableDialectOf<Targets[0]> | KnownMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       never,
       MutationTargetNamesOf<Targets>,
       Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
@@ -5689,12 +6302,12 @@ type AsCurriedResult<
     >
     <Target extends MutationTargetLike, Values extends Record<string, unknown>>(
       target: Target,
-      values: MutationValuesInput<"update", Target, Values>
+      values: MutationValuesInput<"update", Target, Values> & UpdateValuesNonEmptyConstraint<Values> & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
     ): QueryPlan<
       {},
       Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
       AddAvailable<{}, SourceNameOf<Target>>,
-      TableDialectOf<Target>,
+      TableDialectOf<Target> | KnownMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       never,
       SourceNameOf<Target>,
       Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
@@ -5711,20 +6324,22 @@ type AsCurriedResult<
     Target extends MutationTargetLike,
     Values extends MutationInputOf<Table.InsertOf<Target>>,
     const Columns extends DdlColumnInput,
-    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>>
+    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = undefined
   >(
     target: Target,
-    values: Values,
-    conflictColumns: ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>>,
-    updateValues?: UpdateValues
+    values: Values & MutationValuesDialectConstraint<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    conflictColumns: ValidateTargetColumnInput<Target, Columns>,
+    updateValues?: UpdateValues & UpdateValuesNonEmptyConstraint<Exclude<UpdateValues, undefined>> & MutationValuesDialectConstraint<Exclude<UpdateValues, undefined>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
   ) => QueryPlan<
     {},
-    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
+    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>>, SourceNameOf<Target>>,
     AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
+    | TableDialectOf<Target>
+    | KnownMutationDialectFromValues<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    | KnownMutationDialectFromValues<Exclude<UpdateValues, undefined>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     never,
     SourceNameOf<Target>,
-    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
+    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>>, SourceNameOf<Target>>,
     TrueFormula,
     "write",
     "insert",
@@ -5752,7 +6367,7 @@ type AsCurriedResult<
       EmptyFacts
     >
     <Targets extends MutationTargetTuple>(
-      target: Dialect extends "mysql" ? Targets : never
+      target: Dialect extends "mysql" ? Targets & MutationTargetTupleDialectConstraint<Targets, Dialect> & MutationTargetTupleUniqueNamesConstraint<Targets> : never
     ): QueryPlan<
       {},
       never,
@@ -5789,7 +6404,13 @@ type AsCurriedResult<
     EmptyFacts
   >
 
-  type MergeApi = <
+  type MergeUnsupportedError<Dialect extends string> = {
+    readonly __effect_qb_error__: "effect-qb: merge(...) is only supported by the postgres dialect"
+    readonly __effect_qb_dialect__: Dialect
+    readonly __effect_qb_hint__: "Use postgres.Query.merge(...) or dialect-specific insert/update/delete logic"
+  }
+
+  type MergeSupportedApi = <
     Target extends MutationTargetLike,
     Source extends SourceLike,
     On extends PredicateInput,
@@ -5801,9 +6422,9 @@ type AsCurriedResult<
     target: Target,
     source: Source & (
       SourceRequiredOf<Source> extends never ? unknown : SourceRequirementError<Source>
-    ),
+    ) & SourceDialectConstraint<Source, Dialect>,
     on: On,
-    options?: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate>
+    options: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate>
   ) => QueryPlan<
     {},
     Exclude<
@@ -5846,7 +6467,10 @@ type AsCurriedResult<
     EmptyFacts
   >
 
+  type MergeApi = Dialect extends "postgres" ? MergeSupportedApi : MergeUnsupportedError<Dialect>
+
   const mutationRuntime = makeDslMutationRuntime({
+    profile,
     makePlan,
     getAst,
     getQueryState,
@@ -5859,7 +6483,7 @@ type AsCurriedResult<
     buildConflictTarget,
     mutationTargetClauses,
     mutationAvailableSources,
-    normalizeColumnList,
+    normalizeConflictColumns,
     targetSourceDetails,
     sourceDetails
   })
@@ -5875,63 +6499,21 @@ type AsCurriedResult<
   ): QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "ready"> =>
     mutationRuntime.attachInsertSource(plan, source)
 
-  const onConflict: OnConflictApi = <
-    Target extends MutationTargetLike,
-    const Columns extends DdlColumnInput,
-    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = MutationInputOf<Table.UpdateOf<Target>> | undefined,
-    Options extends ConflictActionInput<Target, Dialect, UpdateValues> = ConflictActionInput<Target, Dialect, UpdateValues>
-  >(
-    target: ConflictTargetInput<Target, Dialect, Columns>,
-    options: Options = {} as Options
-  ) =>
-    <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-      plan: PlanValue & RequireInsertStatement<PlanValue>
-    ): QueryPlan<
-      SelectionOfPlan<PlanValue>,
-      Exclude<RequiredOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-      AvailableOfPlan<PlanValue>,
-      PlanDialectOf<PlanValue>,
-      GroupedOfPlan<PlanValue>,
-      ScopedNamesOfPlan<PlanValue>,
-      Exclude<OutstandingOfPlan<PlanValue> | MutationRequiredFromValues<Exclude<UpdateValues, undefined>> | RequiredFromInput<Extract<Options["where"], PredicateInput>>, AvailableNames<AvailableOfPlan<PlanValue>>>,
-      AssumptionsOfPlan<PlanValue>,
-      CapabilitiesOfPlan<PlanValue>,
-      StatementOfPlan<PlanValue>,
-      MutationTargetOfPlan<PlanValue>,
-      InsertSourceStateOfPlan<PlanValue>,
-      FactsOfPlan<PlanValue>
-    > => mutationRuntime.onConflict(target, options)(plan)
+  const onConflict = ((target: unknown, options: unknown = {}) =>
+    (plan: QueryPlan<any, any, any, any, any, any, any, any, any, any>) =>
+      mutationRuntime.onConflict(target, options)(plan)) as OnConflictApi
 
   const update: UpdateApi = ((
     target: MutationTargetInput,
     values: Record<string, unknown>
   ) => mutationRuntime.update(target, values)) as UpdateApi
 
-  const upsert: UpsertApi = <
-    Target extends MutationTargetLike,
-    Values extends MutationInputOf<Table.InsertOf<Target>>,
-    const Columns extends DdlColumnInput,
-    UpdateValues extends MutationInputOf<Table.UpdateOf<Target>>
-  >(
-    target: Target,
-    values: Values,
-    conflictColumns: ValidateTargetColumns<Target, NormalizeDdlColumns<Columns>>,
-    updateValues?: UpdateValues
-  ): QueryPlan<
-    {},
-    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
-    never,
-    SourceNameOf<Target>,
-    Exclude<MutationRequiredFromValues<Values> | MutationRequiredFromValues<UpdateValues>, SourceNameOf<Target>>,
-    TrueFormula,
-    "write",
-    "insert",
-    Target,
-    "ready",
-    EmptyFacts
-  > => mutationRuntime.upsert(target, values, conflictColumns as string | readonly string[], updateValues)
+  const upsert = ((
+    target: MutationTargetLike,
+    values: Record<string, unknown>,
+    conflictColumns: DdlColumnInput,
+    updateValues?: Record<string, unknown>
+  ) => mutationRuntime.upsert(target, values, conflictColumns as string | readonly string[], updateValues)) as UpsertApi
 
   const delete_: DeleteApi = ((
     target: MutationTargetInput
@@ -5958,7 +6540,7 @@ type AsCurriedResult<
     EmptyFacts
   > => mutationRuntime.truncate(target, options)
 
-  const merge: MergeApi = <
+  const merge = (<
     Target extends MutationTargetLike,
     Source extends SourceLike,
     On extends PredicateInput,
@@ -5972,7 +6554,7 @@ type AsCurriedResult<
       SourceRequiredOf<Source> extends never ? unknown : SourceRequirementError<Source>
     ),
     on: On,
-    options: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate> = {}
+    options: MergeOptions<Target, MatchedValues, InsertValues, MatchedPredicate, NotMatchedPredicate>
   ): QueryPlan<
     {},
     Exclude<
@@ -6013,7 +6595,7 @@ type AsCurriedResult<
     any,
     "ready",
     EmptyFacts
-  > => mutationRuntime.merge(target, source, on, options)
+  > => mutationRuntime.merge(target, source, on, options)) as unknown as MergeApi
 
   type TransactionApi = (options?: TransactionOptions) => QueryPlan<
     {},
@@ -6054,7 +6636,7 @@ type AsCurriedResult<
     "rollback"
   >
 
-  type SavepointApi = <Name extends string>(name: Name) => QueryPlan<
+  type SavepointApi = <Name extends string>(name: NonEmptyStringInput<Name>) => QueryPlan<
     {},
     never,
     {},
@@ -6067,7 +6649,7 @@ type AsCurriedResult<
     "savepoint"
   >
 
-  type RollbackToApi = <Name extends string>(name: Name) => QueryPlan<
+  type RollbackToApi = <Name extends string>(name: NonEmptyStringInput<Name>) => QueryPlan<
     {},
     never,
     {},
@@ -6080,7 +6662,7 @@ type AsCurriedResult<
     "rollbackTo"
   >
 
-  type ReleaseSavepointApi = <Name extends string>(name: Name) => QueryPlan<
+  type ReleaseSavepointApi = <Name extends string>(name: NonEmptyStringInput<Name>) => QueryPlan<
     {},
     never,
     {},
@@ -6125,10 +6707,10 @@ type AsCurriedResult<
     "dropTable"
   >
 
-  type CreateIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput>(
+  type CreateIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput, Name extends string = string>(
     target: Target,
-    columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
-    options?: CreateIndexOptions
+    columns: Columns & ValidateDdlColumnInput<Target, Columns>,
+    options?: CreateIndexOptions<Name>
   ) => QueryPlan<
     {},
     never,
@@ -6142,10 +6724,10 @@ type AsCurriedResult<
     "createIndex"
   >
 
-  type DropIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput>(
+  type DropIndexApi = <Target extends SchemaTableLike, const Columns extends DdlColumnInput, Name extends string = string>(
     target: Target,
-    columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
-    options?: DropIndexOptions
+    columns: Columns & ValidateDdlColumnInput<Target, Columns>,
+    options?: DropIndexOptions<Name>
   ) => QueryPlan<
     {},
     never,