effect-qb 0.15.0 → 0.17.0

package/src/mysql/internal/sql-expression-renderer.ts

@@ -1,14 +1,25 @@
+import * as Schema from "effect/Schema"
+
 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 type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
 import * as ExpressionAst from "../../internal/expression-ast.js"
 import * as JsonPath from "../../internal/json/path.js"
+import { renderMysqlMutationLockMode, renderSelectLockMode } from "../../internal/dsl-plan-runtime.js"
+import { expectConflictClause, expectInsertSourceKind } from "../../internal/dsl-mutation-runtime.js"
+import { expectDdlClauseKind, expectTruncateClause, renderTransactionIsolationLevel } from "../../internal/dsl-transaction-ddl-runtime.js"
+import {
+  renderJsonSelectSql,
+  renderSelectSql,
+  toDriverValue
+} from "../../internal/runtime/driver-value-mapping.js"
+import { normalizeDbValue } from "../../internal/runtime/normalize.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"
+import { renderReferentialAction, type DdlExpressionLike } from "../../internal/table-options.js"
 
 const renderDbType = (
   dialect: SqlDialect,
@@ -46,14 +57,59 @@ const renderCastType = (
   }
 }
 
+const renderMysqlDdlString = (value: string): string =>
+  `'${value.replaceAll("'", "''")}'`
+
+const renderMysqlDdlBytes = (value: Uint8Array): string =>
+  `x'${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}'`
+
+const renderMysqlDdlLiteral = (
+  value: unknown,
+  state: RenderState,
+  context: RenderValueContext = {}
+): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "mysql",
+    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 renderMysqlDdlString(driverValue)
+    case "object":
+      if (driverValue instanceof Uint8Array) {
+        return renderMysqlDdlBytes(driverValue)
+      }
+      break
+  }
+  throw new Error("Unsupported mysql 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: renderMysqlDdlLiteral
+  })
+}
 
 const renderMysqlMutationLimit = (
   expression: Expression.Any,
@@ -109,22 +165,27 @@ const renderCreateTableSql = (
         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" : ""}` : ""}`)
         break
       case "unique":
+        if (option.nullsNotDistinct || option.deferrable || option.initiallyDeferred) {
+          throw new Error("Unsupported mysql unique constraint options")
+        }
         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" : ""}` : ""}`)
         break
       case "foreignKey": {
         const reference = 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(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 !== undefined ? ` on delete ${renderReferentialAction(option.onDelete)}` : ""}${option.onUpdate !== undefined ? ` on update ${renderReferentialAction(option.onUpdate)}` : ""}${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`
         )
         break
       }
       case "check":
         definitions.push(
-          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderDdlExpression(option.predicate, state, dialect)})${option.noInherit ? " no inherit" : ""}`
+          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderDdlExpression(option.predicate, { ...state, 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(", ")})`
@@ -136,6 +197,9 @@ const renderCreateIndexSql = (
   state: RenderState,
   dialect: SqlDialect
 ): string => {
+  if (ddl.ifNotExists) {
+    throw new Error("Unsupported mysql create index options")
+  }
   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(", ")})`
 }
@@ -145,16 +209,28 @@ const renderDropIndexSql = (
   ddl: Extract<QueryAst.DdlClause, { readonly kind: "dropIndex" }>,
   state: RenderState,
   dialect: SqlDialect
-): string =>
-  dialect.name === "postgres"
+): string => {
+  if (ddl.ifExists) {
+    throw new Error("Unsupported mysql drop index options")
+  }
+  return 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)}`
+}
 
 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)
@@ -216,19 +292,19 @@ 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":
@@ -242,10 +318,32 @@ const renderJsonPathSegment = (segment: JsonPath.AnySegment | string | number):
   }
 }
 
-const renderJsonPathStringLiteral = (segments: ReadonlyArray<JsonPath.AnySegment | string | number>): string => {
+const renderMySqlJsonIndex = (index: number): string =>
+  index >= 0 ? String(index) : index === -1 ? "last" : `last-${Math.abs(index) - 1}`
+
+const renderMySqlJsonPathSegment = (segment: JsonPath.AnySegment | string | number): string => {
+  if (typeof segment === "number") {
+    return `[${renderMySqlJsonIndex(segment)}]`
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "index") {
+    return `[${renderMySqlJsonIndex(segment.index)}]`
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "slice") {
+    return `[${renderMySqlJsonIndex(segment.start ?? 0)} to ${segment.end === undefined ? "last" : renderMySqlJsonIndex(segment.end)}]`
+  }
+  if (typeof segment === "object" && segment !== null && segment.kind === "descend") {
+    return "**"
+  }
+  return renderJsonPathSegment(segment)
+}
+
+const renderJsonPathStringLiteral = (
+  segments: ReadonlyArray<JsonPath.AnySegment | string | number>,
+  renderSegment: (segment: JsonPath.AnySegment | string | number) => string = renderJsonPathSegment
+): string => {
   let path = "$"
   for (const segment of segments) {
-    path += renderJsonPathSegment(segment)
+    path += renderSegment(segment)
   }
   return path
 }
@@ -254,7 +352,30 @@ const renderMySqlJsonPath = (
   segments: ReadonlyArray<JsonPath.AnySegment | string | number>,
   state: RenderState,
   dialect: SqlDialect
-): string => dialect.renderLiteral(renderJsonPathStringLiteral(segments), state)
+): string => dialect.renderLiteral(renderJsonPathStringLiteral(segments, renderMySqlJsonPathSegment), state)
+
+const isJsonArrayIndexSegment = (segment: JsonPath.AnySegment | string | number | undefined): boolean =>
+  typeof segment === "number" || (typeof segment === "object" && segment !== null && segment.kind === "index")
+
+const renderMySqlJsonInsertPath = (
+  segments: ReadonlyArray<JsonPath.AnySegment | string | number>,
+  insertAfter: boolean,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  if (!insertAfter || segments.length === 0) {
+    return renderMySqlJsonPath(segments, state, dialect)
+  }
+  const last = segments[segments.length - 1]
+  const nextSegments = segments.slice(0, -1)
+  if (typeof last === "number") {
+    return renderMySqlJsonPath([...nextSegments, last + 1], state, dialect)
+  }
+  if (typeof last === "object" && last !== null && last.kind === "index") {
+    return renderMySqlJsonPath([...nextSegments, { ...last, index: last.index + 1 }], state, dialect)
+  }
+  return renderMySqlJsonPath(segments, state, dialect)
+}
 
 const renderPostgresJsonPathArray = (
   segments: ReadonlyArray<JsonPath.AnySegment | string | number>,
@@ -313,6 +434,76 @@ const renderPostgresJsonValue = (
     : `cast(${rendered} as jsonb)`
 }
 
+const expressionDriverContext = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[Expression.TypeId].dbType,
+  runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+  driverValueMapping: expression[Expression.TypeId].driverValueMapping
+})
+
+const renderMySqlStructuredJsonLiteral = (
+  expression: Expression.Any,
+  state: RenderState
+): string | undefined => {
+  const ast = (expression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  if (ast.kind !== "literal" || ast.value === null || typeof ast.value !== "object") {
+    return undefined
+  }
+  state.params.push(JSON.stringify(ast.value))
+  return "cast(? as json)"
+}
+
+const renderJsonInputExpression = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  if (dialect.name === "mysql") {
+    const jsonLiteral = renderMySqlStructuredJsonLiteral(expression, state)
+    if (jsonLiteral !== undefined) {
+      return jsonLiteral
+    }
+  }
+  return renderJsonSelectSql(
+    renderExpression(expression, state, dialect),
+    expressionDriverContext(expression, state, dialect)
+  )
+}
+
+const encodeArrayValues = (
+  values: readonly unknown[],
+  column: Table.AnyTable[typeof Table.TypeId]["fields"][string],
+  state: RenderState,
+  dialect: SqlDialect
+): readonly unknown[] =>
+  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
 ): "json" | "jsonb" => value[Expression.TypeId].dbType.kind === "jsonb" ? "jsonb" : "json"
@@ -323,7 +514,10 @@ const renderJsonOpaquePath = (
   dialect: SqlDialect
 ): string => {
   if (isJsonPathValue(value)) {
-    return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments), state)
+    const renderSegment = dialect.name === "mysql"
+      ? renderMySqlJsonPathSegment
+      : renderJsonPathSegment
+    return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments, renderSegment), state)
   }
   if (typeof value === "string") {
     return dialect.renderLiteral(value, state)
@@ -450,8 +644,9 @@ const renderJsonExpression = (
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one"
+        const modeSql = dialect.renderLiteral(mode, state)
         const paths = keys.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")
-        return `json_contains_path(${baseSql}, ${dialect.renderLiteral(mode, state)}, ${paths})`
+        return `json_contains_path(${baseSql}, ${modeSql}, ${paths})`
       }
       return undefined
     }
@@ -464,7 +659,7 @@ const renderJsonExpression = (
         return `(${renderPostgresJsonValue(ast.left, state, dialect)} || ${renderPostgresJsonValue(ast.right, state, dialect)})`
       }
       if (dialect.name === "mysql") {
-        return `json_merge_preserve(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`
+        return `json_merge_preserve(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`
       }
       return undefined
     }
@@ -474,7 +669,7 @@ const renderJsonExpression = (
         : []
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ])
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`
@@ -488,7 +683,7 @@ const renderJsonExpression = (
       const values = Array.isArray((ast as { readonly values?: readonly Expression.Any[] }).values)
         ? (ast as { readonly values: readonly Expression.Any[] }).values
         : []
-      const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ")
+      const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ")
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`
       }
@@ -502,10 +697,10 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`
+        return renderMySqlStructuredJsonLiteral(base, state) ?? `cast(${renderExpression(base, state, dialect)} as json)`
       }
       return undefined
     case "jsonToJsonb":
@@ -513,10 +708,10 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`
+        return renderMySqlStructuredJsonLiteral(base, state) ?? `cast(${renderExpression(base, state, dialect)} as json)`
       }
       return undefined
     case "jsonTypeOf":
@@ -586,9 +781,7 @@ const renderJsonExpression = (
         return `(${baseSql} #- ${renderPostgresJsonPathArray(segments, state, dialect)})`
       }
       if (dialect.name === "mysql") {
-        return `json_remove(${renderExpression(base, state, dialect)}, ${segments.map((segment) =>
-          renderMySqlJsonPath([segment], state, dialect)
-        ).join(", ")})`
+        return `json_remove(${renderExpression(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)})`
       }
       return undefined
     }
@@ -612,8 +805,16 @@ const renderJsonExpression = (
         return `${functionName}(${renderPostgresJsonValue(base, state, dialect)}, ${renderPostgresJsonPathArray(segments, state, dialect)}, ${renderPostgresJsonValue(nextValue, state, dialect)}${extra})`
       }
       if (dialect.name === "mysql") {
-        const functionName = kind === "jsonInsert" ? "json_insert" : "json_set"
-        return `${functionName}(${renderExpression(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)}, ${renderExpression(nextValue, state, dialect)})`
+        const renderedBase = renderExpression(base, state, dialect)
+        if (kind === "jsonInsert" && isJsonArrayIndexSegment(segments[segments.length - 1])) {
+          const renderedPath = renderMySqlJsonInsertPath(segments, insertAfter, state, dialect)
+          const renderedValue = renderJsonInputExpression(nextValue, state, dialect)
+          return `json_array_insert(${renderedBase}, ${renderedPath}, ${renderedValue})`
+        }
+        const functionName = kind === "jsonInsert" ? "json_insert" : createMissing ? "json_set" : "json_replace"
+        const renderedPath = renderMySqlJsonPath(segments, state, dialect)
+        const renderedValue = renderJsonInputExpression(nextValue, state, dialect)
+        return `${functionName}(${renderedBase}, ${renderedPath}, ${renderedValue})`
       }
       return undefined
     }
@@ -712,16 +913,7 @@ const renderMysqlMutationLock = (
   if (!lock) {
     return ""
   }
-  switch (lock.mode) {
-    case "lowPriority":
-      return " low_priority"
-    case "ignore":
-      return " ignore"
-    case "quick":
-      return statement === "delete" ? " quick" : ""
-    default:
-      return ""
-  }
+  return renderMysqlMutationLockMode(lock.mode, statement)
 }
 
 const renderTransactionClause = (
@@ -731,8 +923,9 @@ 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) {
         modes.push("read only")
@@ -752,7 +945,7 @@ const renderTransactionClause = (
     case "releaseSavepoint":
       return `release savepoint ${dialect.quoteIdentifier(clause.name)}`
   }
-  return ""
+  throw new Error("Unsupported transaction statement kind")
 }
 
 const renderSelectionList = (
@@ -765,19 +958,117 @@ const renderSelectionList = (
     validateAggregationSelection(selection as SelectionValue, [])
   }
   const flattened = flattenSelection(selection)
+  if (dialect.name === "mysql" && flattened.length === 0) {
+    throw new Error("mysql select statements require at least one selected expression")
+  }
   const projections = selectionProjections(selection)
   const sql = flattened.map(({ expression, alias }) =>
-    `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias)}`).join(", ")
+    `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias)}`).join(", ")
   return {
     sql,
     projections
   }
 }
 
