effect-qb 0.13.0 → 0.15.0

package/src/{internal/postgres-renderer.ts → postgres/internal/renderer.ts}

@@ -1,7 +1,7 @@
-import * as Query from "./query.js"
-import { type RenderState } from "./dialect.js"
-import { postgresDialect } from "./postgres-dialect.js"
-import { type Projection } from "./projections.js"
+import * as Query from "../../internal/query.js"
+import { type RenderState } from "../../internal/dialect.js"
+import { postgresDialect } from "./dialect.js"
+import { type Projection } from "../../internal/projections.js"
 import { renderQueryAst } from "./sql-expression-renderer.js"
 
 /**
@@ -19,7 +19,7 @@ export interface PostgresRenderResult {
 /**
  * Renders the current query AST into Postgres SQL plus bind parameters.
  */
-export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
   plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
 ): PostgresRenderResult => {
   const state: RenderState = {
@@ -28,7 +28,7 @@ export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, a
     cteNames: new Set<string>()
   }
   const rendered = renderQueryAst(
-    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any>) as any,
+    Query.getAst(plan as Query.Plan.Any) as any,
     state,
     postgresDialect
   )

package/src/postgres/internal/schema-ddl.ts

@@ -0,0 +1,108 @@
+import type * as Expression from "../../internal/scalar.js"
+import type { RenderState, SqlDialect } from "../../internal/dialect.js"
+import * as SchemaExpression from "../../internal/schema-expression.js"
+import { renderExpression } from "./sql-expression-renderer.js"
+import type { DdlExpressionLike } from "../../internal/table-options.js"
+import { parse, toSql } from "pgsql-ast-parser"
+import { postgresDialect } from "./dialect.js"
+
+export const renderDdlExpression = (
+  expression: DdlExpressionLike,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, state, dialect)
+
+const escapeString = (value: string): string => `'${value.replaceAll("'", "''")}'`
+
+const inlineLiteralDialect: SqlDialect<"postgres"> = {
+  ...postgresDialect,
+  renderLiteral(value) {
+    if (value === null) {
+      return "null"
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false"
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      return String(value)
+    }
+    if (value instanceof Date) {
+      return escapeString(value.toISOString())
+    }
+    return escapeString(String(value))
+  }
+}
+
+export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, {
+        params: [],
+        ctes: [],
+        cteNames: new Set()
+      }, inlineLiteralDialect)
+
+const stripRedundantOuterParens = (value: string): string => {
+  let current = value.trim()
+  while (current.startsWith("(") && current.endsWith(")")) {
+    let depth = 0
+    let wrapsWholeExpression = true
+    let inSingleQuote = false
+    let inDoubleQuote = false
+    for (let index = 0; index < current.length; index++) {
+      const char = current[index]!
+      const previous = index > 0 ? current[index - 1] : undefined
+      if (char === "'" && !inDoubleQuote && previous !== "\\") {
+        inSingleQuote = !inSingleQuote
+        continue
+      }
+      if (char === "\"" && !inSingleQuote && previous !== "\\") {
+        inDoubleQuote = !inDoubleQuote
+        continue
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue
+      }
+      if (char === "(") {
+        depth += 1
+      } else if (char === ")") {
+        depth -= 1
+        if (depth === 0 && index < current.length - 1) {
+          wrapsWholeExpression = false
+          break
+        }
+      }
+    }
+    if (!wrapsWholeExpression) {
+      break
+    }
+    current = current.slice(1, -1).trim()
+  }
+  return current
+}
+
+const canonicalizeDdlExpressionSql = (value: string): string =>
+  stripRedundantOuterParens(
+    value
+      .trim()
+      .replace(/\s+/g, " ")
+      .replace(/"[^"]+"\./g, "")
+      .replace(/"([A-Za-z_][A-Za-z0-9_]*)"/g, "$1")
+      .replace(/\bCOLLATE\b/g, "collate")
+      .replace(
+        /cast\(((?:'(?:[^']|'')*'|"[^"]+"|[a-zA-Z_][a-zA-Z0-9_]*|\([^()]+\))) as ([^)]+)\)/gi,
+        (_, expression: string, target: string) => `${expression}::${target.trim()}`
+      )
+  )
+
+export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
+  const rendered = renderDdlExpressionSql(expression)
+  try {
+    return canonicalizeDdlExpressionSql(toSql.expr(parse(rendered, "expr")))
+  } catch {
+    return canonicalizeDdlExpressionSql(rendered)
+  }
+}

