npm - effect-qb - Versions diffs - 0.17.0 → 0.20.0 - Mend

effect-qb 0.17.0 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (137) hide show

package/README.md +11 -1
package/dist/index.js +9376 -0
package/dist/mysql.js +4092 -2671
package/dist/postgres/metadata.js +2589 -1402
package/dist/postgres.js +3953 -3583
package/dist/sqlite.js +5527 -4088
package/dist/standard.js +9330 -0
package/package.json +9 -4
package/src/casing.ts +71 -0
package/src/index.ts +2 -0
package/src/internal/casing.ts +89 -0
package/src/internal/coercion/rules.ts +13 -1
package/src/internal/column-state.d.ts +3 -3
package/src/internal/column-state.ts +24 -18
package/src/internal/column.ts +52 -15
package/src/internal/datatypes/define.ts +7 -1
package/src/internal/datatypes/enrich.ts +23 -0
package/src/internal/datatypes/lookup.ts +81 -25
package/src/internal/datatypes/matrix.ts +903 -0
package/src/internal/datatypes/shape.ts +2 -0
package/src/internal/derived-table.ts +4 -36
package/src/{mysql/internal/sql-expression-renderer.ts → internal/dialect-renderers/mysql.ts} +552 -361
package/src/{postgres/internal/sql-expression-renderer.ts → internal/dialect-renderers/postgres.ts} +657 -400
package/src/{sqlite/internal/sql-expression-renderer.ts → internal/dialect-renderers/sqlite.ts} +505 -347
package/src/internal/dialect.ts +36 -1
package/src/internal/dsl-mutation-runtime.ts +12 -162
package/src/internal/dsl-plan-runtime.ts +10 -138
package/src/internal/dsl-query-runtime.ts +5 -79
package/src/internal/dsl-transaction-ddl-runtime.ts +41 -65
package/src/internal/executor.ts +66 -49
package/src/internal/grouping-key.ts +87 -20
package/src/internal/implication-runtime.ts +1 -1
package/src/internal/json/path-access.ts +351 -0
package/src/internal/predicate/runtime.ts +3 -0
package/src/internal/query.d.ts +39 -12
package/src/internal/query.ts +65 -26
package/src/internal/renderer.ts +26 -14
package/src/internal/runtime/driver-value-mapping.ts +3 -3
package/src/internal/runtime/normalize.ts +12 -5
package/src/internal/runtime/schema.ts +28 -38
package/src/internal/runtime/value.ts +20 -23
package/src/internal/scalar.d.ts +1 -1
package/src/internal/scalar.ts +8 -2
package/src/internal/schema-derivation.d.ts +12 -61
package/src/internal/schema-derivation.ts +95 -43
package/src/internal/schema-expression.ts +2 -2
package/src/internal/sql-expression-renderer.ts +19 -0
package/src/internal/standard-dsl.ts +6978 -0
package/src/internal/table-options.ts +126 -66
package/src/internal/table.ts +819 -237
package/src/mysql/column-extension.ts +3 -0
package/src/mysql/column.ts +14 -15
package/src/mysql/datatypes/index.ts +4 -2
package/src/mysql/datatypes/spec.ts +6 -176
package/src/mysql/errors/normalize.ts +0 -1
package/src/mysql/executor.ts +11 -11
package/src/mysql/function/temporal.ts +1 -1
package/src/mysql/internal/dialect.ts +9 -4
package/src/mysql/internal/dsl.ts +334 -170
package/src/mysql/internal/renderer.ts +6 -2
package/src/mysql/json.ts +7 -2
package/src/mysql/query-extension.ts +16 -0
package/src/mysql/renderer.ts +37 -3
package/src/mysql/type.ts +60 -0
package/src/mysql.ts +7 -13
package/src/postgres/check.ts +1 -0
package/src/postgres/column-extension.ts +28 -0
package/src/postgres/column.ts +13 -19
package/src/postgres/datatypes/index.d.ts +2 -1
package/src/postgres/datatypes/index.ts +4 -2
package/src/postgres/datatypes/spec.ts +6 -260
package/src/postgres/errors/normalize.ts +0 -1
package/src/postgres/executor.ts +11 -11
package/src/postgres/foreign-key.ts +24 -0
package/src/postgres/function/core.ts +1 -3
package/src/postgres/function/index.ts +1 -17
package/src/postgres/function/temporal.ts +1 -1
package/src/postgres/index.ts +1 -0
package/src/postgres/internal/dialect.ts +9 -4
package/src/postgres/internal/dsl.ts +328 -179
package/src/postgres/internal/renderer.ts +6 -2
package/src/postgres/internal/schema-ddl.ts +22 -10
package/src/postgres/internal/schema-model.ts +238 -7
package/src/postgres/json-extension.ts +7 -0
package/src/postgres/json.ts +762 -173
package/src/postgres/jsonb.ts +37 -0
package/src/postgres/primary-key.ts +24 -0
package/src/postgres/query-extension.ts +2 -0
package/src/postgres/renderer.ts +37 -3
package/src/postgres/schema-management.ts +13 -13
package/src/postgres/schema.ts +106 -15
package/src/postgres/table.ts +205 -538
package/src/postgres/type.ts +93 -10
package/src/postgres/unique.ts +32 -0
package/src/postgres.ts +20 -16
package/src/sqlite/column-extension.ts +3 -0
package/src/sqlite/column.ts +14 -15
package/src/sqlite/datatypes/index.ts +4 -2
package/src/sqlite/datatypes/spec.ts +6 -94
package/src/sqlite/errors/normalize.ts +0 -1
package/src/sqlite/executor.ts +11 -11
package/src/sqlite/function/temporal.ts +1 -1
package/src/sqlite/internal/dialect.ts +9 -4
package/src/sqlite/internal/dsl.ts +307 -159
package/src/sqlite/internal/renderer.ts +6 -2
package/src/sqlite/json.ts +8 -2
package/src/sqlite/query-extension.ts +2 -0
package/src/sqlite/renderer.ts +37 -3
package/src/sqlite/type.ts +40 -0
package/src/sqlite.ts +7 -13
package/src/standard/cast.ts +113 -0
package/src/standard/check.ts +17 -0
package/src/standard/column.ts +163 -0
package/src/standard/datatypes/index.ts +83 -0
package/src/standard/datatypes/spec.ts +12 -0
package/src/standard/dialect.ts +40 -0
package/src/standard/foreign-key.ts +37 -0
package/src/standard/function/aggregate.ts +2 -0
package/src/standard/function/core.ts +2 -0
package/src/standard/function/index.ts +18 -0
package/src/standard/function/string.ts +2 -0
package/src/standard/function/temporal.ts +78 -0
package/src/standard/function/window.ts +2 -0
package/src/standard/index.ts +17 -0
package/src/standard/internal/renderer.ts +45 -0
package/src/standard/json.ts +883 -0
package/src/standard/primary-key.ts +17 -0
package/src/standard/query.ts +152 -0
package/src/standard/renderer.ts +49 -0
package/src/standard/table.ts +151 -0
package/src/standard/unique.ts +17 -0
package/src/standard.ts +32 -0
package/src/internal/aggregation-validation.ts +0 -57
package/src/internal/table.d.ts +0 -173
package/src/mysql/table.ts +0 -183
package/src/postgres/cast.ts +0 -45
package/src/sqlite/table.ts +0 -183