+const nestedRenderState = (state: RenderState): RenderState => ({
+  params: state.params,
+  valueMappings: state.valueMappings,
+  ctes: [],
+  cteNames: new Set(state.cteNames),
+  cteSources: new Map(state.cteSources)
+})
+
+const assertMatchingSetProjections = (
+  left: readonly Projection[],
+  right: readonly Projection[]
+): void => {
+  const leftKeys = left.map((projection) => JSON.stringify(projection.path))
+  const rightKeys = right.map((projection) => JSON.stringify(projection.path))
+  if (leftKeys.length !== rightKeys.length || leftKeys.some((key, index) => key !== rightKeys[index])) {
+    throw new Error("set operator operands must have matching result rows")
+  }
+}
+
+const assertNoGroupedMutationClauses = (
+  ast: Pick<QueryAst.Ast, "groupBy" | "having">,
+  statement: string
+): void => {
+  if (ast.groupBy.length > 0) {
+    throw new Error(`groupBy(...) is not supported for ${statement} statements`)
+  }
+  if (ast.having.length > 0) {
+    throw new Error(`having(...) is not supported for ${statement} statements`)
+  }
+}
+
+const assertNoInsertQueryClauses = (
+  ast: Pick<QueryAst.Ast, "where" | "joins" | "orderBy" | "limit" | "offset" | "lock">
+): void => {
+  if (ast.where.length > 0) {
+    throw new Error("where(...) is not supported for insert statements")
+  }
+  if (ast.joins.length > 0) {
+    throw new Error("join(...) is not supported for insert statements")
+  }
+  if (ast.orderBy.length > 0) {
+    throw new Error("orderBy(...) is not supported for insert statements")
+  }
+  if (ast.limit) {
+    throw new Error("limit(...) is not supported for insert statements")
+  }
+  if (ast.offset) {
+    throw new Error("offset(...) is not supported for insert statements")
+  }
+  if (ast.lock) {
+    throw new Error("lock(...) is not supported for insert statements")
+  }
+}
+
+const assertNoStatementQueryClauses = (
+  ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
+  statement: string,
+  options: { readonly allowSelection?: boolean } = {}
+): void => {
+  if (ast.distinct) {
+    throw new Error(`distinct(...) is not supported for ${statement} statements`)
+  }
+  if (ast.where.length > 0) {
+    throw new Error(`where(...) is not supported for ${statement} statements`)
+  }
+  if ((ast.fromSources?.length ?? 0) > 0 || ast.from) {
+    throw new Error(`from(...) is not supported for ${statement} statements`)
+  }
+  if (ast.joins.length > 0) {
+    throw new Error(`join(...) is not supported for ${statement} statements`)
+  }
+  if (ast.groupBy.length > 0) {
+    throw new Error(`groupBy(...) is not supported for ${statement} statements`)
+  }
+  if (ast.having.length > 0) {
+    throw new Error(`having(...) is not supported for ${statement} statements`)
+  }
+  if (ast.orderBy.length > 0) {
+    throw new Error(`orderBy(...) is not supported for ${statement} statements`)
+  }
+  if (ast.limit) {
+    throw new Error(`limit(...) is not supported for ${statement} statements`)
+  }
+  if (ast.offset) {
+    throw new Error(`offset(...) is not supported for ${statement} statements`)
+  }
+  if (ast.lock) {
+    throw new Error(`lock(...) is not supported for ${statement} statements`)
+  }
+  if (options.allowSelection !== true && Object.keys(ast.select).length > 0) {
+    throw new Error(`returning(...) is not supported for ${statement} statements`)
+  }
+}
+
 export const renderQueryAst = (
   ast: QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>,
   state: RenderState,
-  dialect: SqlDialect
+  dialect: SqlDialect,
+  options: { readonly emitCtes?: boolean } = {}
 ): RenderedQueryAst => {
   let sql = ""
   let projections: readonly Projection[] = []
@@ -787,15 +1078,19 @@ export const renderQueryAst = (
       validateAggregationSelection(ast.select as SelectionValue, ast.groupBy)
       const rendered = renderSelectionList(ast.select as Record<string, unknown>, state, dialect, false)
       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 === "mysql" && join.kind === "full") {
+          throw new Error("Unsupported mysql full join")
+        }
         const source = renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)
         clauses.push(
           join.kind === "cross"
@@ -822,8 +1117,11 @@ export const renderQueryAst = (
         clauses.push(`offset ${renderExpression(ast.offset, state, dialect)}`)
       }
       if (ast.lock) {
+        if (ast.lock.nowait && ast.lock.skipLocked) {
+          throw new Error("lock(...) cannot specify both nowait and skipLocked")
+        }
         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(" ")
@@ -831,6 +1129,7 @@ export const renderQueryAst = (
     }
     case "set": {
       const setAst = ast as QueryAst.Ast<Record<string, unknown>, any, "set">
+      assertNoStatementQueryClauses(setAst, "set", { allowSelection: true })
       const base = renderQueryAst(
         Query.getAst(setAst.setBase as Query.Plan.Any) as QueryAst.Ast<
           Record<string, unknown>,
@@ -841,6 +1140,7 @@ export const renderQueryAst = (
         dialect
       )
       projections = selectionProjections(setAst.select as Record<string, unknown>)
+      assertMatchingSetProjections(projections, base.projections)
       sql = [
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
@@ -853,6 +1153,7 @@ export const renderQueryAst = (
             state,
             dialect
           )
+          assertMatchingSetProjections(projections, rendered.projections)
           return `${entry.kind}${entry.all ? " all" : ""} (${rendered.sql})`
         })
       ].join(" ")
@@ -860,19 +1161,26 @@ export const renderQueryAst = (
     }
     case "insert": {
       const insertAst = ast as QueryAst.Ast<Record<string, unknown>, any, "insert">
+      if (insertAst.distinct) {
+        throw new Error("distinct(...) is not supported for insert statements")
+      }
+      assertNoGroupedMutationClauses(insertAst, "insert")
+      assertNoInsertQueryClauses(insertAst)
       const targetSource = insertAst.into!
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
+      const insertSource = expectInsertSourceKind(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) =>
+      if (insertSource?.kind === "values") {
+        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
+        const rows = insertSource.rows.map((row) =>
           `(${row.values.map((entry) => renderExpression(entry.value, state, 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) => dialect.quoteIdentifier(column)).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
@@ -881,22 +1189,25 @@ 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) => dialect.quoteIdentifier(column)).join(", ")
         if (dialect.name === "postgres") {
           const table = targetSource.source as Table.AnyTable
           const fields = table[Table.TypeId].fields
-          const rendered = unnestSource.values.map((entry) =>
-            `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields[entry.columnName]!.metadata.dbType)}[])`
+          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 table = targetSource.source as Table.AnyTable
+          const fields = table[Table.TypeId].fields
+          const encodedValues = insertSource.values.map((entry) => ({
+            columnName: entry.columnName,
+            values: encodeArrayValues(entry.values, fields[entry.columnName]!, state, dialect)
+          }))
+          const rowCount = encodedValues[0]?.values.length ?? 0
           const rows = Array.from({ length: rowCount }, (_, index) =>
-            `(${unnestSource.values.map((entry) =>
-              dialect.renderLiteral(entry.values[index], state)
-            ).join(", ")})`
+            `(${encodedValues.map((entry) => dialect.renderLiteral(entry.values[index], state)).join(", ")})`
           ).join(", ")
           sql += ` (${columns}) values ${rows}`
         }
@@ -906,30 +1217,39 @@ export const renderQueryAst = (
         if ((insertAst.values ?? []).length > 0) {
           sql += ` (${columns}) values (${values})`
         } else {
-          sql += " default values"
+          sql += " () values ()"
         }
       }
-      if (insertAst.conflict) {
-        const updateValues = (insertAst.conflict.values ?? []).map((entry) =>
+      if (conflict) {
+        if (conflict.where) {
+          throw new Error("Unsupported mysql conflict action predicates")
+        }
+        const updateValues = (conflict.values ?? []).map((entry) =>
           `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, 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(conflict.target.name)}`
+            : conflict.target?.kind === "columns"
+              ? ` on conflict (${conflict.target.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, state, 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, state, 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)
+      const hasReturning = Object.keys(insertAst.select as Record<string, unknown>).length > 0
+      const returning = hasReturning
+        ? renderSelectionList(insertAst.select as Record<string, unknown>, state, dialect, false)
+        : { sql: "", projections: [] }
+      if (dialect.name === "mysql" && returning.sql.length > 0) {
+        throw new Error("Unsupported mysql returning")
+      }
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -938,19 +1258,33 @@ export const renderQueryAst = (
     }
     case "update": {
       const updateAst = ast as QueryAst.Ast<Record<string, unknown>, any, "update">
+      if (updateAst.distinct) {
+        throw new Error("distinct(...) is not supported for update statements")
+      }
+      assertNoGroupedMutationClauses(updateAst, "update")
+      if (updateAst.offset) {
+        throw new Error("offset(...) is not supported for update statements")
+      }
       const targetSource = updateAst.target!
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
       const targets = updateAst.targets ?? [targetSource]
       const fromSources = updateAst.fromSources ?? []
+      if ((updateAst.set ?? []).length === 0) {
+        throw new Error("update statements require at least one assignment")
+      }
       const assignments = updateAst.set!.map((entry) =>
         renderMutationAssignment(entry, state, dialect)).join(", ")
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(updateAst.lock, "update")
         const extraSources = renderFromSources(fromSources, state, dialect)
         const joinSources = updateAst.joins.map((join) =>
-          join.kind === "cross"
-            ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}`
-            : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on!, state, dialect)}`
+          join.kind === "full"
+            ? (() => {
+              throw new Error("Unsupported mysql full join")
+            })()
+            : join.kind === "cross"
+              ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}`
+              : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on!, state, dialect)}`
         ).join(" ")
         const targetList = [
           ...targets.map((entry) =>
@@ -982,7 +1316,13 @@ export const renderQueryAst = (
       if (dialect.name === "mysql" && updateAst.limit) {
         sql += ` limit ${renderMysqlMutationLimit(updateAst.limit, state, dialect)}`
       }
-      const returning = renderSelectionList(updateAst.select as Record<string, unknown>, state, dialect, false)
+      const hasReturning = Object.keys(updateAst.select as Record<string, unknown>).length > 0
+      const returning = hasReturning
+        ? renderSelectionList(updateAst.select as Record<string, unknown>, state, dialect, false)
+        : { sql: "", projections: [] }
+      if (dialect.name === "mysql" && returning.sql.length > 0) {
+        throw new Error("Unsupported mysql returning")
+      }
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -991,6 +1331,13 @@ export const renderQueryAst = (
     }
     case "delete": {
       const deleteAst = ast as QueryAst.Ast<Record<string, unknown>, any, "delete">
+      if (deleteAst.distinct) {
+        throw new Error("distinct(...) is not supported for delete statements")
+      }
+      assertNoGroupedMutationClauses(deleteAst, "delete")
+      if (deleteAst.offset) {
+        throw new Error("offset(...) is not supported for delete statements")
+      }
       const targetSource = deleteAst.target!
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)
       const targets = deleteAst.targets ?? [targetSource]
@@ -1002,9 +1349,13 @@ export const renderQueryAst = (
           renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)
         ).join(", ")
         const joinSources = deleteAst.joins.map((join) =>
-          join.kind === "cross"
-            ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}`
-            : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on!, state, dialect)}`
+          join.kind === "full"
+            ? (() => {
+              throw new Error("Unsupported mysql full join")
+            })()
+            : join.kind === "cross"
+              ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}`
+              : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on!, state, dialect)}`
         ).join(" ")
         sql = hasJoinedSources
           ? `delete${modifiers} ${targetList} from ${fromSources}${joinSources.length > 0 ? ` ${joinSources}` : ""}`
@@ -1028,7 +1379,13 @@ export const renderQueryAst = (
       if (dialect.name === "mysql" && deleteAst.limit) {
         sql += ` limit ${renderMysqlMutationLimit(deleteAst.limit, state, dialect)}`
       }
-      const returning = renderSelectionList(deleteAst.select as Record<string, unknown>, state, dialect, false)
+      const hasReturning = Object.keys(deleteAst.select as Record<string, unknown>).length > 0
+      const returning = hasReturning
+        ? renderSelectionList(deleteAst.select as Record<string, unknown>, state, dialect, false)
+        : { sql: "", projections: [] }
+      if (dialect.name === "mysql" && returning.sql.length > 0) {
+        throw new Error("Unsupported mysql returning")
+      }
       projections = returning.projections
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`
@@ -1037,12 +1394,17 @@ export const renderQueryAst = (
     }
     case "truncate": {
       const truncateAst = ast as QueryAst.Ast<Record<string, unknown>, any, "truncate">
+      assertNoStatementQueryClauses(truncateAst, "truncate")
+      const truncate = expectTruncateClause(truncateAst.truncate)
       const targetSource = truncateAst.target!
+      if (dialect.name === "mysql" && (truncate.restartIdentity || truncate.cascade)) {
+        throw new Error("Unsupported mysql truncate options")
+      }
       sql = `truncate table ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`
-      if (truncateAst.truncate?.restartIdentity) {
+      if (truncate.restartIdentity) {
         sql += " restart identity"
       }
-      if (truncateAst.truncate?.cascade) {
+      if (truncate.cascade) {
         sql += " cascade"
       }
       break
@@ -1055,6 +1417,9 @@ export const renderQueryAst = (
       const targetSource = mergeAst.target!
       const usingSource = mergeAst.using!
       const merge = mergeAst.merge!
+      if (Object.keys(mergeAst.select as Record<string, unknown>).length > 0) {
+        throw new Error("returning(...) is not supported for merge statements")
+      }
       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) {
         sql += " when matched"
@@ -1084,25 +1449,30 @@ export const renderQueryAst = (
     case "savepoint":
     case "rollbackTo":
     case "releaseSavepoint": {
+      assertNoStatementQueryClauses(ast, ast.kind)
       sql = renderTransactionClause(ast.transaction!, dialect)
       break
     }
     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)
+      assertNoStatementQueryClauses(createTableAst, "createTable")
+      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
-      sql = `drop table${ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target!.source, dropTableAst.target!.tableName, dropTableAst.target!.baseTableName, state, dialect)}`
+      assertNoStatementQueryClauses(dropTableAst, "dropTable")
+      const ddl = expectDdlClauseKind(dropTableAst.ddl, "dropTable")
+      sql = `drop table${ddl.ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target!.source, dropTableAst.target!.tableName, dropTableAst.target!.baseTableName, state, dialect)}`
       break
     }
     case "createIndex": {
       const createIndexAst = ast as QueryAst.Ast<Record<string, unknown>, any, "createIndex">
+      assertNoStatementQueryClauses(createIndexAst, "createIndex")
       sql = renderCreateIndexSql(
         createIndexAst.target!,
-        createIndexAst.ddl as Extract<QueryAst.DdlClause, { readonly kind: "createIndex" }>,
+        expectDdlClauseKind(createIndexAst.ddl, "createIndex"),
         state,
         dialect
       )
@@ -1110,17 +1480,20 @@ export const renderQueryAst = (
     }
     case "dropIndex": {
       const dropIndexAst = ast as QueryAst.Ast<Record<string, unknown>, any, "dropIndex">
+      assertNoStatementQueryClauses(dropIndexAst, "dropIndex")
       sql = renderDropIndexSql(
         dropIndexAst.target!,
-        dropIndexAst.ddl as Extract<QueryAst.DdlClause, { readonly kind: "dropIndex" }>,
+        expectDdlClauseKind(dropIndexAst.ddl, "dropIndex"),
         state,
         dialect
       )
       break
     }
+    default:
+      throw new Error("Unsupported query statement kind")
   }
 
-  if (state.ctes.length === 0) {
+  if (state.ctes.length === 0 || options.emitCtes === false) {
     return {
       sql,
       projections
@@ -1168,9 +1541,27 @@ 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 statement = Query.getQueryState(cte.plan).statement
+      if (statement !== "select" && statement !== "set") {
+        const cteAst = Query.getAst(cte.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>
+        if (Object.keys((cteAst.select ?? {}) as Record<string, unknown>).length > 0) {
+          throw new Error("Unsupported mysql returning")
+        }
+        throw new Error("Unsupported mysql data-modifying cte")
+      }
+      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,
@@ -1187,14 +1578,14 @@ 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)}`
+    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 {
@@ -1229,6 +1620,22 @@ const renderSourceReference = (
   return dialect.renderTableReference(tableName, 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
+}
+
 /**
  * Renders a scalar expression AST into SQL text.
  *
@@ -1263,11 +1670,14 @@ export const renderExpression = (
               : ">="
     switch (ast.kind) {
     case "column":
-      return ast.tableName.length === 0
+      return state.rowLocalColumns || ast.tableName.length === 0
         ? dialect.quoteIdentifier(ast.columnName)
         : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
     case "literal":
-      return dialect.renderLiteral(ast.value, state)
+      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":
       return dialect.name === "mysql"
         ? `values(${dialect.quoteIdentifier(ast.columnName)})`
@@ -1329,7 +1739,7 @@ export const renderExpression = (
         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)})`
+        return `json_contains(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
     case "containedBy":
@@ -1343,7 +1753,7 @@ export const renderExpression = (
         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)})`
+        return `json_contains(${renderJsonInputExpression(ast.right, state, dialect)}, ${renderJsonInputExpression(ast.left, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
     case "overlaps":
@@ -1357,7 +1767,7 @@ export const renderExpression = (
         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)})`
+        return `json_overlaps(${renderJsonInputExpression(ast.left, state, dialect)}, ${renderJsonInputExpression(ast.right, state, dialect)})`
       }
       throw new Error("Unsupported container operator for SQL rendering")
     case "isNull":
@@ -1377,14 +1787,26 @@ export const renderExpression = (
     case "min":
       return `min(${renderExpression(ast.value, state, dialect)})`
     case "and":
+      if (ast.values.length === 0) {
+        throw new Error("and(...) requires at least one predicate")
+      }
       return `(${ast.values.map((value: Expression.Any) => renderExpression(value, state, dialect)).join(" and ")})`
     case "or":
+      if (ast.values.length === 0) {
+        throw new Error("or(...) requires at least one predicate")
+      }
       return `(${ast.values.map((value: Expression.Any) => renderExpression(value, state, dialect)).join(" or ")})`
     case "coalesce":
       return `coalesce(${ast.values.map((value: Expression.Any) => renderExpression(value, state, dialect)).join(", ")})`
     case "in":
+      if (ast.values.length < 2) {
+        throw new Error("in(...) requires at least one candidate value")
+      }
       return `(${renderExpression(ast.values[0]!, state, dialect)} in (${ast.values.slice(1).map((value: Expression.Any) => renderExpression(value, state, dialect)).join(", ")}))`
     case "notIn":
+      if (ast.values.length < 2) {
+        throw new Error("notIn(...) requires at least one candidate value")
+      }
       return `(${renderExpression(ast.values[0]!, state, dialect)} not in (${ast.values.slice(1).map((value: Expression.Any) => renderExpression(value, state, dialect)).join(", ")}))`
     case "between":
       return `(${renderExpression(ast.values[0]!, state, dialect)} between ${renderExpression(ast.values[1]!, state, dialect)} and ${renderExpression(ast.values[2]!, state, dialect)})`
@@ -1395,35 +1817,15 @@ 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}))`
+      return `(${renderExpression(ast.left, state, dialect)} in (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
     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}))`
+      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
     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}))`
+      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`
     case "window": {
       if (!Array.isArray(ast.partitionBy) || !Array.isArray(ast.orderBy) || typeof ast.function !== "string") {
         break