package/src/postgres/internal/schema-model.ts

@@ -0,0 +1,150 @@
+import * as Table from "../../internal/table.js"
+import type { AnyColumnDefinition } from "../../internal/column-state.js"
+import { normalizeDdlExpressionSql } from "./schema-ddl.js"
+import type { TableOptionSpec } from "../../internal/table-options.js"
+import type { EnumDefinition } from "../schema-management.js"
+import { EnumTypeId } from "../schema-management.js"
+
+export interface EnumModel {
+  readonly kind: "enum"
+  readonly schemaName?: string
+  readonly name: string
+  readonly values: readonly string[]
+}
+
+export interface ColumnModel {
+  readonly name: string
+  readonly ddlType: string
+  readonly dbTypeKind: string
+  readonly typeKind?: string
+  readonly typeSchema?: string
+  readonly nullable: boolean
+  readonly hasDefault: boolean
+  readonly generated: boolean
+  readonly defaultSql?: string
+  readonly generatedSql?: string
+  readonly identity?: {
+    readonly generation: "always" | "byDefault"
+  }
+  readonly column?: AnyColumnDefinition
+}
+
+export interface TableModel {
+  readonly kind: "table"
+  readonly schemaName?: string
+  readonly name: string
+  readonly columns: readonly ColumnModel[]
+  readonly options: readonly TableOptionSpec[]
+  readonly table?: Table.AnyTable
+}
+
+export interface SchemaModel {
+  readonly dialect: "postgres"
+  readonly enums: readonly EnumModel[]
+  readonly tables: readonly TableModel[]
+}
+
+export const isTableDefinition = (value: unknown): value is Table.AnyTable =>
+  value !== null &&
+  (typeof value === "object" || typeof value === "function") &&
+  Table.TypeId in value
+
+export const isEnumDefinition = (value: unknown): value is EnumDefinition =>
+  typeof value === "object" && value !== null && EnumTypeId in value
+
+export const toTableModel = (table: Table.AnyTable): TableModel => {
+  const state = table[Table.TypeId]
+  const fields = state.fields as Record<string, AnyColumnDefinition>
+  const columns = Object.entries(fields).map(([name, column]) => {
+    const metadata = column.metadata
+    const enumDefinition = metadata.enum
+    const ddlType = metadata.ddlType ?? metadata.dbType.kind
+    return {
+      name,
+      ddlType,
+      dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
+      typeKind: enumDefinition === undefined ? undefined : "e",
+      typeSchema: enumDefinition?.schemaName,
+      nullable: column.metadata.nullable,
+      hasDefault: column.metadata.hasDefault,
+      generated: column.metadata.generated,
+      defaultSql: column.metadata.defaultValue === undefined
+        ? undefined
+        : normalizeDdlExpressionSql(column.metadata.defaultValue),
+      generatedSql: column.metadata.generatedValue === undefined
+        ? undefined
+        : normalizeDdlExpressionSql(column.metadata.generatedValue),
+      identity: column.metadata.identity,
+      column
+    }
+  }) satisfies ReadonlyArray<ColumnModel>
+  return {
+    kind: "table",
+    schemaName: state.schemaName,
+    name: state.baseName,
+    columns,
+    options: table[Table.OptionsSymbol],
+    table
+  }
+}
+
+export const toEnumModel = <
+  Name extends string,
+  Values extends readonly [string, ...string[]],
+  SchemaName extends string | undefined
+>(
+  definition: EnumDefinition<Name, Values, SchemaName>
+): EnumModel => ({
+  kind: "enum",
+  schemaName: definition.schemaName,
+  name: definition.name,
+  values: [...definition.values]
+})
+
+const enumModelsOfTable = (table: Table.AnyTable): readonly EnumModel[] => {
+  const state = table[Table.TypeId]
+  const fields = state.fields as Record<string, AnyColumnDefinition>
+  return Object.values(fields)
+    .flatMap((column) => column.metadata.enum === undefined
+      ? []
+      : [{
+          kind: "enum" as const,
+          schemaName: column.metadata.enum.schemaName,
+          name: column.metadata.enum.name,
+          values: [...column.metadata.enum.values]
+        } satisfies EnumModel
+      ])
+}
+
+export const fromDiscoveredValues = (values: ReadonlyArray<unknown>): SchemaModel => {
+  const tables = values.filter(isTableDefinition).map(toTableModel)
+  const enums = new Map<string, EnumModel>()
+  for (const value of values) {
+    if (isEnumDefinition(value)) {
+      enums.set(enumKey(value.schemaName, value.name), toEnumModel(value))
+    } else if (isTableDefinition(value)) {
+      for (const enumModel of enumModelsOfTable(value)) {
+        const key = enumKey(enumModel.schemaName, enumModel.name)
+        const existing = enums.get(key)
+        if (existing === undefined) {
+          enums.set(key, enumModel)
+          continue
+        }
+        if (JSON.stringify(existing.values) !== JSON.stringify(enumModel.values)) {
+          throw new Error(`Conflicting enum definitions discovered for '${key}'`)
+        }
+      }
+    }
+  }
+  return {
+    dialect: "postgres",
+    enums: [...enums.values()],
+    tables
+  }
+}
+
+export const tableKey = (schemaName: string | undefined, name: string): string =>
+  `${schemaName ?? "public"}.${name}`
+
+export const enumKey = (schemaName: string | undefined, name: string): string =>
+  `${schemaName ?? "public"}.${name}`

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