package/src/internal/table.ts CHANGED Viewed

@@ -5,16 +5,15 @@ import * as Plan from "./row-set.js"
 import type { Any as AnyExpression } from "./scalar.js"
 import type { TrueFormula } from "./predicate/formula.js"
 import type { BoundColumnFrom } from "./column-state.js"
-import { bindColumn, type AnyColumnDefinition } from "./column-state.js"
+import { bindColumn, BoundColumnTypeId, type AnyBoundColumn, type AnyColumnDefinition } from "./column-state.js"
 import {
   collectInlineOptions,
-  normalizeColumnList,
   resolvePrimaryKeyColumns,
+  type ColumnList,
   type DdlExpressionLike,
   type IndexKeySpec,
-  type MatchingColumnArityInput,
-  type NonEmptyColumnInput,
-  type NormalizeColumns,
+  type LiteralStringInput,
+  type NonEmptyStringInput,
   type ReferentialAction,
   type TableOptionSpec,
   type ValidateForeignKeyOptionColumns,
@@ -24,12 +23,16 @@ import {
   validateOptions
 } from "./table-options.js"
 import {
-  deriveSchemas,
+  deriveInsertSchema,
+  deriveSelectSchema,
+  deriveUpdateSchema,
   type InsertRow,
   type SelectRow,
   type TableFieldMap,
+  type TableSchemaVariant,
   type UpdateRow
 } from "./schema-derivation.js"
+import * as Casing from "./casing.js"
 /** Symbol used to attach table-definition metadata. */
 export const TypeId: unique symbol = Symbol.for("effect-qb/Table")
@@ -39,17 +42,62 @@ export const OptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/normaliz
 export const options: unique symbol = Symbol.for("effect-qb/Table/declaredOptions")
 const CacheSymbol: unique symbol = Symbol.for("effect-qb/Table/cache")
+const SchemaCacheSymbol: unique symbol = Symbol.for("effect-qb/Table/schemaCache")
 const DeclaredOptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions")
+const ResolveOptionSymbol: unique symbol = Symbol.for("effect-qb/Table/resolveOption")
 type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
   [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
 }[keyof Fields], string>
-type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"]
+type FieldDialects<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"]
+type ConcreteFieldDialects<Fields extends TableFieldMap> = Exclude<FieldDialects<Fields>, "standard">
+type TableDialect<Fields extends TableFieldMap> = [ConcreteFieldDialects<Fields>] extends [never]
+  ? "standard"
+  : ConcreteFieldDialects<Fields>
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
+type NonEmptyFieldMap<Fields extends TableFieldMap> =
+  string extends keyof Fields ? Fields : "" extends keyof Fields ? never : Fields
 type FieldColumnName<Fields extends TableFieldMap> = Extract<keyof Fields, string>
 type FieldColumnList<Fields extends TableFieldMap> = readonly [FieldColumnName<Fields>, ...FieldColumnName<Fields>[]]
+export type SchemaTableDefinition = TableDefinition<any, any, any, "schema", any, any>
+type LooseTableSelection = any
+type ConcreteSelector<
+  Table extends SchemaTableDefinition,
+  Selection extends AnyColumnSelection
+> = SchemaTableDefinition extends Table ? never : (table: Table) => Selection
+type ColumnNameOfBound<Column> = Column extends {
+  readonly [BoundColumnTypeId]: {
+    readonly columnName: infer ColumnName extends string
+  }
+} ? ColumnName : never
+type BoundColumnTupleNames<Columns extends readonly AnyBoundColumn[]> =
+  Columns extends readonly [infer Head extends AnyBoundColumn, ...infer Tail extends AnyBoundColumn[]]
+    ? readonly [ColumnNameOfBound<Head>, ...BoundColumnTupleNames<Tail>]
+    : readonly []
+type ColumnSelectionNames<Selection> =
+  Selection extends AnyBoundColumn
+    ? readonly [ColumnNameOfBound<Selection>]
+    : Selection extends readonly [infer Head extends AnyBoundColumn, ...infer Tail extends AnyBoundColumn[]]
+      ? readonly [ColumnNameOfBound<Head>, ...BoundColumnTupleNames<Tail>]
+      : never
+export type TableColumnSelection<Table extends SchemaTableDefinition> =
+  TableColumn<Table> | readonly [TableColumn<Table>, ...TableColumn<Table>[]]
+export type TableColumn<Table extends SchemaTableDefinition> =
+  SchemaTableDefinition extends Table ? AnyBoundColumn : Table extends TableDefinition<infer Name, infer Fields, any, "schema", any>
+    ? BoundColumns<Name, Fields>[Extract<keyof Fields, string>]
+    : never
+export type AnyColumnSelection = AnyBoundColumn | readonly [AnyBoundColumn, ...AnyBoundColumn[]]
+export type SelectedColumns<Selection extends AnyColumnSelection> = ColumnSelectionNames<Selection>
+type MatchingSelectionArityInput<
+  Left extends AnyColumnSelection,
+  Right extends AnyColumnSelection
+> = SelectedColumns<Left>["length"] extends SelectedColumns<Right>["length"]
+  ? SelectedColumns<Right>["length"] extends SelectedColumns<Left>["length"]
+    ? unknown
+    : never
+  : never
 type FieldIndexKeySpec<Fields extends TableFieldMap> =
   | (Extract<IndexKeySpec, { readonly kind: "column" }> & { readonly column: FieldColumnName<Fields> })
   | Extract<IndexKeySpec, { readonly kind: "expression" }>
@@ -67,53 +115,162 @@ type ClassOptionSpec<Fields extends TableFieldMap = TableFieldMap> =
     })
   | Extract<TableOptionSpec, { readonly kind: "check" }>
 interface TableOptionBuilderLike<
-  Spec extends TableOptionSpec = TableOptionSpec
+  Spec extends TableOptionSpec = TableOptionSpec,
+  TableContext extends SchemaTableDefinition = SchemaTableDefinition
 > {
   readonly option: Spec
 }
-type ClassTableOption<Fields extends TableFieldMap> = TableOptionBuilderLike<ClassOptionSpec<Fields>>
+type ClassTableOption<Fields extends TableFieldMap> = TableOption<
+  ClassOptionSpec<Fields>,
+  TableDefinition<string, Fields, keyof Fields & string, "schema", any>
+>
 type ClassDeclaredTableOptions<Fields extends TableFieldMap> = readonly ClassTableOption<Fields>[]
