effect-qb 0.17.0 → 0.19.0

package/src/internal/dialect.ts

@@ -1,6 +1,9 @@
 import type * as Schema from "effect/Schema"
 
+import type * as QueryAst from "./query-ast.js"
+import type { Projection } from "./projections.js"
 import type * as Expression from "./scalar.js"
+import type * as Casing from "./casing.js"
 
 /**
  * Mutable rendering state shared while serializing SQL for a concrete dialect.
@@ -11,6 +14,7 @@ import type * as Expression from "./scalar.js"
 export interface RenderState {
   readonly params: unknown[]
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
   readonly ctes: {
     readonly name: string
     readonly sql: string
@@ -18,7 +22,12 @@ export interface RenderState {
   }[]
   readonly cteNames: Set<string>
   readonly cteSources: Map<string, unknown>
+  readonly sourceNames?: Map<string, {
+    readonly tableName: string
+    readonly columns: ReadonlyMap<string, string>
+  }>
   readonly rowLocalColumns?: boolean
+  readonly allowExcluded?: boolean
 }
 
 export interface RenderValueContext {
@@ -27,6 +36,22 @@ export interface RenderValueContext {
   readonly driverValueMapping?: Expression.DriverValueMapping
 }
 
+export const quoteDoubleQuotedIdentifier = (value: string): string => {
+  return `"${value.replaceAll("\"", "\"\"")}"`
+}
+
+export const quoteBacktickIdentifier = (value: string): string => {
+  return `\`${value.replaceAll("`", "``")}\``
+}
+
+export const renderDbTypeName = (value: string): string =>
+  value
+
+export interface RenderedAst {
+  readonly sql: string
+  readonly projections: readonly Projection[]
+}
+
 /**
  * Minimal runtime contract for a SQL dialect.
  *
@@ -40,4 +65,14 @@ export interface SqlDialect<Name extends string = string> {
   renderLiteral(value: unknown, state: RenderState, context?: RenderValueContext): string
   renderTableReference(tableName: string, baseTableName: string, schemaName?: string): string
   renderConcat(values: readonly string[]): string
+  renderQueryAst(
+    ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+    state: RenderState,
+    dialect: SqlDialect<Name>
+  ): RenderedAst
+  renderExpression(
+    expression: Expression.Any,
+    state: RenderState,
+    dialect: SqlDialect<Name>
+  ): string
 }

package/src/internal/dsl-mutation-runtime.ts

@@ -1,6 +1,6 @@
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
-import * as Table from "./table.js"
+import { normalizeStatementFlag } from "./dsl-transaction-ddl-runtime.js"
 
 type DslMutationRuntimeContext = {
   readonly profile: {
@@ -23,150 +23,18 @@ type DslMutationRuntimeContext = {
   readonly sourceDetails: (source: any) => { readonly sourceName: string; readonly sourceBaseName: string }
 }
 
-export const expectInsertSourceKind = <
-  Source extends { readonly kind: string } | undefined
->(
-  source: Source
-): Source => {
-  if (
-    source !== undefined &&
-    source.kind !== "values" &&
-    source.kind !== "query" &&
-    source.kind !== "unnest"
-  ) {
-    throw new Error("Unsupported insert source kind")
-  }
-  return source
-}
-
 export const expectConflictClause = <
   Conflict extends {
     readonly kind: string
     readonly action: string
-    readonly target?: { readonly kind: string }
+    readonly target?: { readonly kind: string; readonly name?: string }
   } | undefined
 >(
   conflict: Conflict
-): Conflict => {
-  if (conflict === undefined) {
-    return conflict
-  }
-  if (conflict.kind !== "conflict") {
-    throw new Error("Unsupported conflict clause kind")
-  }
-  if (conflict.action !== "doNothing" && conflict.action !== "doUpdate") {
-    throw new Error("Unsupported conflict action")
-  }
-  if (
-    conflict.target !== undefined &&
-    conflict.target.kind !== "columns" &&
-    conflict.target.kind !== "constraint"
-  ) {
-    throw new Error("Unsupported conflict target kind")
-  }
-  return conflict
-}
+): Conflict => conflict
 
 export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
-  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"])
-  const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
-    typeof value === "object" && value !== null
-
-  const isTableTarget = (target: unknown): boolean =>
-    typeof target === "object" && target !== null && Table.TypeId in target && Plan.TypeId in target
-
-  const hasColumnRecord = (value: Record<PropertyKey, unknown>): boolean => isRecord(value.columns)
-
-  const isAliasedSource = (source: unknown): boolean => {
-    if (!isRecord(source)) {
-      return false
-    }
-    if (isTableTarget(source)) {
-      return true
-    }
-    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
-      return false
-    }
-    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
-      return false
-    }
-    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
-      return false
-    }
-    switch (source.kind) {
-      case "derived":
-      case "cte":
-      case "lateral":
-        return isRecord(source.plan) && Plan.TypeId in source.plan && hasColumnRecord(source)
-      case "values":
-        return Array.isArray(source.rows) && hasColumnRecord(source)
-      case "unnest":
-        return isRecord(source.arrays) && hasColumnRecord(source)
-      case "tableFunction":
-        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source)
-    }
-    return false
-  }
-
-  const assertMutationTarget = (target: unknown, apiName: string): void => {
-    if (!isTableTarget(target)) {
-      throw new Error(`${apiName}(...) requires table targets`)
-    }
-  }
-
-  const assertAliasedSource = (source: unknown, apiName: string): void => {
-    if (!isAliasedSource(source)) {
-      throw new Error(`${apiName}(...) requires an aliased source`)
-    }
-  }
-
-  const assertMutationTargets = (
-    target: unknown,
-    apiName: string,
-    options: { readonly allowMultiple?: boolean } = {}
-  ): void => {
-    const targets = Array.isArray(target) ? target : [target]
-    if (targets.length === 0) {
-      throw new Error(`${apiName}(...) requires at least one table target`)
-    }
-    if (Array.isArray(target) && targets.length === 1) {
-      throw new Error(`${apiName}(...) requires a table target, not a single-element target tuple`)
-    }
-    for (const entry of targets) {
-      assertMutationTarget(entry, apiName)
-    }
-    if (targets.length > 1 && options.allowMultiple !== true) {
-      throw new Error(`${apiName}(...) requires a single table target`)
-    }
-    if (targets.length > 1 && ctx.profile.dialect !== "mysql" && ctx.profile.dialect !== "sqlite") {
-      throw new Error(`${apiName}(...) only supports multiple mutation targets for mysql`)
-    }
-  }
-
-  const assertUniqueTargetNames = (targets: readonly { readonly tableName: string }[]): void => {
-    const seen = new Set<string>()
-    for (const target of targets) {
-      if (seen.has(target.tableName)) {
-        throw new Error(`mutation target source names must be unique: ${target.tableName}`)
-      }
-      seen.add(target.tableName)
-    }
-  }
-
-  const assertInsertSelectSource = (sourcePlan: any, selection: Record<string, unknown>): void => {
-    const statement = ctx.getQueryState(sourcePlan).statement
-    if (statement !== "select" && statement !== "set") {
-      throw new Error("insert sources only accept select-like query plans")
-    }
-    for (const value of Object.values(selection)) {
-      if (value === null || typeof value !== "object" || !(Expression.TypeId in value)) {
-        throw new Error("insert sources require a flat selection object")
-      }
-    }
-  }
-
   const insert = (target: any, values?: Record<string, unknown>) => {
-    assertMutationTargets(target, "insert")
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     const assignments = values === undefined
       ? []
@@ -248,7 +116,6 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
 
     const sourcePlan = source
     const selection = sourcePlan[Plan.TypeId].selection as Record<string, Expression.Any>
-    assertInsertSelectSource(sourcePlan, selection)
     const columns = ctx.normalizeInsertSelectColumns(selection)
     return ctx.makePlan({
       selection: current.selection,
@@ -271,17 +138,15 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
-      if (currentQuery.statement !== "insert") {
-        throw new Error(`onConflict(...) is not supported for ${currentQuery.statement} statements`)
-      }
       const insertTarget = currentAst.into!.source
-      const conflictTarget = ctx.buildConflictTarget(insertTarget, target)
+      const conflictTarget = expectConflictClause({
+        kind: "conflict",
+        action: "doNothing",
+        target: ctx.buildConflictTarget(insertTarget, target)
+      }).target
       const updateAssignments = options.update
         ? ctx.buildMutationAssignments(insertTarget, options.update)
         : []
-      if (options.update !== undefined && updateAssignments.length === 0) {
-        throw new Error("conflict update assignments require at least one assignment")
-      }
       const updateWhere = options.where === undefined
         ? undefined
         : ctx.toDialectExpression(options.where)
@@ -311,9 +176,7 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
     }
 
   const update = (target: any, values: Record<string, unknown>) => {
-    assertMutationTargets(target, "update", { allowMultiple: true })
     const targets = ctx.mutationTargetClauses(target)
-    assertUniqueTargetNames(targets)
     const primaryTarget = targets[0]!
     const assignments = ctx.buildMutationAssignments(target, values)
     const targetNames = new Set(targets.map((entry: any) => entry.tableName))
@@ -340,13 +203,9 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const upsert = (target: any, values: Record<string, unknown>, conflictColumns: string | readonly string[], updateValues?: Record<string, unknown>) => {
-    assertMutationTargets(target, "upsert")
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     const assignments = ctx.buildMutationAssignments(target, values)
     const updateAssignments = updateValues ? ctx.buildMutationAssignments(target, updateValues) : []
-    if (updateValues !== undefined && updateAssignments.length === 0) {
-      throw new Error("upsert update assignments require at least one assignment")
-    }
     const required = [
       ...assignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies)),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[Expression.TypeId].dependencies))
@@ -390,9 +249,7 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const delete_ = (target: any) => {
-    assertMutationTargets(target, "delete", { allowMultiple: true })
     const targets = ctx.mutationTargetClauses(target)
-    assertUniqueTargetNames(targets)
     const primaryTarget = targets[0]!
     return ctx.makePlan({
       selection: {},
@@ -413,7 +270,8 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const truncate = (target: any, options: { readonly restartIdentity?: boolean; readonly cascade?: boolean } = {}) => {
-    assertMutationTargets(target, "truncate")
+    const restartIdentity = normalizeStatementFlag(options.restartIdentity)
+    const cascade = normalizeStatementFlag(options.cascade)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -431,8 +289,8 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
       },
       truncate: {
         kind: "truncate",
-        restartIdentity: options.restartIdentity ?? false,
-        cascade: options.cascade ?? false
+        restartIdentity,
+        cascade
       },
       where: [],
       having: [],
@@ -443,19 +301,11 @@ export const makeDslMutationRuntime = (ctx: DslMutationRuntimeContext) => {
   }
 
   const merge = (target: any, source: any, on: any, options: any = {}) => {
-    assertMutationTargets(target, "merge")
-    assertAliasedSource(source, "merge")
     const { sourceName: targetName, sourceBaseName: targetBaseName } = ctx.targetSourceDetails(target)
     const { sourceName: usingName, sourceBaseName: usingBaseName } = ctx.sourceDetails(source)
-    if (targetName === usingName) {
-      throw new Error(`merge(...) source name must differ from target source name: ${targetName}`)
-    }
     const onExpression = ctx.toDialectExpression(on)
     const matched = options.whenMatched
     const notMatched = options.whenNotMatched
-    if (matched && "delete" in matched && "update" in matched) {
-      throw new Error("merge whenMatched cannot specify both update and delete")
-    }
     const matchedPredicate = matched?.predicate ? ctx.toDialectExpression(matched.predicate) : undefined
     const matchedAssignments = matched && "update" in matched && matched.update
       ? ctx.buildMutationAssignments(target, matched.update)

package/src/internal/dsl-plan-runtime.ts

@@ -1,6 +1,5 @@
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
-import * as Table from "./table.js"
 
 type DslPlanRuntimeContext = {
   readonly profile: {
@@ -22,122 +21,28 @@ type DslPlanRuntimeContext = {
   readonly attachInsertSource: (plan: any, source: any) => any
 }
 
-export const renderSelectLockMode = (mode: unknown): string => {
-  switch (mode) {
-    case "update":
-      return "for update"
-    case "share":
-      return "for share"
-  }
-  throw new Error("lock(...) mode must be update or share for select statements")
-}
+type LockMode = "update" | "share" | "lowPriority" | "ignore" | "quick"
+
+export const renderSelectLockMode = (mode: LockMode): string =>
+  mode === "update" ? "for update" : "for share"
 
 export const renderMysqlMutationLockMode = (
-  mode: unknown,
-  statement: "update" | "delete"
+  mode: LockMode,
+  _statement: "update" | "delete"
 ): string => {
-  switch (mode) {
-    case "lowPriority":
-      return " low_priority"
-    case "ignore":
-      return " ignore"
-    case "quick":
-      if (statement === "delete") {
-        return " quick"
-      }
-      break
+  if (mode === "lowPriority") {
+    return " low_priority"
   }
-  throw new Error(
-    statement === "update"
-      ? "lock(...) mode must be lowPriority or ignore for update statements"
-      : "lock(...) mode must be lowPriority, quick, or ignore for delete statements"
-  )
+  return mode === "ignore" ? " ignore" : " quick"
 }
 
 export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
-  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"])
-  const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
-    typeof value === "object" && value !== null
-
-  const isPlan = (value: unknown): boolean => isRecord(value) && Plan.TypeId in value
-  const hasColumnRecord = (value: Record<PropertyKey, unknown>): boolean => isRecord(value.columns)
-
   const sourceRequiredList = (source: any): readonly string[] =>
     typeof source === "object" && source !== null && "required" in source
       ? ctx.currentRequiredList(source.required)
       : []
 
-  const isAliasedSource = (source: unknown): boolean => {
-    if (!isRecord(source)) {
-      return false
-    }
-    if (Table.TypeId in source) {
-      return true
-    }
-    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
-      return false
-    }
-    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
-      return false
-    }
-    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
-      return false
-    }
-    switch (source.kind) {
-      case "derived":
-      case "cte":
-      case "lateral":
-        return isPlan(source.plan) && hasColumnRecord(source)
-      case "values":
-        return Array.isArray(source.rows) && hasColumnRecord(source)
-      case "unnest":
-        return isRecord(source.arrays) && hasColumnRecord(source)
-      case "tableFunction":
-        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source)
-    }
-    return false
-  }
-
-  const assertAliasedSource = (source: unknown, message: string): void => {
-    if (!isAliasedSource(source)) {
-      throw new Error(message)
-    }
-  }
-
-  const assertPlanComplete = (plan: any): void => {
-    const required = ctx.currentRequiredList(plan[Plan.TypeId].required)
-    if (required.length > 0) {
-      throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`)
-    }
-  }
-
-  const assertSourceNameAvailable = (available: Record<string, unknown>, sourceName: string): void => {
-    if (sourceName in available) {
-      throw new Error(`query source name is already in scope: ${sourceName}`)
-    }
-  }
-
-  const assertSelectHasBaseSourceForJoin = (statement: string, available: Record<string, unknown>): void => {
-    if (statement === "select" && Object.keys(available).length === 0) {
-      throw new Error("select joins require a from(...) source before joining")
-    }
-  }
-
-  const supportsJoinSources = (statement: string): boolean =>
-    statement === "select" || statement === "update" || statement === "delete"
-
-  const assertSetOperandStatement = (plan: any): void => {
-    const statement = ctx.getQueryState(plan).statement
-    if (statement !== "select" && statement !== "set") {
-      throw new Error("set operator operands only accept select-like query plans")
-    }
-  }
-
   const buildSetOperation = (kind: string, all: boolean, left: any, right: any) => {
-    assertSetOperandStatement(left)
-    assertSetOperandStatement(right)
-    assertPlanComplete(left)
-    assertPlanComplete(right)
     const leftState = left[Plan.TypeId]
     const leftAst = ctx.getAst(left)
     const basePlan = leftAst.kind === "set"
@@ -206,17 +111,10 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
         return ctx.attachInsertSource(plan, source)
       }
 
-      assertAliasedSource(source, "from(...) requires an aliased source in select/update statements")
-
-      if (currentQuery.statement === "select" && currentAst.from !== undefined) {
-        throw new Error("select statements accept only one from(...) source; use joins for additional sources")
-      }
-
       const sourceLike = source
       const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike)
       const sourceRequired = sourceRequiredList(sourceLike)
-      assertSourceNameAvailable(current.available, sourceName)
 
       if (currentQuery.statement === "select") {
         const nextAvailable = {
@@ -276,7 +174,7 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
         }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
       }
 
-      throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`)
+      return plan
     }
 
   const having = (predicate: any) =>
@@ -309,16 +207,9 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
-      if (supportsJoinSources(currentQuery.statement)) {
-        assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements")
-        assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available)
-      }
       const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
       const sourceRequired = sourceRequiredList(table)
-      if (supportsJoinSources(currentQuery.statement)) {
-        assertSourceNameAvailable(current.available, sourceName)
-      }
       const nextAvailable = {
         ...current.available,
         [sourceName]: {
@@ -353,16 +244,9 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       const currentQuery = ctx.getQueryState(plan)
       const onExpression = ctx.toDialectExpression(on)
       const onFormula = ctx.formulaOfExpressionRuntime(onExpression)
-      if (supportsJoinSources(currentQuery.statement)) {
-        assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements")
-        assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available)
-      }
       const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
       const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
       const sourceRequired = sourceRequiredList(table)
-      if (supportsJoinSources(currentQuery.statement)) {
-        assertSourceNameAvailable(current.available, sourceName)
-      }
       const baseAvailable = (kind === "right" || kind === "full"
         ? Object.fromEntries(
           Object.entries(current.available as Record<string, any>).map(([name, source]) => [name, {
@@ -408,9 +292,6 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
 
   const orderBy = (value: any, direction: "asc" | "desc" = "asc") =>
     (plan: any) => {
-      if (direction !== "asc" && direction !== "desc") {
-        throw new Error("orderBy(...) direction must be asc or desc")
-      }
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
@@ -437,15 +318,6 @@ export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
-      if (currentQuery.statement === "select") {
-        renderSelectLockMode(mode)
-      }
-      if (ctx.profile.dialect === "mysql" && currentQuery.statement === "update") {
-        renderMysqlMutationLockMode(mode, "update")
-      }
-      if (ctx.profile.dialect === "mysql" && currentQuery.statement === "delete") {
-        renderMysqlMutationLockMode(mode, "delete")
-      }
       return ctx.makePlan({
         selection: current.selection,
         required: current.required,

package/src/internal/dsl-query-runtime.ts

@@ -1,6 +1,5 @@
 import * as Expression from "./scalar.js"
 import * as Plan from "./row-set.js"
-import { flattenSelection } from "./projections.js"
 
 type DslQueryRuntimeContext = {
   readonly profile: {
@@ -20,55 +19,13 @@ type DslQueryRuntimeContext = {
 }
 
 export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
-  const assertSelectionObject = (apiName: string, selection: any): void => {
-    if (
-      selection === null ||
-      typeof selection !== "object" ||
-      Array.isArray(selection) ||
-      Expression.TypeId in selection
-    ) {
-      throw new Error(`${apiName}(...) expects a projection object`)
-    }
-  }
-
-  const assertSelectionTree = (apiName: string, selection: any): void => {
-    const visit = (value: any, isRoot: boolean): void => {
-      if (value !== null && typeof value === "object" && Expression.TypeId in value) {
-        return
-      }
-      if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`${apiName}(...) selection leaves must be expressions`)
-      }
-      const nested = Object.values(value)
-      if (!isRoot && nested.length === 0) {
-        throw new Error(`${apiName}(...) projection objects cannot contain empty nested selections`)
-      }
-      for (const item of nested) {
-        visit(item, false)
-      }
-    }
-    visit(selection, true)
-  }
-
   const values = (rows: readonly [Record<string, any>, ...Record<string, any>[]]) => {
-    if (rows.length === 0) {
-      throw new Error("values(...) requires at least one row")
-    }
-    const normalizedRows = rows.map((row) => ctx.normalizeValuesRow(row)) as unknown as readonly [
-      Record<string, Expression.Any>,
-      ...Record<string, Expression.Any>[]
-    ]
+    const [first, ...rest] = rows
+    const normalizedRows = [
+      ctx.normalizeValuesRow(first),
+      ...rest.map((row) => ctx.normalizeValuesRow(row))
+    ] satisfies readonly [Record<string, Expression.Any>, ...Record<string, Expression.Any>[]]
     const columnNames = Object.keys(normalizedRows[0]!)
-    if (columnNames.length === 0) {
-      throw new Error("values(...) rows must specify at least one column")
-    }
-    const columnNameSet = new Set(columnNames)
-    for (const row of normalizedRows) {
-      const rowKeys = Object.keys(row)
-      if (rowKeys.length !== columnNames.length || !rowKeys.every((key) => columnNameSet.has(key))) {
-        throw new Error("values(...) rows must project the same columns")
-      }
-    }
     return Object.assign(Object.create(ctx.ValuesInputProto), {
       kind: "values",
       dialect: ctx.profile.dialect,
@@ -80,20 +37,6 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
   const unnest = (columns: Record<string, readonly any[]>, alias: string) => {
     const normalizedColumns = ctx.normalizeUnnestColumns(columns)
     const columnNames = Object.keys(normalizedColumns)
-    if (columnNames.length === 0) {
-      throw new Error("unnest(...) requires at least one column array")
-    }
-    const firstColumn = normalizedColumns[columnNames[0] as keyof typeof normalizedColumns]
-    const rowCount = firstColumn?.length ?? 0
-    if (rowCount === 0) {
-      throw new Error("unnest(...) requires at least one row")
-    }
-    for (const columnName of columnNames) {
-      const values = normalizedColumns[columnName]!
-      if (values.length !== rowCount) {
-        throw new Error("unnest(...) column arrays must have the same length")
-      }
-    }
     const firstRow = Object.fromEntries(
       columnNames.map((columnName) => [columnName, normalizedColumns[columnName]![0]!])
     ) as Record<string, Expression.Any>
@@ -133,8 +76,6 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
   }
 
   const select = (selection: any = {}) => {
-    assertSelectionObject("select", selection)
-    assertSelectionTree("select", selection)
     return ctx.makePlan({
       selection,
       required: ctx.extractRequiredRuntime(selection),
@@ -153,9 +94,6 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
 
   const groupBy = (...values: readonly Expression.Any[]) =>
     (plan: any) => {
-      if (values.length === 0) {
-        throw new Error("groupBy(...) requires at least one expression")
-      }
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
@@ -174,22 +112,10 @@ export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
     }
 
   const returning = (selection: any) => {
-    assertSelectionObject("returning", selection)
-    assertSelectionTree("returning", selection)
-    if (flattenSelection(selection as Record<string, unknown>).length === 0) {
-      throw new Error("returning(...) requires at least one selected expression")
-    }
     return (plan: any) => {
       const current = plan[Plan.TypeId]
       const currentAst = ctx.getAst(plan)
       const currentQuery = ctx.getQueryState(plan)
-      if (
-        currentQuery.statement !== "insert" &&
-        currentQuery.statement !== "update" &&
-        currentQuery.statement !== "delete"
-      ) {
-        throw new Error(`returning(...) is not supported for ${currentQuery.statement} statements`)
-      }
       return ctx.makePlan({
         selection,
         required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredRuntime(selection)].filter((name, index, list) =>