@@ -1,12 +1,14 @@
-import * as Query from "./query.js"
-import * as Expression from "./expression.js"
-import * as Table from "./table.js"
-import * as QueryAst from "./query-ast.js"
-import type { RenderState, SqlDialect } from "./dialect.js"
-import * as ExpressionAst from "./expression-ast.js"
-import * as JsonPath from "./json/path.js"
-import { flattenSelection, type Projection } from "./projections.js"
-import { type SelectionValue, validateAggregationSelection } from "./aggregation-validation.js"
+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 { 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"
 
 const renderDbType = (
   dialect: SqlDialect,
@@ -44,6 +46,15 @@ const renderCastType = (
   }
 }
 
+const renderDdlExpression = (
+  expression: DdlExpressionLike,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression, state, dialect)
+
 const renderColumnDefinition = (
   dialect: SqlDialect,
   state: RenderState,
@@ -52,12 +63,14 @@ const renderColumnDefinition = (
 ): string => {
   const clauses = [
     dialect.quoteIdentifier(columnName),
-    renderDbType(dialect, column.metadata.dbType)
+    column.metadata.ddlType ?? renderDbType(dialect, column.metadata.dbType)
   ]
-  if (column.metadata.generatedValue) {
-    clauses.push(`generated always as (${renderExpression(column.metadata.generatedValue, state, dialect)}) stored`)
+  if (column.metadata.identity) {
+    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`)
   } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderExpression(column.metadata.defaultValue, state, dialect)}`)
+    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, state, dialect)}`)
   }
   if (!column.metadata.nullable) {
     clauses.push("not null")
@@ -65,14 +78,6 @@ const renderColumnDefinition = (
   return clauses.join(" ")
 }
 
-const renderCheckPredicate = (
-  predicate: Expression.Any,
-  state: RenderState,
-  dialect: SqlDialect
-): string => {
-  return renderExpression(predicate, state, dialect)
-}
-
 const renderCreateTableSql = (
   targetSource: QueryAst.FromClause,
   state: RenderState,
@@ -87,21 +92,21 @@ const renderCreateTableSql = (
   for (const option of table[Table.OptionsSymbol]) {
     switch (option.kind) {
       case "primaryKey":
-        definitions.push(`primary key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`)
+        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":
-        definitions.push(`unique (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`)
+        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(
-          `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.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" : ""}` : ""}`
         )
         break
       }
       case "check":
         definitions.push(
-          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderCheckPredicate(option.predicate, state, dialect)})`
+          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderDdlExpression(option.predicate, state, dialect)})${option.noInherit ? " no inherit" : ""}`
         )
         break
       case "index":