+type TableNameOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<infer Name, any, any, "schema", any> ? Name : never
+type TableFieldsOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, infer Fields, any, "schema", any> ? Fields : never
+type TablePrimaryKeyOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, any, infer PrimaryKeyColumns, "schema", any> ? PrimaryKeyColumns : never
+type TableSchemaNameOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, any, any, "schema", infer SchemaName> ? SchemaName : never
+type HasBroadColumns<Columns extends readonly string[]> = string extends Columns[number] ? true : false
+export type ConflictArbiterScope = "unconditional" | "partial"
+export type ConflictArbiter<
+  Columns extends ColumnList = ColumnList,
+  Scope extends ConflictArbiterScope = ConflictArbiterScope,
+  Name extends string | undefined = string | undefined,
+  Constraint extends boolean = boolean
+> = {
+  readonly columns: Columns
+  readonly scope: Scope
+  readonly name?: Name
+  readonly constraint: Constraint
+}
+type InlineConflictArbiters<Fields extends TableFieldMap> = Extract<{
+  [K in keyof Fields]: Fields[K] extends AnyColumnDefinition
+    ? Fields[K]["metadata"]["primaryKey"] extends true
+      ? ConflictArbiter<readonly [Extract<K, string>], "unconditional", undefined, true>
+      : Fields[K]["metadata"]["unique"] extends true
+        ? ConflictArbiter<
+          readonly [Extract<K, string>],
+          "unconditional",
+          Fields[K]["metadata"]["uniqueConstraint"] extends { readonly name?: infer Name extends string } ? Name : undefined,
+          true
+        >
+        : never
+    : never
+}[keyof Fields], ConflictArbiter>
+type TableConflictArbitersOf<Table extends TableDefinition<any, any, any, any, any, any>> =
+  Table extends TableDefinition<any, any, any, any, any, infer ConflictArbiters> ? ConflictArbiters : never
+type NormalizeArbiterColumns<Columns> =
+  Columns extends readonly [infer Head extends string, ...infer Tail extends string[]]
+    ? readonly [Head, ...Tail]
+    : Columns extends string
+      ? readonly [Columns]
+      : never
+type OptionColumns<Spec extends TableOptionSpec> =
+  Spec extends { readonly columns?: infer Columns } ? NormalizeArbiterColumns<Columns> : never
+type OptionName<Spec extends TableOptionSpec> =
+  Spec extends { readonly name: infer Name extends string } ? Name : undefined
+type ConflictArbiterFromOption<Spec extends TableOptionSpec> =
+  OptionColumns<Spec> extends infer Columns extends ColumnList
+    ? HasBroadColumns<Columns> extends true
+      ? never
+      : Spec extends { readonly kind: "primaryKey" | "unique" }
+        ? ConflictArbiter<Columns, "unconditional", OptionName<Spec>, true>
+        : Spec extends { readonly kind: "index"; readonly unique: true }
+          ? ConflictArbiter<Columns, Spec extends { readonly predicate: DdlExpressionLike } ? "partial" : "unconditional", OptionName<Spec>, false>
+          : never
+    : never
 type BuildPrimaryKey<
-  Table extends TableDefinition<any, any, any, "schema", any>,
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey"; readonly columns: infer Columns extends readonly string[] }
-  ? Columns[number] & keyof Table[typeof TypeId]["fields"] & string
-  : Table[typeof TypeId]["primaryKey"][number]
+  ? HasBroadColumns<Columns> extends true
+    ? TablePrimaryKeyOf<Table>
+    : Columns[number] & keyof TableFieldsOf<Table> & string
+  : TablePrimaryKeyOf<Table>
-type OptionInputTable<
-  Table extends TableDefinition<any, any, any, "schema", any>,
+type OptionInputConstraint<
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey"; readonly columns: infer Columns extends readonly string[] }
-  ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
+  ? HasBroadColumns<Columns> extends true ? unknown : ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : unknown
   : Spec extends { readonly kind: "index" }
-    ? ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+    ? Spec extends { readonly columns: infer Columns extends readonly string[] }
+      ? HasBroadColumns<Columns> extends true ? unknown : ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
+      : ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
     : Spec extends { readonly kind: "foreignKey" }
-      ? ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+      ? Spec extends { readonly columns: infer Columns extends readonly string[] }
+        ? HasBroadColumns<Columns> extends true ? unknown : ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
+        : ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
       : Spec extends { readonly columns: infer Columns extends readonly string[] }
-        ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
-        : Table
+        ? HasBroadColumns<Columns> extends true ? unknown : ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : unknown
+        : unknown
+type OptionInputTable<
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
+  Spec extends TableOptionSpec
+> = Table & OptionInputConstraint<Table, Spec>
+type OptionValidationArgs<
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
+  Spec extends TableOptionSpec
+> = OptionInputConstraint<Table, Spec> extends never ? [never] : []
 type ApplyOption<
-  Table extends TableDefinition<any, any, any, "schema", any>,
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey" }
   ? TableDefinition<
-    Table[typeof TypeId]["name"],
-    Table[typeof TypeId]["fields"],
+    TableNameOf<Table>,
+    TableFieldsOf<Table>,
     BuildPrimaryKey<Table, Spec>,
-    "schema"
+    "schema",
+    TableSchemaNameOf<Table>,
+    TableConflictArbitersOf<Table> | ConflictArbiterFromOption<Spec>
   >
   : TableDefinition<
-    Table[typeof TypeId]["name"],
-    Table[typeof TypeId]["fields"],
-    Table[typeof TypeId]["primaryKey"][number],
-    "schema"
+    TableNameOf<Table>,
+    TableFieldsOf<Table>,
+    TablePrimaryKeyOf<Table>,
+    "schema",
+    TableSchemaNameOf<Table>,
+    TableConflictArbitersOf<Table> | ConflictArbiterFromOption<Spec>
   >
+type ApplyTableOption<
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
+  Spec extends TableOptionSpec
+> = ApplyOption<Table, Spec>
+type TableOptionPipe<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  Kind extends TableKind,
+  SchemaName extends string | undefined,
+  ConflictArbiters extends ConflictArbiter
+> = Kind extends "schema"
+  ? {
+      pipe<Spec extends TableOptionSpec>(
+        option: TableOption<Spec, TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName, ConflictArbiters>>,
+        ...validation: OptionValidationArgs<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName, ConflictArbiters>, Spec>
+      ): ApplyTableOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName, ConflictArbiters>, Spec>
+    }
+  : {}
 export type ValidateDeclaredOptions<
-  Table extends TableDefinition<any, any, any, "schema", any>,
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
   Options extends DeclaredTableOptions
 > = {
   readonly [K in keyof Options]: Options[K] extends TableOptionBuilderLike<infer Spec>
@@ -122,7 +279,7 @@ export type ValidateDeclaredOptions<
 }
 export type ApplyDeclaredOptions<
-  Table extends TableDefinition<any, any, any, "schema", any>,
+  Table extends TableDefinition<any, any, any, "schema", any, any>,
   Options extends DeclaredTableOptions
 > = Options extends readonly [infer Head, ...infer Tail]
   ? Head extends TableOptionBuilderLike<infer Spec>
