effect-qb 0.16.0 → 0.19.0

package/src/{postgres/internal/sql-expression-renderer.ts → internal/dialect-renderers/postgres.ts}

@@ -1,38 +1,49 @@
-import * as Query from "../../internal/query.js"
-import * as Expression from "../../internal/scalar.js"
-import * as Table from "../../internal/table.js"
-import * as QueryAst from "../../internal/query-ast.js"
-import type { RenderState, SqlDialect } from "../../internal/dialect.js"
-import * as ExpressionAst from "../../internal/expression-ast.js"
-import * as JsonPath from "../../internal/json/path.js"
+import * as Schema from "effect/Schema"
+
+import * as Query from "../query.js"
+import * as Expression from "../scalar.js"
+import * as Table from "../table.js"
+import * as QueryAst from "../query-ast.js"
+import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
+import * as ExpressionAst from "../expression-ast.js"
+import * as JsonPath from "../json/path.js"
+import { renderSelectLockMode } from "../dsl-plan-runtime.js"
+import { expectConflictClause } from "../dsl-mutation-runtime.js"
+import { expectDdlClauseKind, expectTruncateClause, normalizeStatementFlag, normalizeStatementIdentifier, renderTransactionIsolationLevel } from "../dsl-transaction-ddl-runtime.js"
 import {
   renderJsonSelectSql,
   renderSelectSql,
   toDriverValue
-} from "../../internal/runtime/driver-value-mapping.js"
-import { flattenSelection, type Projection } from "../../internal/projections.js"
-import { type SelectionValue, validateAggregationSelection } from "../../internal/aggregation-validation.js"
-import * as SchemaExpression from "../../internal/schema-expression.js"
-import type { DdlExpressionLike } from "../../internal/table-options.js"
+} from "../runtime/driver-value-mapping.js"
+import { normalizeDbValue } from "../runtime/normalize.js"
+import { flattenSelection, type Projection } from "../projections.js"
+import { groupingKeyOfExpression } from "../grouping-key.js"
+import * as SchemaExpression from "../schema-expression.js"
+import { renderReferentialAction, validateOptions, type DdlExpressionLike, type TableOptionSpec } from "../table-options.js"
+import * as Casing from "../casing.js"
 
 const renderDbType = (
   dialect: SqlDialect,
   dbType: Expression.DbType.Any
 ): string => {
-  if (dialect.name === "mysql" && dbType.dialect === "mysql" && dbType.kind === "uuid") {
-    return "char(36)"
+  if (dialect.name === "postgres" && dbType.kind === "blob") {
+    return "bytea"
   }
-  return dbType.kind
+  return renderDbTypeName(dbType.kind)
 }
 
+const isArrayDbType = (dbType: Expression.DbType.Any): boolean =>
+  "element" in dbType
+
 const renderCastType = (
   dialect: SqlDialect,
-  dbType: Expression.DbType.Any
+  dbType: unknown
 ): string => {
+  const kind = (dbType as { readonly kind?: string } | undefined)?.kind as string
   if (dialect.name !== "mysql") {
-    return dbType.kind
+    return renderDbTypeName(kind)
   }
-  switch (dbType.kind) {
+  switch (kind) {
     case "text":
       return "char"
     case "uuid":
@@ -47,35 +58,243 @@ const renderCastType = (
     case "json":
       return "json"
     default:
-      return dbType.kind
+      return renderDbTypeName(kind)
   }
 }
 
+const casingForTable = (
+  table: Table.AnyTable,
+  state: RenderState
+): Casing.Options | undefined =>
+  Casing.merge(state.casing, table[Table.TypeId].casing)
+
+const casedTableName = (
+  table: Table.AnyTable,
+  state: RenderState
+): string => {
+  const tableState = table[Table.TypeId]
+  return Casing.applyCategory(casingForTable(table, state), "tables", tableState.baseName)
+}
+
+const casedSchemaName = (
+  table: Table.AnyTable,
+  state: RenderState
+): string | undefined => {
+  const schemaName = table[Table.TypeId].schemaName
+  return schemaName === undefined
+    ? undefined
+    : Casing.applyCategory(casingForTable(table, state), "schemas", schemaName)
+}
+
+const casedColumnName = (
+  columnName: string,
+  state: RenderState,
+  tableName?: string
+): string => {
+  if (tableName !== undefined) {
+    const mapped = state.sourceNames?.get(tableName)?.columns.get(columnName)
+    if (mapped !== undefined) {
+      return mapped
+    }
+  }
+  return Casing.applyCategory(state.casing, "columns", columnName)
+}
+
+const casedTableReferenceName = (
+  tableName: string,
+  state: RenderState
+): string =>
+  state.sourceNames?.get(tableName)?.tableName ?? Casing.applyCategory(state.casing, "tables", tableName)
+
+const quoteColumn = (
+  columnName: string,
+  state: RenderState,
+  dialect: SqlDialect,
+  tableName?: string
+): string => dialect.quoteIdentifier(casedColumnName(columnName, state, tableName))
+
+const stateWithTableCasing = (
+  state: RenderState,
+  source: unknown
+): RenderState =>
+  typeof source === "object" && source !== null && Table.TypeId in source
+    ? { ...state, casing: casingForTable(source as Table.AnyTable, state) }
+    : state
+
+const referenceCasing = (
+  reference: { readonly casing?: Casing.Options },
+  state: RenderState
+): Casing.Options | undefined =>
+  Casing.merge(state.casing, reference.casing)
+
+const renderReferenceTable = (
+  reference: {
+    readonly tableName: string
+    readonly schemaName?: string
+    readonly casing?: Casing.Options
+  },
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  const casing = referenceCasing(reference, state)
+  const tableName = Casing.applyCategory(casing, "tables", reference.tableName)
+  const schemaName = reference.schemaName === undefined
+    ? undefined
+    : Casing.applyCategory(casing, "schemas", reference.schemaName)
+  return dialect.renderTableReference(tableName, tableName, schemaName)
+}
+
+const quoteReferenceColumn = (
+  columnName: string,
+  reference: { readonly casing?: Casing.Options },
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  dialect.quoteIdentifier(Casing.applyCategory(referenceCasing(reference, state), "columns", columnName))
+
+const registerSourceReference = (
+  source: unknown,
+  tableName: string,
+  state: RenderState
+): void => {
+  if (typeof source !== "object" || source === null) {
+    return
+  }
+  if (Table.TypeId in source) {
+    const table = source as Table.AnyTable
+    const tableState = table[Table.TypeId]
+    const casing = casingForTable(table, state)
+    const renderedTableName = tableState.kind === "alias"
+      ? tableName
+      : Casing.applyCategory(casing, "tables", tableState.baseName)
+    const columns = new Map(
+      Object.keys(tableState.fields).map((columnName) => [
+        columnName,
+        Casing.applyCategory(casing, "columns", columnName)
+      ] as const)
+    )
+    state.sourceNames?.set(tableName, {
+      tableName: renderedTableName,
+      columns
+    })
+    return
+  }
+  if ("columns" in source && typeof source.columns === "object" && source.columns !== null) {
+    state.sourceNames?.set(tableName, {
+      tableName,
+      columns: new Map(Object.keys(source.columns).map((columnName) => [columnName, columnName] as const))
+    })
+  }
+}
+
+const registerQuerySources = (
+  ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+  state: RenderState
+): void => {
+  if (ast.from !== undefined) {
+    registerSourceReference(ast.from.source, ast.from.tableName, state)
+  }
+  for (const source of ast.fromSources ?? []) {
+    registerSourceReference(source.source, source.tableName, state)
+  }
+  for (const join of ast.joins) {
+    registerSourceReference(join.source, join.tableName, state)
+  }
+  if (ast.into !== undefined) {
+    registerSourceReference(ast.into.source, ast.into.tableName, state)
+  }
+  if (ast.target !== undefined) {
+    registerSourceReference(ast.target.source, ast.target.tableName, state)
+  }
+  for (const target of ast.targets ?? []) {
+    registerSourceReference(target.source, target.tableName, state)
+  }
+  if (ast.using !== undefined) {
+    registerSourceReference(ast.using.source, ast.using.tableName, state)
+  }
+}
+
+const renderPostgresDdlString = (value: string): string =>
+  `'${value.replaceAll("'", "''")}'`
+
+const renderPostgresDdlBytes = (value: Uint8Array): string =>
+  `decode('${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}', 'hex')`
+
+const renderPostgresDdlLiteral = (
+  value: unknown,
+  state: RenderState,
+  context: RenderValueContext = {}
+): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    valueMappings: state.valueMappings,
+    ...context
+  })
+  if (driverValue === null) {
+    return "null"
+  }
+  switch (typeof driverValue) {
+    case "boolean":
+      return driverValue ? "true" : "false"
+    case "number":
+      if (!Number.isFinite(driverValue)) {
+        throw new Error("Expected a finite numeric value")
+      }
+      return String(driverValue)
+    case "bigint":
+      return driverValue.toString()
+    case "string":
+      return renderPostgresDdlString(driverValue)
+    case "object":
+      if (driverValue instanceof Uint8Array) {
+        return renderPostgresDdlBytes(driverValue)
+      }
+      break
+  }
+  throw new Error("Unsupported postgres DDL literal value")
+}
+
 const renderDdlExpression = (
   expression: DdlExpressionLike,
   state: RenderState,
   dialect: SqlDialect
-): string =>
-  SchemaExpression.isSchemaExpression(expression)
-    ? SchemaExpression.render(expression)
-    : renderExpression(expression, state, dialect)
+): string => {
+  if (SchemaExpression.isSchemaExpression(expression)) {
+    return SchemaExpression.render(expression)
+  }
+  return renderExpression(expression, state, {
+    ...dialect,
+    renderLiteral: renderPostgresDdlLiteral
+  })
+}
 
 const renderColumnDefinition = (
   dialect: SqlDialect,
   state: RenderState,
   columnName: string,
-  column: Table.AnyTable[typeof Table.TypeId]["fields"][string]
+  column: Table.AnyTable[typeof Table.TypeId]["fields"][string],
+  tableName?: string,
+  casing?: Casing.Options
 ): string => {
+  const expressionState = { ...state, casing, rowLocalColumns: true }
+  if (dialect.name !== "postgres" && isArrayDbType(column.metadata.dbType)) {
+    throw new Error(`Unsupported ${dialect.name} array column options`)
+  }
   const clauses = [
-    dialect.quoteIdentifier(columnName),
-    column.metadata.ddlType ?? renderDbType(dialect, column.metadata.dbType)
+    quoteColumn(columnName, state, dialect, tableName),
+    column.metadata.ddlType === undefined
+      ? renderDbType(dialect, column.metadata.dbType)
+      : renderDbTypeName(column.metadata.ddlType)
   ]
   if (column.metadata.identity) {
+    if (dialect.name !== "postgres") {
+      throw new Error(`Unsupported ${dialect.name} identity column options`)
+    }
     clauses.push(`generated ${column.metadata.identity.generation === "byDefault" ? "by default" : "always"} as identity`)
   } else if (column.metadata.generatedValue) {
-    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, state, dialect)}) stored`)
+    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, expressionState, dialect)}) stored`)
   } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, state, dialect)}`)
+    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, expressionState, dialect)}`)
   }
   if (!column.metadata.nullable) {
     clauses.push("not null")
@@ -87,38 +306,65 @@ const renderCreateTableSql = (
   targetSource: QueryAst.FromClause,
   state: RenderState,
   dialect: SqlDialect,
-  ifNotExists: boolean
+  ifNotExists: unknown
 ): string => {
+  const normalizedIfNotExists = normalizeStatementFlag(ifNotExists)
+  if (dialect.name !== "postgres" && normalizedIfNotExists) {
+    throw new Error(`Unsupported ${dialect.name} create table options`)
+  }
   const table = targetSource.source as Table.AnyTable
+  const tableCasing = casingForTable(table, state)
   const fields = table[Table.TypeId].fields
   const definitions = Object.entries(fields).map(([columnName, column]) =>
-    renderColumnDefinition(dialect, state, columnName, column)
+    renderColumnDefinition(dialect, state, columnName, column, targetSource.tableName, tableCasing)
   )
-  for (const option of table[Table.OptionsSymbol]) {
+  const options = table[Table.OptionsSymbol] as unknown
+  const tableOptions = (Array.isArray(options) ? options : [options]) as readonly TableOptionSpec[]
+  validateOptions(table[Table.TypeId].name, fields, tableOptions)
+  for (const option of tableOptions) {
+    if (typeof option !== "object" || option === null || !("kind" in option)) {
+      continue
+    }
     switch (option.kind) {
       case "primaryKey":
-        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}primary key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
+        if (dialect.name !== "postgres" && (option.deferrable || option.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} primary key constraint options`)
+        }
+        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "constraints", option.name))} ` : ""}primary key (${option.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
         break
       case "unique":
-        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}unique${option.nullsNotDistinct ? " nulls not distinct" : ""} (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
+        if (dialect.name !== "postgres" && (option.nullsNotDistinct || option.deferrable || option.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} unique constraint options`)
+        }
+        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "constraints", option.name))} ` : ""}unique${option.nullsNotDistinct ? " nulls not distinct" : ""} (${option.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
         break
       case "foreignKey": {
-        const reference = option.references()
+        if (dialect.name !== "postgres" && (option.deferrable || option.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} foreign key constraint options`)
+        }
+        const reference = typeof option.references === "function"
+          ? option.references()
+          : option.references
         definitions.push(
-          `${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}foreign key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.onDelete ? ` on delete ${option.onDelete.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option.onUpdate ? ` on update ${option.onUpdate.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`
+          `${option.name ? `constraint ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "constraints", option.name))} ` : ""}foreign key (${option.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable(reference, state, dialect)} (${reference.columns.map((column) => quoteReferenceColumn(column, reference, state, dialect)).join(", ")})${option.onDelete !== undefined ? ` on delete ${renderReferentialAction(option.onDelete)}` : ""}${option.onUpdate !== undefined ? ` on update ${renderReferentialAction(option.onUpdate)}` : ""}${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`
         )
         break
       }
       case "check":
+        if (dialect.name !== "postgres" && option.noInherit) {
+          throw new Error(`Unsupported ${dialect.name} check constraint options`)
+        }
         definitions.push(
-          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderDdlExpression(option.predicate, state, dialect)})${option.noInherit ? " no inherit" : ""}`
+          `constraint ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "constraints", option.name))} check (${renderDdlExpression(option.predicate, { ...state, casing: tableCasing, rowLocalColumns: true }, dialect)})${option.noInherit ? " no inherit" : ""}`
         )
         break
       case "index":
         break
+      default:
+        throw new Error("Unsupported table option kind")
     }
   }
-  return `create table${ifNotExists ? " if not exists" : ""} ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${definitions.join(", ")})`
+  return `create table${normalizedIfNotExists ? " if not exists" : ""} ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${definitions.join(", ")})`
 }
 
 const renderCreateIndexSql = (
@@ -127,8 +373,16 @@ const renderCreateIndexSql = (
   state: RenderState,
   dialect: SqlDialect
 ): string => {
-  const maybeIfNotExists = dialect.name === "postgres" && ddl.ifNotExists ? " if not exists" : ""
-  return `create${ddl.unique ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`
+  const unique = normalizeStatementFlag(ddl.unique)
+  const ifNotExists = normalizeStatementFlag(ddl.ifNotExists)
+  const name = normalizeStatementIdentifier("createIndex", "option 'name'", ddl.name)
+  if (dialect.name !== "postgres" && ifNotExists) {
+    throw new Error(`Unsupported ${dialect.name} create index options`)
+  }
+  const maybeIfNotExists = dialect.name === "postgres" && ifNotExists ? " if not exists" : ""
+  const table = targetSource.source as Table.AnyTable
+  const tableCasing = casingForTable(table, state)
+  return `create${unique ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})`
 }
 
 const renderDropIndexSql = (
@@ -136,20 +390,108 @@ const renderDropIndexSql = (
   ddl: Extract<QueryAst.DdlClause, { readonly kind: "dropIndex" }>,
   state: RenderState,
   dialect: SqlDialect
-): string =>
-  dialect.name === "postgres"
-    ? `drop index${ddl.ifExists ? " if exists" : ""} ${dialect.quoteIdentifier(ddl.name)}`
-    : `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`
+): string => {
+  const ifExists = normalizeStatementFlag(ddl.ifExists)
+  const name = normalizeStatementIdentifier("dropIndex", "option 'name'", ddl.name)
+  if (dialect.name !== "postgres" && ifExists) {
+    throw new Error(`Unsupported ${dialect.name} drop index options`)
+  }
+  if (dialect.name === "postgres") {
+    const table = typeof targetSource.source === "object" &&
+      targetSource.source !== null &&
+      Table.TypeId in targetSource.source
+      ? targetSource.source as Table.AnyTable
+      : undefined
+    const schemaName = table?.[Table.TypeId].schemaName
+    const tableCasing = table === undefined ? state.casing : casingForTable(table, state)
+    const renderedSchemaName = table === undefined ? schemaName : casedSchemaName(table, state)
+    const renderedIndexName = Casing.applyCategory(tableCasing, "indexes", name)
+    const indexName = schemaName === undefined || schemaName === "public"
+      ? dialect.quoteIdentifier(renderedIndexName)
+      : `${dialect.quoteIdentifier(renderedSchemaName ?? schemaName)}.${dialect.quoteIdentifier(renderedIndexName)}`
+    return `drop index${ifExists ? " if exists" : ""} ${indexName}`
+  }
+  const table = targetSource.source as Table.AnyTable
+  const tableCasing = casingForTable(table, state)
+  return `drop index ${dialect.quoteIdentifier(Casing.applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`
+}
 
 const isExpression = (value: unknown): value is Expression.Any =>
   value !== null && typeof value === "object" && Expression.TypeId in value
 
-const isJsonDbType = (dbType: Expression.DbType.Any): boolean =>
-  dbType.kind === "jsonb" || dbType.kind === "json" || ("variant" in dbType && dbType.variant === "json")
+const isJsonDbType = (dbType: Expression.DbType.Any): boolean => {
+  if (dbType.kind === "jsonb" || dbType.kind === "json") {
+    return true
+  }
+  if (!("variant" in dbType)) {
+    return false
+  }
+  const variant = dbType.variant as string
+  return variant === "json" || variant === "jsonb"
+}
 
 const isJsonExpression = (value: unknown): value is Expression.Any =>
   isExpression(value) && isJsonDbType(value[Expression.TypeId].dbType)
 
+const expectValueExpression = (
+  _functionName: string,
+  value: unknown
+): Expression.Any => value as Expression.Any
+
+const expectBinaryExpressions = (
+  _functionName: string,
+  left: unknown,
+  right: unknown
+): readonly [Expression.Any, Expression.Any] => [left as Expression.Any, right as Expression.Any]
+
+const renderBinaryExpression = (
+  functionName: string,
+  operator: string,
+  left: unknown,
+  right: unknown,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right)
+  return `(${renderExpression(leftExpression, state, dialect)} ${operator} ${renderExpression(rightExpression, state, dialect)})`
+}
+
+const postgresRangeSubtypeByKind: Readonly<Record<string, string>> = {
+  int4range: "int4",
+  int8range: "int8",
+  numrange: "numeric",
+  tsrange: "timestamp",
+  tstzrange: "timestamptz",
+  daterange: "date",
+  int4multirange: "int4",
+  int8multirange: "int8",
+  nummultirange: "numeric",
+  tsmultirange: "timestamp",
+  tstzmultirange: "timestamptz",
+  datemultirange: "date"
+}
+
+const postgresRangeSubtypeKey = (dbType: Expression.DbType.Any): string | undefined => {
+  if ("base" in dbType) {
+    return postgresRangeSubtypeKey(dbType.base)
+  }
+  if ("subtype" in dbType) {
+    return postgresRangeSubtypeKey(dbType.subtype) ?? dbType.subtype.kind
+  }
+  return postgresRangeSubtypeByKind[dbType.kind]
+}
+
+const assertCompatiblePostgresRangeOperands = (
+  left: Expression.Any,
+  right: Expression.Any
+): void => {
+  const leftKey = postgresRangeSubtypeKey(left[Expression.TypeId].dbType)
+  const rightKey = postgresRangeSubtypeKey(right[Expression.TypeId].dbType)
+  if (leftKey !== undefined && rightKey !== undefined && leftKey !== rightKey) {
+    throw new Error("Incompatible postgres range operands")
+  }
+}
+
 const unsupportedJsonFeature = (
   dialect: SqlDialect,
   feature: string
@@ -173,13 +515,57 @@ const extractJsonBase = (node: Record<string, unknown>): unknown =>
 const isJsonPathValue = (value: unknown): value is JsonPath.Path<any> =>
   value !== null && typeof value === "object" && JsonPath.TypeId in value
 
+const isOptionalJsonPathNumber = (value: unknown): boolean =>
+  value === undefined || (typeof value === "number" && Number.isFinite(value))
+
+const isJsonPathSegment = (segment: unknown): boolean => {
+  if (typeof segment === "string") {
+    return true
+  }
+  if (typeof segment === "number") {
+    return Number.isFinite(segment)
+  }
+  if (segment === null || typeof segment !== "object" || !("kind" in segment)) {
+    return false
+  }
+  switch ((segment as { readonly kind?: unknown }).kind) {
+    case "key":
+      return typeof (segment as { readonly key?: unknown }).key === "string"
+    case "index": {
+      const index = (segment as { readonly index?: unknown }).index
+      return typeof index === "number" && Number.isFinite(index)
+    }
+    case "wildcard":
+    case "descend":
+      return true
+    case "slice":
+      return isOptionalJsonPathNumber((segment as { readonly start?: unknown }).start) &&
+        isOptionalJsonPathNumber((segment as { readonly end?: unknown }).end)
+    default:
+      return false
+  }
+}
+
+const validateJsonPathSegments = (segments: unknown): ReadonlyArray<JsonPath.AnySegment> => {
+  if (!Array.isArray(segments)) {
+    throw new Error("JSON path expressions require a segment array")
+  }
+  if (segments.some((segment) => !isJsonPathSegment(segment))) {
+    throw new Error("JSON path segments require string, number, or path segment objects")
+  }
+  return segments as ReadonlyArray<JsonPath.AnySegment>
+}
+
 const extractJsonPathSegments = (node: Record<string, unknown>): ReadonlyArray<JsonPath.AnySegment> => {
   const path = node.path ?? node.segments ?? node.keys
   if (isJsonPathValue(path)) {
-    return path.segments
+    return validateJsonPathSegments(path.segments)
   }
   if (Array.isArray(path)) {
-    return path as readonly JsonPath.AnySegment[]
+    return validateJsonPathSegments(path)
+  }
+  if (node.segments !== undefined) {
+    return validateJsonPathSegments(node.segments)
   }
   if ("key" in node) {
     return [JsonPath.key(String(node.key))]
@@ -198,28 +584,40 @@ const extractJsonPathSegments = (node: Record<string, unknown>): ReadonlyArray<J
     return []
   }
   if ("right" in node && isJsonPathValue(node.right)) {
-    return node.right.segments
+    return validateJsonPathSegments(node.right.segments)
   }
   return []
 }
 
+const extractJsonKeys = (
+  node: Record<string, unknown>,
+  segments: ReadonlyArray<JsonPath.AnySegment>
+): readonly unknown[] =>
+  Array.isArray(node.keys)
+    ? node.keys
+    : segments.map((segment) =>
+        typeof segment === "object" && segment !== null && segment.kind === "key"
+          ? segment.key
+          : segment
+      )
+
 const extractJsonValue = (node: Record<string, unknown>): unknown =>
   node.newValue ?? node.insert ?? node.right
 
 const renderJsonPathSegment = (segment: JsonPath.AnySegment | string | number): string => {
+  const renderKey = (value: string): string =>
+    /^[A-Za-z_][A-Za-z0-9_]*$/.test(value)
+      ? `.${value}`
+      : `.${JSON.stringify(value)}`
   if (typeof segment === "string") {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)
-      ? `.${segment}`
-      : `."${segment.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+    return renderKey(segment)
   }
   if (typeof segment === "number") {
     return `[${segment}]`
   }
   switch (segment.kind) {
     case "key":
-      return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment.key)
-        ? `.${segment.key}`
-        : `."${segment.key.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+      return renderKey(segment.key)
     case "index":
       return `[${segment.index}]`
     case "wildcard":
@@ -284,7 +682,7 @@ const renderPostgresJsonAccessStep = (
     case "key":
       return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.key, state)}`
     case "index":
-      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(String(segment.index), state)}`
+      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.index, state)}`
     default:
       throw new Error("Postgres exact JSON access requires key/index segments")
   }
@@ -338,14 +736,26 @@ const encodeArrayValues = (
   state: RenderState,
   dialect: SqlDialect
 ): readonly unknown[] =>
-  values.map((value) =>
-    toDriverValue(value, {
+  values.map((value) => {
+    if (value === null && column.metadata.nullable) {
+      return null
+    }
+    const runtimeSchemaAccepts = column.schema !== undefined &&
+      (Schema.is(column.schema) as (candidate: unknown) => boolean)(value)
+    const normalizedValue = runtimeSchemaAccepts
+      ? value
+      : normalizeDbValue(column.metadata.dbType, value)
+    const encodedValue = column.schema === undefined || runtimeSchemaAccepts
+      ? normalizedValue
+      : (Schema.decodeUnknownSync as any)(column.schema)(normalizedValue)
+    return toDriverValue(encodedValue, {
       dialect: dialect.name,
       valueMappings: state.valueMappings,
       dbType: column.metadata.dbType,
       runtimeSchema: column.schema,
       driverValueMapping: column.metadata.driverValueMapping
-    }))
+    })
+  })
 
 const renderPostgresJsonKind = (
   value: Expression.Any
@@ -360,52 +770,64 @@ const renderJsonOpaquePath = (
     return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments), state)
   }
   if (typeof value === "string") {
+    if (value.trim().length === 0) {
+      throw new Error("SQL/JSON path input must be a non-empty string")
+    }
     return dialect.renderLiteral(value, state)
   }
   if (isExpression(value)) {
+    const ast = (value as Expression.Any & {
+      readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+    })[ExpressionAst.TypeId]
+    if (ast.kind === "literal" && typeof ast.value === "string" && ast.value.trim().length === 0) {
+      throw new Error("SQL/JSON path input must be a non-empty string")
+    }
     return renderExpression(value, state, dialect)
   }
   throw new Error("Unsupported SQL/JSON path input")
 }
 
+const renderFunctionName = (name: unknown): string => {
+  return name as string
+}
+
+const renderExtractField = (field: Expression.Any): string => {
+  const ast = (field as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId] as ExpressionAst.LiteralNode<string>
+  return ast.value
+}
+
 const renderFunctionCall = (
-  name: string,
-  args: readonly Expression.Any[],
+  name: unknown,
+  args: unknown,
   state: RenderState,
   dialect: SqlDialect
 ): string => {
-  if (name === "array") {
-    return `ARRAY[${args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}]`
-  }
-  if (name === "extract" && args.length === 2) {
-    const field = args[0]
-    const source = args[1]
-    if (field === undefined) {
-      throw new Error("Unsupported SQL extract expression")
-    }
-    if (source === undefined) {
-      throw new Error("Unsupported SQL extract expression")
-    }
-    const fieldRuntime = isExpression(field) && field[Expression.TypeId].dbType.kind === "text" && typeof field[Expression.TypeId].runtime === "string"
-      ? field[Expression.TypeId].runtime
-      : undefined
-    const renderedField = fieldRuntime ?? renderExpression(field, state, dialect)
-    return `extract(${renderedField} from ${renderExpression(source, state, dialect)})`
+  const functionName = renderFunctionName(name)
+  const functionArgs = args as readonly Expression.Any[]
+  if (functionName === "array") {
+    return `ARRAY[${functionArgs.map((arg) => renderExpression(arg, state, dialect)).join(", ")}]`
+  }
+  if (functionName === "extract") {
+    const field = functionArgs[0]!
+    const source = functionArgs[1]!
+    return `extract(${renderExtractField(field)} from ${renderExpression(source, state, dialect)})`
   }
-  const renderedArgs = args.map((arg) => renderExpression(arg, state, dialect)).join(", ")
-  if (args.length === 0) {
-    switch (name) {
+  const renderedArgs = functionArgs.map((arg) => renderExpression(arg, state, dialect)).join(", ")
+  if (functionArgs.length === 0) {
+    switch (functionName) {
       case "current_date":
       case "current_time":
       case "current_timestamp":
       case "localtime":
       case "localtimestamp":
-        return name
+        return functionName
       default:
-        return `${name}()`
+        return `${functionName}()`
     }
   }
-  return `${name}(${renderedArgs})`
+  return `${functionName}(${renderedArgs})`
 }
 
 const renderJsonExpression = (
@@ -469,22 +891,26 @@ const renderJsonExpression = (
       const baseSql = dialect.name === "postgres"
         ? renderPostgresJsonValue(base, state, dialect)
         : renderExpression(base, state, dialect)
-      const keys = segments
+      const keys = extractJsonKeys(ast, segments)
       if (keys.length === 0) {
         return undefined
       }
+      if (keys.some((key) => typeof key !== "string" || key.length === 0)) {
+        throw new Error("json key predicates require string keys")
+      }
+      const keyNames = keys as readonly string[]
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
+          return `(${baseSql} ?| array[${keyNames.map((key) => renderPostgresTextLiteral(key, state, dialect)).join(", ")}])`
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
+          return `(${baseSql} ?& array[${keyNames.map((key) => renderPostgresTextLiteral(key, state, dialect)).join(", ")}])`
         }
-        return `(${baseSql} ? ${renderPostgresTextLiteral(String(keys[0]!), state, dialect)})`
+        return `(${baseSql} ? ${renderPostgresTextLiteral(keyNames[0]!, state, dialect)})`
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one"
-        const paths = keys.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")
+        const paths = keyNames.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")
         return `json_contains_path(${baseSql}, ${dialect.renderLiteral(mode, state)}, ${paths})`
       }
       return undefined
@@ -503,9 +929,7 @@ const renderJsonExpression = (
       return undefined
     }
     case "jsonBuildObject": {
-      const entries = Array.isArray((ast as { readonly entries?: readonly { readonly key: string; readonly value: Expression.Any }[] }).entries)
-        ? (ast as { readonly entries: readonly { readonly key: string; readonly value: Expression.Any }[] }).entries
-        : []
+      const entries = (ast as { readonly entries: readonly { readonly key: string; readonly value: Expression.Any }[] }).entries
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
         renderJsonInputExpression(entry.value, state, dialect)
@@ -519,9 +943,7 @@ const renderJsonExpression = (
       return undefined
     }
     case "jsonBuildArray": {
-      const values = Array.isArray((ast as { readonly values?: readonly Expression.Any[] }).values)
-        ? (ast as { readonly values: readonly Expression.Any[] }).values
-        : []
+      const values = (ast as { readonly values: readonly Expression.Any[] }).values
       const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ")
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`
@@ -588,7 +1010,7 @@ const renderJsonExpression = (
         const baseSql = renderExpression(base, state, dialect)
         const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`
         const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`
-        return `(case when ${typeOf}(${baseSql}) = 'object' then array(select ${objectKeys}(${baseSql})) else null end)`
+        return `(case when ${typeOf}(${baseSql}) = 'object' then to_json(array(select ${objectKeys}(${baseSql}))) else null end)`
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression(base, state, dialect)})`
@@ -615,7 +1037,7 @@ const renderJsonExpression = (
           const segment = segments[0]!
           return `(${baseSql} - ${segment.kind === "key"
             ? dialect.renderLiteral(segment.key, state)
-            : dialect.renderLiteral(String(segment.index), state)})`
+            : dialect.renderLiteral(segment.index, state)})`
         }
         return `(${baseSql} #- ${renderPostgresJsonPathArray(segments, state, dialect)})`
       }
@@ -699,11 +1121,12 @@ const selectionProjections = (selection: Record<string, unknown>): readonly Proj
 const renderMutationAssignment = (
   entry: QueryAst.AssignmentClause,
   state: RenderState,
-  dialect: SqlDialect
+  dialect: SqlDialect,
+  targetTableName?: string
 ): string => {
   const column = entry.tableName && dialect.name === "mysql"
-    ? `${dialect.quoteIdentifier(entry.tableName)}.${dialect.quoteIdentifier(entry.columnName)}`
-    : dialect.quoteIdentifier(entry.columnName)
+    ? `${dialect.quoteIdentifier(casedTableReferenceName(entry.tableName, state))}.${quoteColumn(entry.columnName, state, dialect, entry.tableName)}`
+    : quoteColumn(entry.columnName, state, dialect, targetTableName)
   return `${column} = ${renderExpression(entry.value, state, dialect)}`
 }
 
@@ -765,10 +1188,11 @@ const renderTransactionClause = (
   switch (clause.kind) {
     case "transaction": {
       const modes: string[] = []
-      if (clause.isolationLevel) {
-        modes.push(`isolation level ${clause.isolationLevel}`)
+      const isolationLevel = renderTransactionIsolationLevel(clause.isolationLevel)
+      if (isolationLevel) {
+        modes.push(isolationLevel)
       }
-      if (clause.readOnly === true) {
+      if (normalizeStatementFlag(clause.readOnly)) {
         modes.push("read only")
       }
       return modes.length > 0
@@ -780,24 +1204,20 @@ const renderTransactionClause = (
     case "rollback":
       return "rollback"
     case "savepoint":
-      return `savepoint ${dialect.quoteIdentifier(clause.name)}`
+      return `savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("savepoint", "name", clause.name))}`
     case "rollbackTo":
-      return `rollback to savepoint ${dialect.quoteIdentifier(clause.name)}`
+      return `rollback to savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("rollbackTo", "name", clause.name))}`
     case "releaseSavepoint":
-      return `release savepoint ${dialect.quoteIdentifier(clause.name)}`
+      return `release savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("releaseSavepoint", "name", clause.name))}`
   }
-  return ""
+  return "start transaction"
 }
 
 const renderSelectionList = (
   selection: Record<string, unknown>,
   state: RenderState,
-  dialect: SqlDialect,
-  validateAggregation: boolean
+  dialect: SqlDialect
 ): RenderedQueryAst => {
-  if (validateAggregation) {
-    validateAggregationSelection(selection as SelectionValue, [])
-  }
   const flattened = flattenSelection(selection)
   const projections = selectionProjections(selection)
   const sql = flattened.map(({ expression, alias }) =>
@@ -808,28 +1228,74 @@ const renderSelectionList = (
   }
 }
 
+const nestedRenderState = (state: RenderState): RenderState => ({
+  params: state.params,
+  valueMappings: state.valueMappings,
+  casing: state.casing,
+  ctes: [],
+  cteNames: new Set(state.cteNames),
+  cteSources: new Map(state.cteSources),
+  sourceNames: new Map(state.sourceNames)
+})
+
+const assertSupportedMutationReturning = (
+  dialect: SqlDialect,
+  selection: Record<string, unknown>
+): void => {
+  if (dialect.name === "standard" && Object.keys(selection).length > 0) {
+    throw new Error("Unsupported standard returning")
+  }
+}
+
+const validateDistinctOnOrdering = (
+  distinctOn: readonly Expression.Any[] | undefined,
+  orderBy: readonly QueryAst.OrderByClause[]
+): void => {
+  if (distinctOn === undefined || distinctOn.length === 0 || orderBy.length === 0) {
+    return
+  }
+  const remainingDistinctKeys = new Set(distinctOn.map(groupingKeyOfExpression))
+  for (const order of orderBy) {
+    const key = groupingKeyOfExpression(order.value)
+    if (remainingDistinctKeys.has(key)) {
+      remainingDistinctKeys.delete(key)
+      continue
+    }
+    if (remainingDistinctKeys.size > 0) {
+      throw new Error("distinctOn(...) expressions must match the leftmost orderBy(...) expressions")
+    }
+    return
+  }
+}
+
 export const renderQueryAst = (
   ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
   state: RenderState,
-  dialect: SqlDialect
+  dialect: SqlDialect,
+  options: { readonly emitCtes?: boolean } = {}
 ): RenderedQueryAst => {
+  registerQuerySources(ast, state)
   let sql = ""
   let projections: readonly Projection[] = []
 
   switch (ast.kind) {
     case "select": {
-      validateAggregationSelection(ast.select as SelectionValue, ast.groupBy)
-      const rendered = renderSelectionList(ast.select as Record<string, unknown>, state, dialect, false)
+      validateDistinctOnOrdering(ast.distinctOn, ast.orderBy)
+      const rendered = renderSelectionList(ast.select as Record<string, unknown>, state, dialect)
       projections = rendered.projections
+      const selectList = rendered.sql.length > 0 ? ` ${rendered.sql}` : ""
       const clauses = [
         ast.distinctOn && ast.distinctOn.length > 0
-          ? `select distinct on (${ast.distinctOn.map((value) => renderExpression(value, state, dialect)).join(", ")}) ${rendered.sql}`
-          : `select${ast.distinct ? " distinct" : ""} ${rendered.sql}`
+          ? `select distinct on (${ast.distinctOn.map((value) => renderExpression(value, state, dialect)).join(", ")})${selectList}`
+          : `select${ast.distinct ? " distinct" : ""}${selectList}`
       ]
       if (ast.from) {
         clauses.push(`from ${renderSourceReference(ast.from.source, ast.from.tableName, ast.from.baseTableName, state, dialect)}`)
       }
       for (const join of ast.joins) {
+        if (dialect.name === "standard" && join.kind === "full") {
+          throw new Error("Unsupported standard full join")
+        }
         const source = renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)
         clauses.push(
           join.kind === "cross"
@@ -856,8 +1322,11 @@ export const renderQueryAst = (
         clauses.push(`offset ${renderExpression(ast.offset, state, dialect)}`)
       }
       if (ast.lock) {
+        if (dialect.name === "standard") {
+          throw new Error("Unsupported standard row locking")
+        }
         clauses.push(
-          `${ast.lock.mode === "update" ? "for update" : "for share"}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`
+          `${renderSelectLockMode(ast.lock.mode)}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`
         )
       }
       sql = clauses.join(" ")
@@ -887,6 +1356,9 @@ export const renderQueryAst = (
             state,
             dialect
           )
+          if (dialect.name === "standard" && entry.all && entry.kind !== "union") {
+            throw new Error("Unsupported standard set operator all variant")
+          }
           return `${entry.kind}${entry.all ? " all" : ""} (${rendered.sql})`
         })
       ].join(" ")
@@ -896,17 +1368,20 @@ export const renderQueryAst = (
       const insertAst = ast as QueryAst.Ast<Record<string, unknown>, any, "insert">
       const targetSource = insertAst.into!
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
+      const targetCasingState = stateWithTableCasing(state, targetSource.source)
+      const insertSource = insertAst.insertSource
+      const conflict = expectConflictClause(insertAst.conflict)
       sql = `insert into ${target}`
-      if (insertAst.insertSource?.kind === "values") {
-        const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
-        const rows = insertAst.insertSource.rows.map((row) =>
-          `(${row.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`
+      if (insertSource?.kind === "values") {
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")
+        const rows = insertSource.rows.map((row) =>
+          `(${row.values.map((entry) => renderExpression(entry.value, targetCasingState, dialect)).join(", ")})`
         ).join(", ")
         sql += ` (${columns}) values ${rows}`
-      } else if (insertAst.insertSource?.kind === "query") {
-        const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
+      } else if (insertSource?.kind === "query") {
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")
         const renderedQuery = renderQueryAst(
-          Query.getAst(insertAst.insertSource.query as Query.Plan.Any) as QueryAst.Ast<
+          Query.getAst(insertSource.query as Query.Plan.Any) as QueryAst.Ast<
             Record<string, unknown>,
             any,
             QueryAst.QueryStatement
@@ -915,20 +1390,19 @@ export const renderQueryAst = (
           dialect
         )
         sql += ` (${columns}) ${renderedQuery.sql}`
-      } else if (insertAst.insertSource?.kind === "unnest") {
-        const unnestSource = insertAst.insertSource
-        const columns = unnestSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
+      } else if (insertSource?.kind === "unnest") {
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")
         if (dialect.name === "postgres") {
           const table = targetSource.source as Table.AnyTable
           const fields = table[Table.TypeId].fields
-          const rendered = unnestSource.values.map((entry) =>
+          const rendered = insertSource.values.map((entry) =>
             `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName]!, state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName]!.metadata.dbType)}[])`
           ).join(", ")
           sql += ` (${columns}) select * from unnest(${rendered})`
         } else {
-          const rowCount = unnestSource.values[0]?.values.length ?? 0
+          const rowCount = insertSource.values[0]?.values.length ?? 0
           const rows = Array.from({ length: rowCount }, (_, index) =>
-            `(${unnestSource.values.map((entry) =>
+            `(${insertSource.values.map((entry) =>
               dialect.renderLiteral(
                 entry.values[index],
                 state,
@@ -939,35 +1413,41 @@ export const renderQueryAst = (
           sql += ` (${columns}) values ${rows}`
         }
       } else {
-        const columns = (insertAst.values ?? []).map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")
-        const values = (insertAst.values ?? []).map((entry) => renderExpression(entry.value, state, dialect)).join(", ")
-        if ((insertAst.values ?? []).length > 0) {
+        const insertValues = insertAst.values ?? []
+        const columns = insertValues.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ")
+        const values = insertValues.map((entry) => renderExpression(entry.value, targetCasingState, dialect)).join(", ")
+        if (insertValues.length > 0) {
           sql += ` (${columns}) values (${values})`
         } else {
           sql += " default values"
         }
       }
-      if (insertAst.conflict) {
-        const updateValues = (insertAst.conflict.values ?? []).map((entry) =>
-          `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`
+      if (conflict) {
+        if (dialect.name === "standard") {
+          throw new Error("Unsupported standard insert conflict")
+        }
+        const conflictValueState = { ...targetCasingState, allowExcluded: true }
+        const updateValues = (conflict.values ?? []).map((entry) =>
+          `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression(entry.value, conflictValueState, dialect)}`
         ).join(", ")
         if (dialect.name === "postgres") {
-          const targetSql = insertAst.conflict.target?.kind === "constraint"
-            ? ` on conflict on constraint ${dialect.quoteIdentifier(insertAst.conflict.target.name)}`
-            : insertAst.conflict.target?.kind === "columns"
-              ? ` on conflict (${insertAst.conflict.target.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${insertAst.conflict.target.where ? ` where ${renderExpression(insertAst.conflict.target.where, state, dialect)}` : ""}`
+          const targetSql = conflict.target?.kind === "constraint"
+            ? ` on conflict on constraint ${dialect.quoteIdentifier(Casing.applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}`
+            : conflict.target?.kind === "columns"
+              ? ` on conflict (${conflict.target.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, targetCasingState, dialect)}` : ""}`
               : " on conflict"
           sql += targetSql
-          sql += insertAst.conflict.action === "doNothing"
+          sql += conflict.action === "doNothing"
             ? " do nothing"
-            : ` do update set ${updateValues}${insertAst.conflict.where ? ` where ${renderExpression(insertAst.conflict.where, state, dialect)}` : ""}`
-        } else if (insertAst.conflict.action === "doNothing") {
+            : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression(conflict.where, conflictValueState, dialect)}` : ""}`
+        } else if (conflict.action === "doNothing") {
           sql = sql.replace(/^insert/, "insert ignore")
         } else {
           sql += ` on duplicate key update ${updateValues}`
         }
       }
-      const returning = renderSelectionList(insertAst.select as Record<string, unknown>, state, dialect, false)
+      assertSupportedMutationReturning(dialect, insertAst.select as Record<string, unknown>)
+      const returning = renderSelectionList(insertAst.select as Record<string, unknown>, state, dialect)
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -980,8 +1460,11 @@ export const renderQueryAst = (
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
       const targets = updateAst.targets ?? [targetSource]
       const fromSources = updateAst.fromSources ?? []
+      if (dialect.name === "standard" && (targets.length > 1 || fromSources.length > 0 || updateAst.joins.length > 0)) {
+        throw new Error("Unsupported standard joined mutation")
+      }
       const assignments = updateAst.set!.map((entry) =>
-        renderMutationAssignment(entry, state, dialect)).join(", ")
+        renderMutationAssignment(entry, state, dialect, targetSource.tableName)).join(", ")
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(updateAst.lock, "update")
         const extraSources = renderFromSources(fromSources, state, dialect)
@@ -1020,7 +1503,8 @@ export const renderQueryAst = (
       if (dialect.name === "mysql" && updateAst.limit) {
         sql += ` limit ${renderExpression(updateAst.limit, state, dialect)}`
       }
-      const returning = renderSelectionList(updateAst.select as Record<string, unknown>, state, dialect, false)
+      assertSupportedMutationReturning(dialect, updateAst.select as Record<string, unknown>)
+      const returning = renderSelectionList(updateAst.select as Record<string, unknown>, state, dialect)
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -1032,6 +1516,9 @@ export const renderQueryAst = (
       const targetSource = deleteAst.target!
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
       const targets = deleteAst.targets ?? [targetSource]
+      if (dialect.name === "standard" && (targets.length > 1 || deleteAst.joins.length > 0)) {
+        throw new Error("Unsupported standard joined mutation")
+      }
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(deleteAst.lock, "delete")
         const hasJoinedSources = deleteAst.joins.length > 0 || targets.length > 1
@@ -1066,7 +1553,8 @@ export const renderQueryAst = (
       if (dialect.name === "mysql" && deleteAst.limit) {
         sql += ` limit ${renderExpression(deleteAst.limit, state, dialect)}`
       }
-      const returning = renderSelectionList(deleteAst.select as Record<string, unknown>, state, dialect, false)
+      assertSupportedMutationReturning(dialect, deleteAst.select as Record<string, unknown>)
+      const returning = renderSelectionList(deleteAst.select as Record<string, unknown>, state, dialect)
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -1075,12 +1563,18 @@ export const renderQueryAst = (
     }
     case "truncate": {
       const truncateAst = ast as QueryAst.Ast<Record<string, unknown>, any, "truncate">
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard truncate statement")
+      }
+      const truncate = expectTruncateClause(truncateAst.truncate)
       const targetSource = truncateAst.target!
+      const restartIdentity = truncate.restartIdentity
+      const cascade = truncate.cascade
       sql = `truncate table ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`
-      if (truncateAst.truncate?.restartIdentity) {
+      if (restartIdentity) {
         sql += " restart identity"
       }
-      if (truncateAst.truncate?.cascade) {
+      if (cascade) {
         sql += " cascade"
       }
       break
@@ -1095,15 +1589,17 @@ export const renderQueryAst = (
       const merge = mergeAst.merge!
       sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge.on, state, dialect)}`
       if (merge.whenMatched) {
+        const matchedKind = merge.whenMatched.kind === "delete" ? "delete" : "update"
         sql += " when matched"
         if (merge.whenMatched.predicate) {
           sql += ` and ${renderExpression(merge.whenMatched.predicate, state, dialect)}`
         }
-        if (merge.whenMatched.kind === "delete") {
+        if (matchedKind === "delete") {
           sql += " then delete"
         } else {
-          sql += ` then update set ${merge.whenMatched.values.map((entry) =>
-            `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`
+          const matchedUpdate = merge.whenMatched as Extract<QueryAst.MergeMatchedClause, { readonly kind: "update" }>
+          sql += ` then update set ${matchedUpdate.values.map((entry) =>
+            `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression(entry.value, state, dialect)}`
           ).join(", ")}`
         }
       }
@@ -1112,7 +1608,7 @@ export const renderQueryAst = (
         if (merge.whenNotMatched.predicate) {
           sql += ` and ${renderExpression(merge.whenNotMatched.predicate, state, dialect)}`
         }
-        sql += ` then insert (${merge.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`
+        sql += ` then insert (${merge.whenNotMatched.values.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`
       }
       break
     }
@@ -1127,12 +1623,17 @@ export const renderQueryAst = (
     }
     case "createTable": {
       const createTableAst = ast as QueryAst.Ast<Record<string, unknown>, any, "createTable">
-      sql = renderCreateTableSql(createTableAst.target!, state, dialect, createTableAst.ddl?.kind === "createTable" && createTableAst.ddl.ifNotExists)
+      const ddl = expectDdlClauseKind(createTableAst.ddl, "createTable")
+      sql = renderCreateTableSql(createTableAst.target!, state, dialect, ddl.ifNotExists)
       break
     }
     case "dropTable": {
       const dropTableAst = ast as QueryAst.Ast<Record<string, unknown>, any, "dropTable">
-      const ifExists = dropTableAst.ddl?.kind === "dropTable" && dropTableAst.ddl.ifExists
+      const ddl = expectDdlClauseKind(dropTableAst.ddl, "dropTable")
+      const ifExists = normalizeStatementFlag(ddl.ifExists)
+      if (dialect.name !== "postgres" && ifExists) {
+        throw new Error(`Unsupported ${dialect.name} drop table options`)
+      }
       sql = `drop table${ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target!.source, dropTableAst.target!.tableName, dropTableAst.target!.baseTableName, state, dialect)}`
       break
     }
@@ -1140,7 +1641,7 @@ export const renderQueryAst = (
       const createIndexAst = ast as QueryAst.Ast<Record<string, unknown>, any, "createIndex">
       sql = renderCreateIndexSql(
         createIndexAst.target!,
-        createIndexAst.ddl as Extract<QueryAst.DdlClause, { readonly kind: "createIndex" }>,
+        expectDdlClauseKind(createIndexAst.ddl, "createIndex"),
         state,
         dialect
       )
@@ -1150,15 +1651,21 @@ export const renderQueryAst = (
       const dropIndexAst = ast as QueryAst.Ast<Record<string, unknown>, any, "dropIndex">
       sql = renderDropIndexSql(
         dropIndexAst.target!,
-        dropIndexAst.ddl as Extract<QueryAst.DdlClause, { readonly kind: "dropIndex" }>,
+        expectDdlClauseKind(dropIndexAst.ddl, "dropIndex"),
         state,
         dialect
       )
       break
     }
+    default: {
+      if (ast.transaction !== undefined) {
+        sql = renderTransactionClause(ast.transaction, dialect)
+      }
+      break
+    }
   }
 
-  if (state.ctes.length === 0) {
+  if (state.ctes.length === 0 || options.emitCtes === false) {
     return {
       sql,
       projections
@@ -1206,9 +1713,19 @@ const renderSourceReference = (
       readonly plan: Query.Plan.Any
       readonly recursive?: boolean
     }
+    const registeredCteSource = state.cteSources.get(cte.name)
+    if (registeredCteSource !== undefined && registeredCteSource !== cte.plan) {
+      throw new Error(`common table expression name is already registered with a different plan: ${cte.name}`)
+    }
     if (!state.cteNames.has(cte.name)) {
       state.cteNames.add(cte.name)
-      const rendered = renderQueryAst(Query.getAst(cte.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, state, dialect)
+      state.cteSources.set(cte.name, cte.plan)
+      const rendered = renderQueryAst(
+        Query.getAst(cte.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+        state,
+        dialect,
+        { emitCtes: false }
+      )
       state.ctes.push({
         name: cte.name,
         sql: rendered.sql,
@@ -1225,14 +1742,17 @@ const renderSourceReference = (
     if (!state.cteNames.has(derived.name)) {
       // derived tables are inlined, so no CTE registration is needed
     }
-    return `(${renderQueryAst(Query.getAst(derived.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, state, dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`
+    return `(${renderQueryAst(Query.getAst(derived.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`
   }
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "lateral") {
     const lateral = source as unknown as {
       readonly name: string
       readonly plan: Query.Plan.Any
     }
-    return `lateral (${renderQueryAst(Query.getAst(lateral.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, state, dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`
+    if (dialect.name === "standard") {
+      throw new Error("Unsupported standard lateral source")
+    }
+    return `lateral (${renderQueryAst(Query.getAst(lateral.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`
   }
   if (typeof source === "object" && source !== null && (source as { readonly kind?: string }).kind === "values") {
     const values = source as unknown as {
@@ -1258,13 +1778,42 @@ const renderSourceReference = (
     if (dialect.name !== "postgres") {
       throw new Error("Unsupported table function source for SQL rendering")
     }
+    const functionName = renderFunctionName(tableFunction.functionName)
     const columnNames = Object.keys(tableFunction.columns)
-    return `${tableFunction.functionName}(${tableFunction.args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}) as ${dialect.quoteIdentifier(tableFunction.name)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`
+    return `${functionName}(${tableFunction.args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}) as ${dialect.quoteIdentifier(tableFunction.name)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`
   }
   const schemaName = typeof source === "object" && source !== null && Table.TypeId in source
-    ? (source as Table.AnyTable)[Table.TypeId].schemaName
+    ? casedSchemaName(source as Table.AnyTable, state)
     : undefined
-  return dialect.renderTableReference(tableName, baseTableName, schemaName)
+  if (typeof source === "object" && source !== null && Table.TypeId in source) {
+    const table = source as Table.AnyTable
+    const renderedBaseName = casedTableName(table, state)
+    const renderedTableName = table[Table.TypeId].kind === "alias"
+      ? tableName
+      : renderedBaseName
+    return dialect.renderTableReference(renderedTableName, renderedBaseName, schemaName)
+  }
+  return dialect.renderTableReference(
+    Casing.applyCategory(state.casing, "tables", tableName),
+    Casing.applyCategory(state.casing, "tables", baseTableName),
+    schemaName
+  )
+}
+
+const renderSubqueryExpressionPlan = (
+  plan: Query.Plan.Any,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  const statement = Query.getQueryState(plan).statement
+  if (statement !== "select" && statement !== "set") {
+    throw new Error("subquery expressions only accept select-like query plans")
+  }
+  return renderQueryAst(
+    Query.getAst(plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+    state,
+    dialect
+  ).sql
 }
 
 /**
@@ -1287,135 +1836,176 @@ export const renderExpression = (
     return jsonSql
   }
   const ast = rawAst as ExpressionAst.Any
-  const renderComparisonOperator = (operator: "eq" | "neq" | "lt" | "lte" | "gt" | "gte"): "=" | "<>" | "<" | "<=" | ">" | ">=" =>
-    operator === "eq"
-      ? "="
-      : operator === "neq"
-        ? "<>"
-        : operator === "lt"
-          ? "<"
-          : operator === "lte"
-            ? "<="
-            : operator === "gt"
-              ? ">"
-              : ">="
-    switch (ast.kind) {
+  const renderComparisonOperator = (operator: unknown): "=" | "<>" | "<" | "<=" | ">" | ">=" =>
+    ({
+      eq: "=",
+      neq: "<>",
+      lt: "<",
+      lte: "<=",
+      gt: ">",
+      gte: ">="
+    } as const)[operator as "eq" | "neq" | "lt" | "lte" | "gt" | "gte"]!
+  const renderCollation = (collation: unknown): string => {
+    return (collation as readonly string[]).map((segment) => dialect.quoteIdentifier(segment)).join(".")
+  }
+  switch (ast.kind) {
     case "column":
-      return ast.tableName.length === 0
-        ? dialect.quoteIdentifier(ast.columnName)
-        : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
+      return state.rowLocalColumns || ast.tableName.length === 0
+        ? quoteColumn(ast.columnName, state, dialect, ast.tableName)
+        : `${dialect.quoteIdentifier(casedTableReferenceName(ast.tableName, state))}.${quoteColumn(ast.columnName, state, dialect, ast.tableName)}`
     case "literal":
+      if (typeof ast.value === "number" && !Number.isFinite(ast.value)) {
+        throw new Error("Expected a finite numeric value")
+      }
       return dialect.renderLiteral(ast.value, state, expression[Expression.TypeId])
     case "excluded":
+      if (state.allowExcluded !== true) {
+        throw new Error("excluded(...) is only supported inside insert conflict handlers")
+      }
       return dialect.name === "mysql"
-        ? `values(${dialect.quoteIdentifier(ast.columnName)})`
-        : `excluded.${dialect.quoteIdentifier(ast.columnName)}`
+        ? `values(${quoteColumn(ast.columnName, state, dialect)})`
+        : `excluded.${quoteColumn(ast.columnName, state, dialect)}`
     case "cast":
-      return `cast(${renderExpression(ast.value, state, dialect)} as ${renderCastType(dialect, ast.target)})`
+      return `cast(${renderExpression(expectValueExpression("cast", ast.value), state, dialect)} as ${renderCastType(dialect, ast.target)})`
     case "collate":
-      return `(${renderExpression(ast.value, state, dialect)} collate ${ast.collation.map((segment) => dialect.quoteIdentifier(segment)).join(".")})`
+      return `(${renderExpression(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`
     case "function":
-      return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect)
+      return renderFunctionCall(ast.name, ast.args, state, dialect)
     case "eq":
-      return `(${renderExpression(ast.left, state, dialect)} = ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect)
     case "neq":
-      return `(${renderExpression(ast.left, state, dialect)} <> ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("neq", "<>", ast.left, ast.right, state, dialect)
     case "lt":
-      return `(${renderExpression(ast.left, state, dialect)} < ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("lt", "<", ast.left, ast.right, state, dialect)
     case "lte":
-      return `(${renderExpression(ast.left, state, dialect)} <= ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("lte", "<=", ast.left, ast.right, state, dialect)
     case "gt":
-      return `(${renderExpression(ast.left, state, dialect)} > ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect)
     case "gte":
-      return `(${renderExpression(ast.left, state, dialect)} >= ${renderExpression(ast.right, state, dialect)})`
+      return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect)
     case "like":
-      return `(${renderExpression(ast.left, state, dialect)} like ${renderExpression(ast.right, state, dialect)})`
-    case "ilike":
+      return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect)
+    case "ilike": {
+      const [left, right] = expectBinaryExpressions("ilike", ast.left, ast.right)
       return dialect.name === "postgres"
-        ? `(${renderExpression(ast.left, state, dialect)} ilike ${renderExpression(ast.right, state, dialect)})`
-        : `(lower(${renderExpression(ast.left, state, dialect)}) like lower(${renderExpression(ast.right, state, dialect)}))`
-    case "regexMatch":
+        ? `(${renderExpression(left, state, dialect)} ilike ${renderExpression(right, state, dialect)})`
+        : `(lower(${renderExpression(left, state, dialect)}) like lower(${renderExpression(right, state, dialect)}))`
+    }
+    case "regexMatch": {
+      const [left, right] = expectBinaryExpressions("regexMatch", ast.left, ast.right)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates")
+      }
       return dialect.name === "postgres"
-        ? `(${renderExpression(ast.left, state, dialect)} ~ ${renderExpression(ast.right, state, dialect)})`
-        : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`
-    case "regexIMatch":
+        ? `(${renderExpression(left, state, dialect)} ~ ${renderExpression(right, state, dialect)})`
+        : `(${renderExpression(left, state, dialect)} regexp ${renderExpression(right, state, dialect)})`
+    }
+    case "regexIMatch": {
+      const [left, right] = expectBinaryExpressions("regexIMatch", ast.left, ast.right)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates")
+      }
       return dialect.name === "postgres"
-        ? `(${renderExpression(ast.left, state, dialect)} ~* ${renderExpression(ast.right, state, dialect)})`
-        : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`
-    case "regexNotMatch":
+        ? `(${renderExpression(left, state, dialect)} ~* ${renderExpression(right, state, dialect)})`
+        : `(${renderExpression(left, state, dialect)} regexp ${renderExpression(right, state, dialect)})`
+    }
+    case "regexNotMatch": {
+      const [left, right] = expectBinaryExpressions("regexNotMatch", ast.left, ast.right)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates")
+      }
       return dialect.name === "postgres"
-        ? `(${renderExpression(ast.left, state, dialect)} !~ ${renderExpression(ast.right, state, dialect)})`
-        : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`
-    case "regexNotIMatch":
+        ? `(${renderExpression(left, state, dialect)} !~ ${renderExpression(right, state, dialect)})`
+        : `(${renderExpression(left, state, dialect)} not regexp ${renderExpression(right, state, dialect)})`
+    }
+    case "regexNotIMatch": {
+      const [left, right] = expectBinaryExpressions("regexNotIMatch", ast.left, ast.right)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates")
+      }
       return dialect.name === "postgres"
-        ? `(${renderExpression(ast.left, state, dialect)} !~* ${renderExpression(ast.right, state, dialect)})`
-        : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`
-    case "isDistinctFrom":
+        ? `(${renderExpression(left, state, dialect)} !~* ${renderExpression(right, state, dialect)})`
+        : `(${renderExpression(left, state, dialect)} not regexp ${renderExpression(right, state, dialect)})`
+    }
+    case "isDistinctFrom": {
+      const [left, right] = expectBinaryExpressions("isDistinctFrom", ast.left, ast.right)
       return dialect.name === "mysql"
-        ? `(not (${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)}))`
-        : `(${renderExpression(ast.left, state, dialect)} is distinct from ${renderExpression(ast.right, state, dialect)})`
-    case "isNotDistinctFrom":
+        ? `(not (${renderExpression(left, state, dialect)} <=> ${renderExpression(right, state, dialect)}))`
+        : `(${renderExpression(left, state, dialect)} is distinct from ${renderExpression(right, state, dialect)})`
+    }
+    case "isNotDistinctFrom": {
+      const [left, right] = expectBinaryExpressions("isNotDistinctFrom", ast.left, ast.right)
       return dialect.name === "mysql"
-        ? `(${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)})`
-        : `(${renderExpression(ast.left, state, dialect)} is not distinct from ${renderExpression(ast.right, state, dialect)})`
-    case "contains":
+        ? `(${renderExpression(left, state, dialect)} <=> ${renderExpression(right, state, dialect)})`
+        : `(${renderExpression(left, state, dialect)} is not distinct from ${renderExpression(right, state, dialect)})`
+    }
+    case "contains": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("contains", ast.left, ast.right)
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(ast.left)
-          ? renderPostgresJsonValue(ast.left, state, dialect)
-          : renderExpression(ast.left, state, dialect)
-        const right = isJsonExpression(ast.right)
-          ? renderPostgresJsonValue(ast.right, state, dialect)
-          : renderExpression(ast.right, state, dialect)
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression)
+        const left = isJsonExpression(leftExpression)
+          ? renderPostgresJsonValue(leftExpression, state, dialect)
+          : renderExpression(leftExpression, state, dialect)
+        const right = isJsonExpression(rightExpression)
+          ? renderPostgresJsonValue(rightExpression, state, dialect)
+          : renderExpression(rightExpression, state, dialect)
         return `(${left} @> ${right})`
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_contains(${renderExpression(leftExpression, state, dialect)}, ${renderExpression(rightExpression, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
-    case "containedBy":
+    }
+    case "containedBy": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("containedBy", ast.left, ast.right)
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(ast.left)
-          ? renderPostgresJsonValue(ast.left, state, dialect)
-          : renderExpression(ast.left, state, dialect)
-        const right = isJsonExpression(ast.right)
-          ? renderPostgresJsonValue(ast.right, state, dialect)
-          : renderExpression(ast.right, state, dialect)
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression)
+        const left = isJsonExpression(leftExpression)
+          ? renderPostgresJsonValue(leftExpression, state, dialect)
+          : renderExpression(leftExpression, state, dialect)
+        const right = isJsonExpression(rightExpression)
+          ? renderPostgresJsonValue(rightExpression, state, dialect)
+          : renderExpression(rightExpression, state, dialect)
         return `(${left} <@ ${right})`
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.right, state, dialect)}, ${renderExpression(ast.left, state, dialect)})`
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_contains(${renderExpression(rightExpression, state, dialect)}, ${renderExpression(leftExpression, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
-    case "overlaps":
+    }
+    case "overlaps": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("overlaps", ast.left, ast.right)
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(ast.left)
-          ? renderPostgresJsonValue(ast.left, state, dialect)
-          : renderExpression(ast.left, state, dialect)
-        const right = isJsonExpression(ast.right)
-          ? renderPostgresJsonValue(ast.right, state, dialect)
-          : renderExpression(ast.right, state, dialect)
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression)
+        const left = isJsonExpression(leftExpression)
+          ? renderPostgresJsonValue(leftExpression, state, dialect)
+          : renderExpression(leftExpression, state, dialect)
+        const right = isJsonExpression(rightExpression)
+          ? renderPostgresJsonValue(rightExpression, state, dialect)
+          : renderExpression(rightExpression, state, dialect)
         return `(${left} && ${right})`
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_overlaps(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_overlaps(${renderExpression(leftExpression, state, dialect)}, ${renderExpression(rightExpression, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
+    }
     case "isNull":
-      return `(${renderExpression(ast.value, state, dialect)} is null)`
+      return `(${renderExpression(expectValueExpression("isNull", ast.value), state, dialect)} is null)`
     case "isNotNull":
-      return `(${renderExpression(ast.value, state, dialect)} is not null)`
+      return `(${renderExpression(expectValueExpression("isNotNull", ast.value), state, dialect)} is not null)`
     case "not":
-      return `(not ${renderExpression(ast.value, state, dialect)})`
+      return `(not ${renderExpression(expectValueExpression("not", ast.value), state, dialect)})`
     case "upper":
-      return `upper(${renderExpression(ast.value, state, dialect)})`
+      return `upper(${renderExpression(expectValueExpression("upper", ast.value), state, dialect)})`
     case "lower":
-      return `lower(${renderExpression(ast.value, state, dialect)})`
+      return `lower(${renderExpression(expectValueExpression("lower", ast.value), state, dialect)})`
     case "count":
-      return `count(${renderExpression(ast.value, state, dialect)})`
+      return `count(${renderExpression(expectValueExpression("count", ast.value), state, dialect)})`
     case "max":
-      return `max(${renderExpression(ast.value, state, dialect)})`
+      return `max(${renderExpression(expectValueExpression("max", ast.value), state, dialect)})`
     case "min":
-      return `min(${renderExpression(ast.value, state, dialect)})`
+      return `min(${renderExpression(expectValueExpression("min", ast.value), state, dialect)})`
     case "and":
       return `(${ast.values.map((value: Expression.Any) => renderExpression(value, state, dialect)).join(" and ")})`
     case "or":
@@ -1435,45 +2025,39 @@ export const renderExpression = (
         `when ${renderExpression(branch.when, state, dialect)} then ${renderExpression(branch.then, state, dialect)}`
       ).join(" ")} else ${renderExpression(ast.else, state, dialect)} end`
     case "exists":
-      return `exists (${renderQueryAst(
-        Query.getAst(ast.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
-        state,
-        dialect
-      ).sql})`
+      return `exists (${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`
     case "scalarSubquery":
-      return `(${renderQueryAst(
-        Query.getAst(ast.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
-        state,
-        dialect
-      ).sql})`
+      return `(${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`
     case "inSubquery":
-      return `(${renderExpression(ast.left, state, dialect)} in (${renderQueryAst(
-        Query.getAst(ast.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
-        state,
-        dialect
-      ).sql}))`
-    case "comparisonAny":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderQueryAst(
-        Query.getAst(ast.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
-        state,
-        dialect
-      ).sql}))`
-    case "comparisonAll":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderQueryAst(
-        Query.getAst(ast.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
-        state,
-        dialect
-      ).sql}))`
-    case "window": {
-      if (!Array.isArray(ast.partitionBy) || !Array.isArray(ast.orderBy) || typeof ast.function !== "string") {
-        break
+      return `(${renderExpression(expectValueExpression("inSubquery", ast.left), state, dialect)} in (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
+    case "comparisonAny": {
+      const left = expectValueExpression("compareAny", ast.left)
+      const operator = renderComparisonOperator(ast.operator)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard quantified comparison")
+      }
+      return `(${renderExpression(left, state, dialect)} ${operator} any (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
+    }
+    case "comparisonAll": {
+      const left = expectValueExpression("compareAll", ast.left)
+      const operator = renderComparisonOperator(ast.operator)
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard quantified comparison")
       }
+      return `(${renderExpression(left, state, dialect)} ${operator} all (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
+    }
+    case "window": {
+      const partitionBy = ast.partitionBy as readonly Expression.Any[]
+      const orderBy = ast.orderBy as readonly {
+        readonly value: Expression.Any
+        readonly direction: string
+      }[]
       const clauses: string[] = []
-      if (ast.partitionBy.length > 0) {
-        clauses.push(`partition by ${ast.partitionBy.map((value: Expression.Any) => renderExpression(value, state, dialect)).join(", ")}`)
+      if (partitionBy.length > 0) {
+        clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
       }
-      if (ast.orderBy.length > 0) {
-        clauses.push(`order by ${ast.orderBy.map((entry) =>
+      if (orderBy.length > 0) {
+        clauses.push(`order by ${orderBy.map((entry) =>
           `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
         ).join(", ")}`)
       }
@@ -1486,7 +2070,7 @@ export const renderExpression = (
         case "denseRank":
           return `dense_rank() over (${specification})`
         case "over":
-          return `${renderExpression(ast.value!, state, dialect)} over (${specification})`
+          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${specification})`
       }
       break
     }