@@ -258,6 +263,12 @@ const renderPostgresJsonPathArray = (
   }
 }).join(", ")}]`
 
+const renderPostgresTextLiteral = (
+  value: string,
+  state: RenderState,
+  dialect: SqlDialect
+): string => `cast(${dialect.renderLiteral(value, state)} as text)`
+
 const renderPostgresJsonAccessStep = (
   segment: JsonPath.AnySegment,
   textMode: boolean,
@@ -288,6 +299,10 @@ const renderPostgresJsonValue = (
     : `cast(${rendered} as jsonb)`
 }
 
+const renderPostgresJsonKind = (
+  value: Expression.Any
+): "json" | "jsonb" => value[Expression.TypeId].dbType.kind === "jsonb" ? "jsonb" : "json"
+
 const renderJsonOpaquePath = (
   value: unknown,
   state: RenderState,
@@ -311,6 +326,24 @@ const renderFunctionCall = (
   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 renderedArgs = args.map((arg) => renderExpression(arg, state, dialect)).join(", ")
   if (args.length === 0) {
     switch (name) {
@@ -328,6 +361,7 @@ const renderFunctionCall = (
 }
 
 const renderJsonExpression = (
+  expression: Expression.Any,
   ast: Record<string, unknown>,
   state: RenderState,
   dialect: SqlDialect
@@ -340,6 +374,12 @@ const renderJsonExpression = (
   const base = extractJsonBase(ast)
   const segments = extractJsonPathSegments(ast)
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index")
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression(expression)
+    ? renderPostgresJsonKind(expression)
+    : undefined
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression(base)
+    ? renderPostgresJsonKind(base)
+    : undefined
 
   switch (kind) {
     case "jsonGet":
@@ -363,7 +403,7 @@ const renderJsonExpression = (
         }
         const jsonPathLiteral = dialect.renderLiteral(renderJsonPathStringLiteral(segments), state)
         const queried = `jsonb_path_query_first(${renderPostgresJsonValue(base, state, dialect)}, ${jsonPathLiteral})`
-        return textMode ? `cast(${queried} as text)` : queried
+        return textMode ? `(${queried} #>> '{}')` : queried
       }
       if (dialect.name === "mysql") {
         const extracted = `json_extract(${baseSql}, ${renderMySqlJsonPath(segments, state, dialect)})`
@@ -387,12 +427,12 @@ const renderJsonExpression = (
       }
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| ${renderPostgresJsonPathArray(keys, state, dialect)})`
+          return `(${baseSql} ?| array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& ${renderPostgresJsonPathArray(keys, state, dialect)})`
+          return `(${baseSql} ?& array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
         }