@@ -148,9 +305,23 @@ export interface TableSchemas<
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 > {
-  readonly select: Schema.Schema<SelectRow<Name, Fields>>
-  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
-  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
+  readonly select: Schema.ConstraintDecoder<SelectRow<Name, Fields>, never>
+  readonly insert: Schema.ConstraintDecoder<InsertRow<Name, Fields>, never>
+  readonly update: Schema.ConstraintDecoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+type AnyTableSchemas = {
+  readonly select: Schema.Schema<any>
+  readonly insert: Schema.Schema<any>
+  readonly update: Schema.Schema<any>
+}
+type TableSchemaCache<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+> = Partial<TableSchemas<Name, Fields, PrimaryKeyColumns>> & {
+  schemas?: TableSchemas<Name, Fields, PrimaryKeyColumns>
 }
 interface TableState<
@@ -158,45 +329,37 @@ interface TableState<
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string,
   Kind extends TableKind = "schema",
-  SchemaName extends string | undefined = DefaultSchemaName
+  SchemaName extends string | undefined = DefaultSchemaName,
+  ConflictArbiters extends ConflictArbiter = InlineConflictArbiters<Fields>
 > {
   readonly name: Name
   readonly baseName: string
   readonly schemaName: SchemaName
   readonly fields: Fields
   readonly primaryKey: readonly PrimaryKeyColumns[]
+  readonly conflictArbiters: readonly ConflictArbiters[]
   readonly kind: Kind
-}
-/** Namespace-scoped table builder. */
-export interface TableSchemaNamespace<SchemaName extends string> {
-  readonly schemaName: SchemaName
-  readonly table: <
-    Name extends string,
-    Fields extends TableFieldMap,
-    const Options extends DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ) => ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  readonly casing?: Casing.Options
 }
 export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
-export type { DdlExpressionLike, IndexKeySpec, MatchingColumnArityInput, NonEmptyColumnInput, NormalizeColumns, ReferentialAction } from "./table-options.js"
+export type { DdlExpressionLike, IndexKeySpec, LiteralStringInput, MatchingColumnArityInput, NonEmptyColumnInput, NonEmptyStringInput, NormalizeColumns, ReferentialAction } from "./table-options.js"
+export type { NonEmptyFieldMap }
+export type NonEmptySchemaNameInput<Value extends string | undefined> =
+  Value extends string ? NonEmptyStringInput<Value> : Value
 export type TableDefinition<
   Name extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
   Kind extends TableKind = "schema",