-        return `(${baseSql} ? ${dialect.renderLiteral(keys[0]!, state)})`
+        return `(${baseSql} ? ${renderPostgresTextLiteral(String(keys[0]!), state, dialect)})`
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one"
@@ -423,7 +463,7 @@ const renderJsonExpression = (
         renderExpression(entry.value, state, dialect)
       ])
       if (dialect.name === "postgres") {
-        return `jsonb_build_object(${renderedEntries.join(", ")})`
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`
       }
       if (dialect.name === "mysql") {
         return `json_object(${renderedEntries.join(", ")})`
@@ -436,7 +476,7 @@ const renderJsonExpression = (
         : []
       const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ")
       if (dialect.name === "postgres") {
-        return `jsonb_build_array(${renderedValues})`
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`
       }
       if (dialect.name === "mysql") {
         return `json_array(${renderedValues})`
@@ -470,7 +510,8 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `jsonb_typeof(${renderPostgresJsonValue(base, state, dialect)})`
+        const baseSql = renderExpression(base, state, dialect)
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof(${baseSql})`
       }
       if (dialect.name === "mysql") {
         return `json_type(${renderExpression(base, state, dialect)})`
@@ -481,8 +522,11 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect)
-        return `(case when jsonb_typeof(${jsonb}) = 'array' then jsonb_array_length(${jsonb}) when jsonb_typeof(${jsonb}) = 'object' then jsonb_object_length(${jsonb}) else null end)`
+        const baseSql = renderExpression(base, state, dialect)
+        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`
+        const arrayLength = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_array_length`
+        const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`
+        return `(case when ${typeOf}(${baseSql}) = 'array' then ${arrayLength}(${baseSql}) when ${typeOf}(${baseSql}) = 'object' then (select count(*)::int from ${objectKeys}(${baseSql})) else null end)`
       }
       if (dialect.name === "mysql") {
         return `json_length(${renderExpression(base, state, dialect)})`
@@ -493,8 +537,10 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect)
-        return `(case when jsonb_typeof(${jsonb}) = 'object' then array(select jsonb_object_keys(${jsonb})) else null end)`
+        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)`
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression(base, state, dialect)})`
@@ -505,7 +551,7 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `jsonb_strip_nulls(${renderPostgresJsonValue(base, state, dialect)})`
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_strip_nulls(${renderExpression(base, state, dialect)})`
       }
       unsupportedJsonFeature(dialect, "jsonStripNulls")
       return undefined
@@ -772,7 +818,7 @@ export const renderQueryAst = (
     case "set": {
       const setAst = ast as QueryAst.Ast<Record<string, unknown>, any, "set">
       const base = renderQueryAst(
-        Query.getAst(setAst.setBase as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+        Query.getAst(setAst.setBase as Query.Plan.Any) as QueryAst.Ast<
           Record<string, unknown>,
           any,
           QueryAst.QueryStatement
@@ -785,7 +831,7 @@ export const renderQueryAst = (
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
           const rendered = renderQueryAst(
-            Query.getAst(entry.query as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+            Query.getAst(entry.query as Query.Plan.Any) as QueryAst.Ast<
               Record<string, unknown>,
               any,
               QueryAst.QueryStatement
@@ -812,7 +858,7 @@ export const renderQueryAst = (
       } else if (insertAst.insertSource?.kind === "query") {
         const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
         const renderedQuery = renderQueryAst(
-          Query.getAst(insertAst.insertSource.query as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+          Query.getAst(insertAst.insertSource.query as Query.Plan.Any) as QueryAst.Ast<
             Record<string, unknown>,
             any,
             QueryAst.QueryStatement
@@ -1105,7 +1151,7 @@ const renderSourceReference = (
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "cte") {
     const cte = source as unknown as {
       readonly name: string
-      readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any>
+      readonly plan: Query.Plan.Any
       readonly recursive?: boolean
     }
     if (!state.cteNames.has(cte.name)) {
@@ -1122,7 +1168,7 @@ const renderSourceReference = (
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "derived") {
     const derived = source as unknown as {
       readonly name: string
-      readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any>
+      readonly plan: Query.Plan.Any
     }
     if (!state.cteNames.has(derived.name)) {
       // derived tables are inlined, so no CTE registration is needed
@@ -1132,7 +1178,7 @@ const renderSourceReference = (
   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.QueryPlan<any, any, any, any, any, any, any, any, any>
+      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)}`
   }
@@ -1184,7 +1230,7 @@ export const renderExpression = (
   const rawAst = (expression as Expression.Any & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.Any
   })[ExpressionAst.TypeId] as ExpressionAst.Any | Record<string, unknown>
-  const jsonSql = renderJsonExpression(rawAst as Record<string, unknown>, state, dialect)
+  const jsonSql = renderJsonExpression(expression, rawAst as Record<string, unknown>, state, dialect)
   if (jsonSql !== undefined) {
     return jsonSql
   }
@@ -1201,9 +1247,11 @@ export const renderExpression = (
             : operator === "gt"
               ? ">"
               : ">="
-  switch (ast.kind) {
+    switch (ast.kind) {
     case "column":
-      return `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
+      return ast.tableName.length === 0
+        ? dialect.quoteIdentifier(ast.columnName)
+        : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
     case "literal":
       return dialect.renderLiteral(ast.value, state)
     case "excluded":
@@ -1212,6 +1260,8 @@ export const renderExpression = (
         : `excluded.${dialect.quoteIdentifier(ast.columnName)}`
     case "cast":
       return `cast(${renderExpression(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(".")})`
     case "function":
       return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect)
     case "eq":
@@ -1232,6 +1282,22 @@ export const renderExpression = (
       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":
+      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":
+      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":
+      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":
+      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":
       return dialect.name === "mysql"
         ? `(not (${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)}))`