-  SchemaName extends string | undefined = DefaultSchemaName
-> = Pipeable & {
+  SchemaName extends string | undefined = DefaultSchemaName,
+  ConflictArbiters extends ConflictArbiter = InlineConflictArbiters<Fields>
+> = Pipeable & TableOptionPipe<Name, Fields, PrimaryKeyColumns, Kind, SchemaName, ConflictArbiters> & {
   readonly name: Name
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
-  readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns> & AnyTableSchemas
+  readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName, ConflictArbiters>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
@@ -222,11 +385,12 @@ export type TableClassStatic<
   Name extends string,
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
-  SchemaName extends string | undefined = DefaultSchemaName
+  SchemaName extends string | undefined = DefaultSchemaName,
+  ConflictArbiters extends ConflictArbiter = InlineConflictArbiters<Fields>
 > = (abstract new (...args: any[]) => any) & Pipeable & {
   readonly columns: BoundColumns<Name, Fields>
   readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
-  readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+  readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName, ConflictArbiters>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
     never,
@@ -245,32 +409,38 @@ export type TableClassStatic<
   >
 /** Minimal structural table-like contract used across helper APIs. */
-export type AnyTable = TableDefinition<any, any, any, any, any> | TableClassStatic<any, any, any, any>
-type FieldsOfAnyTable<Table extends AnyTable> = Table extends TableDefinition<any, infer Fields extends TableFieldMap, any, any, any>
-  ? Fields
-  : Table extends TableClassStatic<any, infer Fields extends TableFieldMap, any, any>
-    ? Fields
-    : never
+export type AnyTable<Dialect extends string = string> = {
+  readonly [TypeId]: TableState<string, TableFieldMap, string, TableKind, string | undefined, ConflictArbiter>
+  readonly [OptionsSymbol]: readonly TableOptionSpec[]
+} & Plan.RowSet<any, any, Record<string, Plan.AnySource>, Dialect>
-type ColumnNamesOfAnyTable<Table extends AnyTable> = Extract<keyof FieldsOfAnyTable<Table>, string>
+type CheckPredicateTable = any
+type CheckPredicate = (table: CheckPredicateTable) => DdlExpressionLike
 /** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
 export type TableOption<
-  Spec extends TableOptionSpec = TableOptionSpec
-> = {
-  <
-    Name extends string,
-    Fields extends TableFieldMap,
-    PrimaryKeyColumns extends keyof Fields & string
-  >(
-    table: OptionInputTable<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>
-  ): ApplyOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>
+  Spec extends TableOptionSpec = TableOptionSpec,
+  TableContext extends SchemaTableDefinition = SchemaTableDefinition
+> = Pipeable & {
+  readonly pipe: Pipeable["pipe"]
   readonly option: Spec
-}
+  readonly [ResolveOptionSymbol]?: (table: TableDefinition<any, any, any, "schema", any>) => Spec
+} & (Spec extends { readonly kind: "primaryKey" }
+  ? {
+  <Table extends TableContext>(
+    table: Table,
+    ...validation: OptionValidationArgs<Table, Spec>
+  ): ApplyOption<Table, Spec>
+  }
+  : {
+    <Table extends TableContext>(
+      table: Table,
+      ...validation: OptionValidationArgs<Table, Spec>
+    ): ApplyOption<Table, Spec>
+  })
 const TableProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -279,7 +449,7 @@ const attachPipe = <Value extends object>(value: Value): Value => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Value) {
       return pipeArguments(value, arguments)
     }
   })
@@ -292,11 +462,44 @@ type BuildArtifacts<
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
+  readonly conflictArbiters: readonly ConflictArbiter[]
 }
+const conflictArbitersFromOptions = (
+  options: readonly TableOptionSpec[]
+): readonly ConflictArbiter[] =>
+  options.flatMap((option): readonly ConflictArbiter[] => {
+    if (typeof option !== "object" || option === null) {
+      return []
+    }
+    if (!("columns" in option) || !Array.isArray(option.columns) || option.columns.length === 0) {
+      return []
+    }
+    switch (option.kind) {
+      case "primaryKey":
+      case "unique":
+        return [{
+          columns: option.columns as ColumnList,
+          scope: "unconditional",
+          name: option.name,
+          constraint: true
+        }]
+      case "index":
+        return option.unique === true
+          ? [{
+            columns: option.columns as ColumnList,
+            scope: option.predicate === undefined ? "unconditional" : "partial",
+            name: option.name,
+            constraint: false
+          }]
+          : []
+      default:
+        return []
+    }
+  })
 const buildArtifacts = <
   Name extends string,
   Fields extends TableFieldMap,
@@ -305,22 +508,159 @@ const buildArtifacts = <
   name: Name,
   fields: Fields,
   declaredOptions: readonly TableOptionSpec[],
-  schemaName: SchemaName
+  schemaName: SchemaName,
+  casing?: Casing.Options
 ): BuildArtifacts<Name, Fields, keyof Fields & string> => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions]
   validateFieldDialects(name, fields)
   validateOptions(name, fields, declaredOptions)
   const primaryKey = resolvePrimaryKeyColumns(fields, declaredOptions) as readonly (keyof Fields & string)[]
+  const conflictArbiters = conflictArbitersFromOptions(normalizedOptions)
   const columns = Object.fromEntries(
-    Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
+    Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName, casing)])
   ) as BoundColumns<Name, Fields>
-  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
-    schemas,
     normalizedOptions,
-    primaryKey
+    primaryKey,
+    conflictArbiters
+  }
+}
+const getSchemaCache = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemaCache<Name, Fields, PrimaryKeyColumns> => {
+  const target = table as {
+    [SchemaCacheSymbol]?: TableSchemaCache<Name, Fields, PrimaryKeyColumns>
+  }
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol]
+  }
+  const cache: TableSchemaCache<Name, Fields, PrimaryKeyColumns> = {}
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  })
+  return cache
+}
+const deriveTableSchema = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const state = table[TypeId]
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+}
+const schemaFor = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const cache = getSchemaCache(table)
+  const cached = cache[variant]
+  if (cached !== undefined) {
+    return cached as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+  const schema = deriveTableSchema(table, variant)
+  cache[variant] = schema as any
+  return schema
+}
+export function selectSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.ConstraintDecoder<SelectRow<Name, Fields>, never> {
+  return schemaFor(table, "select") as Schema.ConstraintDecoder<SelectRow<Name, Fields>, never>
+}
+export function insertSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.ConstraintDecoder<InsertRow<Name, Fields>, never> {
+  return schemaFor(table, "insert") as Schema.ConstraintDecoder<InsertRow<Name, Fields>, never>
+}
+export function updateSchema<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): Schema.ConstraintDecoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never> {
+  return schemaFor(table, "update") as Schema.ConstraintDecoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+const schemasFor = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemas<Name, Fields, PrimaryKeyColumns> => {
+  const cache = getSchemaCache(table)
+  if (cache.schemas !== undefined) {
+    return cache.schemas
   }
+  const schemas = {} as TableSchemas<Name, Fields, PrimaryKeyColumns>
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema(table)
+    }
+  })
+  cache.schemas = schemas
+  return schemas
+}
+const defineSchemasGetter = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any>
+): void => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table)
+    }
+  })
 }
 const makeTable = <
@@ -328,7 +668,8 @@ const makeTable = <
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string,
   Kind extends TableKind = "schema",
-  SchemaName extends string | undefined = DefaultSchemaName
+  SchemaName extends string | undefined = DefaultSchemaName,
+  ConflictArbiters extends ConflictArbiter = InlineConflictArbiters<Fields>
 >(
   name: Name,
   fields: Fields,
@@ -336,24 +677,27 @@ const makeTable = <
   baseName: string = name,
   kind: Kind = "schema" as Kind,
   schemaName?: SchemaName,
-  schemaMode: "default" | "explicit" = "default"
-): TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName> => {
+  schemaMode: "default" | "explicit" = "default",
+  casing?: Casing.Options
+): TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName, ConflictArbiters> => {
   const resolvedSchemaName = schemaMode === "explicit"
     ? schemaName
     : ("public" as SchemaName)
-  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName)
+  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName, casing)
   const dialect = resolveFieldDialect(fields)
   const table = attachPipe(Object.create(TableProto))
   table.name = name
   table.columns = artifacts.columns
-  table.schemas = artifacts.schemas
+  defineSchemasGetter(table)
   table[TypeId] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields,
     primaryKey: artifacts.primaryKey,
-    kind
+    conflictArbiters: artifacts.conflictArbiters as readonly ConflictArbiters[],
+    kind,
+    casing
   }
   table[Plan.TypeId] = {
     selection: artifacts.columns,
@@ -400,23 +744,17 @@ const applyDeclaredOptions = <
   ) as unknown as Table
 }
-const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void => {
-  for (const option of declaredOptions) {
-    if (option.kind === "primaryKey") {
-      throw new Error("Table.Class does not support table-level primary keys; declare primary keys inline on columns")
-    }
-  }
-}
 const resolveFieldDialect = (fields: TableFieldMap): string => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))]
   if (dialects.length === 0) {
     throw new Error("Cannot infer table dialect from an empty field set")
   }
-  if (dialects.length > 1) {
+  const concreteDialects = dialects.filter((dialect) => dialect !== "standard")
+  const uniqueConcreteDialects = [...new Set(concreteDialects)]
+  if (uniqueConcreteDialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`)
   }
-  return dialects[0]!
+  return uniqueConcreteDialects[0] ?? "standard"
 }
 const validateFieldDialects = (tableName: string, fields: TableFieldMap): void => {
@@ -442,7 +780,6 @@ const ensureClassArtifacts = <
   }
   const state = self[TypeId]
   const classOptions = self[options]
-  validateClassOptions(extractDeclaredOptions(classOptions))
   const table = applyDeclaredOptions(
     makeTable(
       state.name,
@@ -451,15 +788,16 @@ const ensureClassArtifacts = <
       state.name,
       "schema",
       state.schemaName,
-      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"
+      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit",
+      state.casing
     ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", typeof state.schemaName>,
     classOptions
   )
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
-    primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
+    primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[],
+    conflictArbiters: table[TypeId].conflictArbiters
   } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
@@ -476,9 +814,6 @@ const appendOption = <
   option: Spec
 ): ApplyOption<Table, Spec> => {
   const state = table[TypeId]
-  if (state.kind !== "schema") {
-    throw new Error("Table options can only be applied to schema tables, not aliased query sources")
-  }
   return makeTable(
     state.name,
     state.fields,
@@ -486,49 +821,113 @@ const appendOption = <
     state.baseName,
     state.kind,
     state.schemaName,
-    "explicit"
+    "explicit",
+    state.casing
   ) as unknown as ApplyOption<Table, Spec>
 }
-const makeOption = <Spec extends TableOptionSpec>(option: Spec): TableOption<Spec> => {
-  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
-    appendOption(table, option)) as unknown as TableOption<Spec>
-  ;(builder as { option: Spec }).option = option
-  return builder
+const makeOption = <
+  Spec extends TableOptionSpec,
+  TableContext extends SchemaTableDefinition = SchemaTableDefinition
+>(option: Spec): TableOption<Spec, TableContext> => {
+  return attachPipe(Object.assign(
+    <Table extends TableDefinition<any, any, any, "schema", any>>(
+      table: Table,
+      ..._validation: OptionValidationArgs<Table, Spec>
+    ): ApplyTableOption<Table, Spec> =>
+      appendOption(table, option) as unknown as ApplyTableOption<Table, Spec>,
+    { option }
+  )) as unknown as TableOption<Spec, TableContext>
 }
-const makeResolvedOption = <Spec extends TableOptionSpec>(
+const makeResolvedOption = <
+  Spec extends TableOptionSpec,
+  TableContext extends SchemaTableDefinition = SchemaTableDefinition
+>(
   option: Spec,
   resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
-): TableOption<Spec> => {
-  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
-    appendOption(table, resolve(table))) as unknown as TableOption<Spec>
-  ;(builder as { option: Spec }).option = option
-  return builder
+): TableOption<Spec, TableContext> => {
+  return attachPipe(Object.assign(
+    <Table extends TableDefinition<any, any, any, "schema", any>>(
+      table: Table,
+      ..._validation: OptionValidationArgs<Table, Spec>
+    ): ApplyTableOption<Table, Spec> =>
+      appendOption(
+        table,
+        resolve(table)
+      ) as unknown as ApplyTableOption<Table, Spec>,
+    {
+      option,
+      [ResolveOptionSymbol]: resolve
+    }
+  )) as unknown as TableOption<Spec, TableContext>
 }
 export const option = <Spec extends TableOptionSpec>(spec: Spec): TableOption<Spec> =>
   makeOption(spec)
-export const optionFromTable = <Spec extends TableOptionSpec>(
+export const optionFromTable = <
+  Spec extends TableOptionSpec,
+  TableContext extends SchemaTableDefinition = SchemaTableDefinition
+>(
   spec: Spec,
   resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
-): TableOption<Spec> =>
+): TableOption<Spec, TableContext> =>
   makeResolvedOption(spec, resolve)
+export const resolveOption = <
+  Spec extends TableOptionSpec,
+  TableContext extends SchemaTableDefinition
+>(
+  option: TableOption<Spec, TableContext>,
+  table: TableContext
+): Spec => {
+  const resolve = option[ResolveOptionSymbol]
+  return resolve === undefined ? option.option : resolve(table)
+}
+export const mapOption = <
+  Spec extends TableOptionSpec,
+  Next extends TableOptionSpec,
+  TableContext extends SchemaTableDefinition
+>(
+  option: TableOption<Spec, TableContext>,
+  map: (spec: Spec) => Next
+): TableOption<Next, TableContext> => {
+  const resolve = option[ResolveOptionSymbol]
+  return resolve === undefined
+    ? makeOption<Next, TableContext>(map(option.option))
+    : makeResolvedOption<Next, TableContext>(
+        map(option.option),
+        (table) => map(resolve(table))
+      )
+}
 /** Creates a table definition from a name and field map. */
+export function make<
+  Name extends string,
+  Fields extends TableFieldMap
+>(
+  name: NonEmptyStringInput<Name>,
+  fields: Fields & NonEmptyFieldMap<Fields>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", DefaultSchemaName>
 export function make<
   Name extends string,
   Fields extends TableFieldMap,
-  SchemaName extends string | undefined = DefaultSchemaName
+  const SchemaName extends string
 >(
-  name: Name,
-  fields: Fields,
-  schemaName?: SchemaName
-): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName> {
+  name: NonEmptyStringInput<Name>,
+  fields: Fields & NonEmptyFieldMap<Fields>,
+  schemaName: NonEmptySchemaNameInput<SchemaName>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>
+export function make(
+  name: string,
+  fields: TableFieldMap,
+  schemaName?: string
+): any {
   const resolvedSchemaName = arguments.length >= 3
     ? schemaName
-    : ("public" as SchemaName)
+    : "public"
   return makeTable(
     name,
     fields,
@@ -540,38 +939,58 @@ export function make<
   )
 }
-/**
- * Creates a namespace-scoped builder for a concrete SQL schema/database.
- */
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => {
-  const table = <
-    Name extends string,
-    Fields extends TableFieldMap,
-    const Options extends DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ): ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options> =>
-    applyDeclaredOptions(
-      makeTable(
-        name,
-        fields,
-        [],
-        name,
-        "schema",
-        schemaName,
-        "explicit"
-      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
-      options as unknown as Options
-    ) as ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  return {
+export const withCasing = <
+  Table extends TableDefinition<any, any, any, any, any>
+>(
+  table: Table,
+  casing: Casing.Options
+): Table => {
+  const state = table[TypeId]
+  return makeTable(
+    state.name,
+    state.fields,
+    table[DeclaredOptionsSymbol],
+    state.baseName,
+    state.kind,
+    state.schemaName,
+    "explicit",
+    Casing.merge(state.casing, casing)
+  ) as Table
+}
+export const withSchema = <
+  Table extends TableDefinition<any, any, any, any, any>,
+  SchemaName extends string
+>(
+  table: Table,
+  schemaName: SchemaName,
+  schemaCasing?: Casing.Options
+): TableDefinition<
+  Table[typeof TypeId]["name"],
+  Table[typeof TypeId]["fields"],
+  Table[typeof TypeId]["primaryKey"][number],
+  Table[typeof TypeId]["kind"],
+  SchemaName,
+  Table[typeof TypeId]["conflictArbiters"][number]
+> => {
+  const state = table[TypeId]
+  return makeTable(
+    state.name,
+    state.fields,
+    table[DeclaredOptionsSymbol],
+    state.baseName,
+    state.kind,
     schemaName,
-    table
-  } as unknown as TableSchemaNamespace<SchemaName>
+    "explicit",
+    Casing.merge(schemaCasing, state.casing)
+  ) as TableDefinition<
+    Table[typeof TypeId]["name"],
+    Table[typeof TypeId]["fields"],
+    Table[typeof TypeId]["primaryKey"][number],
+    Table[typeof TypeId]["kind"],
+    SchemaName,
+    Table[typeof TypeId]["conflictArbiters"][number]
+  >
 }
 /**
@@ -586,39 +1005,43 @@ export const alias = <
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string,
   SchemaName extends string,
+  ConflictArbiters extends ConflictArbiter,
   AliasName extends string
 >(
-  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName> | TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>,
-  aliasName: AliasName
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName, ConflictArbiters> | TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName, ConflictArbiters>,
+  aliasName: LiteralStringInput<AliasName>
 ): TableDefinition<
   AliasName,
   Fields,
   PrimaryKeyColumns,
   "alias",
-  SchemaName
+  SchemaName,
+  ConflictArbiters
 > => {
   const state = table[TypeId]
   const columns = Object.fromEntries(
-    Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column as AnyColumnDefinition, state.baseName, state.schemaName)])
+    Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName as AliasName, key, column as AnyColumnDefinition, state.baseName, state.schemaName, state.casing)])
   ) as BoundColumns<AliasName, Fields>
   const aliased = attachPipe(Object.create(TableProto))
-  aliased.name = aliasName
+  aliased.name = aliasName as AliasName
   aliased.columns = columns
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
+  defineSchemasGetter(aliased)
   aliased[TypeId] = {
-    name: aliasName,
+    name: aliasName as AliasName,
     baseName: state.baseName,
     schemaName: state.schemaName,
     fields: state.fields,
     primaryKey: state.primaryKey,
-    kind: "alias"
+    conflictArbiters: state.conflictArbiters,
+    kind: "alias",
+    casing: state.casing
   }
   aliased[Plan.TypeId] = {
     selection: columns,
     required: undefined as never,
     available: {
       [aliasName]: {
-        name: aliasName,
+        name: aliasName as AliasName,
         mode: "required",
         baseName: state.baseName
       }
@@ -642,19 +1065,38 @@ export const alias = <
  * The returned base class can be extended and configured with
  * `static readonly [Table.options]`.
  */
+export function Class<Self = never>(
+  name: "",
+  schemaName?: string | undefined
+): never
+export function Class<Self = never>(
+  name: string,
+  schemaName: ""
+): never
+export function Class<
+  Self = never,
+  const SchemaName extends string | undefined = DefaultSchemaName,
+  const Name extends string = string
+>(
+  name: NonEmptyStringInput<Name>,
+  schemaName?: NonEmptySchemaNameInput<SchemaName>
+): <Fields extends TableFieldMap>(fields: Fields & NonEmptyFieldMap<Fields>) => [Self] extends [never]
+  ? MissingSelfGeneric
+  : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
 export function Class<
   Self = never,
-  SchemaName extends string | undefined = DefaultSchemaName
+  SchemaName extends string | undefined = DefaultSchemaName,
+  Name extends string = string
 >(
   name: string,
   schemaName?: SchemaName
-) {
+): any {
   const resolvedSchemaName = arguments.length >= 2
     ? schemaName
     : ("public" as SchemaName)
-  return <Fields extends TableFieldMap>(fields: Fields): [Self] extends [never]
+  return <Fields extends TableFieldMap>(fields: Fields & NonEmptyFieldMap<Fields>): [Self] extends [never]
     ? MissingSelfGeneric
-    : TableClassStatic<typeof name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName> => {
+    : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName> => {
       abstract class TableClassBase {
         static readonly tableName = name
@@ -663,18 +1105,19 @@ export function Class<
         }
         static get schemas() {
-          return ensureClassArtifacts(this as any).schemas
+          return schemasFor(this as any)
         }
         static get [TypeId]() {
-          const declaredOptions = extractDeclaredOptions((this as unknown as TableClassStatic<typeof name, Fields>)[options])
-          validateClassOptions(declaredOptions)
+          const declaredOptions = extractDeclaredOptions((this as unknown as TableClassStatic<Name, Fields>)[options])
+          const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions]
           return {
             name,
             baseName: name,
             schemaName: resolvedSchemaName,
             fields,
             primaryKey: resolvePrimaryKeyColumns(fields, collectInlineOptions(fields)),
+            conflictArbiters: conflictArbitersFromOptions(normalizedOptions),
             kind: "schema"
           }
         }
@@ -699,7 +1142,7 @@ export function Class<
           return ensureClassArtifacts(this as any).normalizedOptions
         }
-        static pipe(this: unknown) {
+        static pipe(this: Pipeable) {
           return pipeArguments(this, arguments)
         }
       }
@@ -718,97 +1161,236 @@ export function Class<
     }
 }
+const selectionArray = (selection: AnyColumnSelection): readonly AnyBoundColumn[] =>
+  (Array.isArray(selection) ? selection : [selection]) as readonly AnyBoundColumn[]
+export const selectedColumnList = <Selection extends AnyColumnSelection>(
+  selection: Selection
+): SelectedColumns<Selection> =>
+  selectionArray(selection).map((column) => column[BoundColumnTypeId].columnName) as unknown as SelectedColumns<Selection>
+const referenceFromSelection = <Selection extends AnyColumnSelection>(selection: Selection) => {
+  const columns = selectionArray(selection)
+  const first = columns[0]!
+  const bound = first[BoundColumnTypeId]
+  return {
+    tableName: bound.baseTableName,
+    schemaName: bound.schemaName,
+    casing: bound.casing,
+    columns: columns.map((column) => column[BoundColumnTypeId].columnName) as unknown as SelectedColumns<Selection>
+  }
+}
 /** Declares a table-level primary key. */
-export const primaryKey = <
-  const Columns extends string | readonly string[]
+export function primaryKey<
+  Table extends SchemaTableDefinition,
+  Selection extends TableColumnSelection<Table> = TableColumnSelection<Table>
+>(
+  columns: ConcreteSelector<Table, Selection>
+): TableOption<{
+  readonly kind: "primaryKey"
+  readonly columns: SelectedColumns<Selection>
+}, Table>
+export function primaryKey<
+  Selection extends AnyColumnSelection
 >(
-  columns: Columns & NonEmptyColumnInput<Columns>
+  columns: (table: LooseTableSelection) => Selection
+): TableOption<{
+  readonly kind: "primaryKey"
+  readonly columns: SelectedColumns<Selection>
+}>
+export function primaryKey(
+  columns: (table: any) => AnyColumnSelection
 ): TableOption<{
   readonly kind: "primaryKey"
-  readonly columns: NormalizeColumns<Columns>
-}> => makeOption({
-  kind: "primaryKey",
-  columns: normalizeColumnList(columns) as NormalizeColumns<Columns>
-})
+  readonly columns: readonly [string, ...string[]]
+}> {
+  return makeResolvedOption({
+    kind: "primaryKey",
+    columns: [] as unknown as readonly [string, ...string[]]
+  }, (table) => ({
+    kind: "primaryKey",
+    columns: selectedColumnList(columns(table))
+  }))
+}
 /** Declares a table-level unique constraint. */
-export const unique = <
-  const Columns extends string | readonly string[]
+export function unique<
+  Table extends SchemaTableDefinition,
+  Selection extends TableColumnSelection<Table> = TableColumnSelection<Table>
+>(
+  columns: ConcreteSelector<Table, Selection>
+): TableOption<{
+  readonly kind: "unique"
+  readonly columns: SelectedColumns<Selection>
+}, Table>
+export function unique<
+  Selection extends AnyColumnSelection
 >(
-  columns: Columns & NonEmptyColumnInput<Columns>
+  columns: (table: LooseTableSelection) => Selection
 ): TableOption<{
   readonly kind: "unique"
-  readonly columns: NormalizeColumns<Columns>
-}> => makeOption({
-  kind: "unique",
-  columns: normalizeColumnList(columns) as NormalizeColumns<Columns>
-})
+  readonly columns: SelectedColumns<Selection>
+}>
+export function unique(
+  columns: (table: any) => AnyColumnSelection
+): TableOption<{
+  readonly kind: "unique"
+  readonly columns: readonly [string, ...string[]]
+}> {
+  return makeResolvedOption({
+    kind: "unique",
+    columns: [] as unknown as readonly [string, ...string[]]
+  }, (table) => ({
+    kind: "unique",
+    columns: selectedColumnList(columns(table))
+  }))
+}
 /** Declares a table-level index. */
-export const index = <
-  const Columns extends string | readonly string[]
+export function index<
+  Table extends SchemaTableDefinition,
+  Selection extends TableColumnSelection<Table> = TableColumnSelection<Table>
 >(
-  columns: Columns & NonEmptyColumnInput<Columns>
+  columns: ConcreteSelector<Table, Selection>
 ): TableOption<{
   readonly kind: "index"
-  readonly columns: NormalizeColumns<Columns>
-}> => makeOption({
-  kind: "index",
-  columns: normalizeColumnList(columns) as NormalizeColumns<Columns>
-})
+  readonly columns: SelectedColumns<Selection>
+}, Table>
+export function index<
+  Selection extends AnyColumnSelection
+>(
+  columns: (table: LooseTableSelection) => Selection
+): TableOption<{
+  readonly kind: "index"
+  readonly columns: SelectedColumns<Selection>
+}>
+export function index(
+  columns: (table: any) => AnyColumnSelection
+): TableOption<{
+  readonly kind: "index"
+  readonly columns: readonly [string, ...string[]]
+}> {
+  return makeResolvedOption({
+    kind: "index",
+    columns: [] as unknown as readonly [string, ...string[]]
+  }, (table) => ({
+    kind: "index",
+    columns: selectedColumnList(columns(table))
+  }))
+}
 /** Declares a table-level foreign key. */
-export const foreignKey = <
-  const LocalColumns extends string | readonly string[],
-  TargetTable extends AnyTable,
-  const TargetColumns extends string | readonly string[]
->(
-  columns: LocalColumns & NonEmptyColumnInput<LocalColumns>,
-  target: () => TargetTable,
-  referencedColumns: TargetColumns & NonEmptyColumnInput<TargetColumns> & MatchingColumnArityInput<LocalColumns, TargetColumns>
+export function foreignKey<
+  Table extends SchemaTableDefinition,
+  LocalSelection extends TableColumnSelection<Table> = TableColumnSelection<Table>,
+  TargetSelection extends AnyColumnSelection = AnyColumnSelection
+>(
+  columns: ConcreteSelector<Table, LocalSelection>,
+  target: () => TargetSelection & MatchingSelectionArityInput<LocalSelection, TargetSelection>
 ): TableOption<{
   readonly kind: "foreignKey"
-  readonly columns: NormalizeColumns<LocalColumns>
+  readonly columns: SelectedColumns<LocalSelection>
   readonly references: () => {
     readonly tableName: string
     readonly schemaName?: string
-    readonly columns: NormalizeColumns<TargetColumns>
-    readonly knownColumns: readonly ColumnNamesOfAnyTable<TargetTable>[]
+    readonly casing?: Casing.Options
+    readonly columns: SelectedColumns<TargetSelection>
   }
-}> => makeOption({
-  kind: "foreignKey",
-  columns: normalizeColumnList(columns) as NormalizeColumns<LocalColumns>,
-  references: () => ({
-    tableName: target()[TypeId].baseName,
-    schemaName: target()[TypeId].schemaName,
-    columns: normalizeColumnList(referencedColumns) as NormalizeColumns<TargetColumns>,
-    knownColumns: Object.keys(target()[TypeId].fields) as unknown as readonly ColumnNamesOfAnyTable<TargetTable>[]
-  })
-})
+}, Table>
+export function foreignKey<
+  LocalSelection extends AnyColumnSelection,
+  TargetSelection extends AnyColumnSelection
+>(
+  columns: (table: LooseTableSelection) => LocalSelection,
+  target: () => TargetSelection
+): TableOption<{
+  readonly kind: "foreignKey"
+  readonly columns: SelectedColumns<LocalSelection>
+  readonly references: () => {
+    readonly tableName: string
+    readonly schemaName?: string
+    readonly casing?: Casing.Options
+    readonly columns: SelectedColumns<TargetSelection>
+  }
+}>
+export function foreignKey(
+  columns: (table: any) => AnyColumnSelection,
+  target: () => AnyColumnSelection
+): TableOption<{
+  readonly kind: "foreignKey"
+  readonly columns: readonly [string, ...string[]]
+  readonly references: () => {
+    readonly tableName: string
+    readonly schemaName?: string
+    readonly casing?: Casing.Options
+    readonly columns: readonly [string, ...string[]]
+  }
+}> {
+  return makeResolvedOption({
+    kind: "foreignKey",
+    columns: [] as unknown as readonly [string, ...string[]],
+    references: () => referenceFromSelection(target())
+  }, (table) => ({
+    kind: "foreignKey",
+    columns: selectedColumnList(columns(table)),
+    references: () => referenceFromSelection(target())
+  }))
+}
 /** Declares a check constraint expression. */
-export const check = <Name extends string>(
-  name: Name,
+export function check<const Name extends string>(
+  name: NonEmptyStringInput<Name>,
   predicate: DdlExpressionLike
 ): TableOption<{
   readonly kind: "check"
   readonly name: Name
   readonly predicate: DdlExpressionLike
-}> => makeOption({
-  kind: "check",
-  name,
-  predicate
-})
-/** Extracts the row type of a table's select schema. */
-export type SelectOf<Table extends { readonly schemas: { readonly select: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["select"]
->
-/** Extracts the payload type of a table's insert schema. */
-export type InsertOf<Table extends { readonly schemas: { readonly insert: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["insert"]
->
-/** Extracts the payload type of a table's update schema. */
-export type UpdateOf<Table extends { readonly schemas: { readonly update: Schema.Schema<any> } }> = Schema.Schema.Type<
-  Table["schemas"]["update"]
->
+}>
+export function check<const Name extends string>(
+  name: NonEmptyStringInput<Name>,
+  predicate: CheckPredicate
+): TableOption<{
+  readonly kind: "check"
+  readonly name: Name
+  readonly predicate: DdlExpressionLike
+}>
+export function check(
+  name: string,
+  predicate: DdlExpressionLike | CheckPredicate
+): TableOption<{
+  readonly kind: "check"
+  readonly name: string
+  readonly predicate: DdlExpressionLike
+}> {
+  const spec = {
+    kind: "check",
+    name,
+    predicate: predicate as DdlExpressionLike
+  } as const
+  return typeof predicate === "function"
+    ? makeResolvedOption(spec, (table) => ({
+        ...spec,
+        predicate: predicate(table as CheckPredicateTable)
+      }))
+    : makeOption(spec)
+}
+/** Extracts the row type produced by `selectSchema(table)`. */
+export type SelectOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+} ? SelectRow<Name, Fields> : never
+/** Extracts the payload type produced by `insertSchema(table)`. */
+export type InsertOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+} ? InsertRow<Name, Fields> : never
+/** Extracts the payload type produced by `updateSchema(table)`. */
+export type UpdateOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+  readonly name: infer Name extends string
+  readonly fields: infer Fields extends TableFieldMap
+  readonly primaryKey: readonly (infer PrimaryKeyColumns)[]
+} ? UpdateRow<Name, Fields, Extract<PrimaryKeyColumns, keyof Fields & string>> : never