Compile SQLKit under Embedded Swift

Motivation:

Embedded Swift has no Codable, no reflection, no existential metatypes, and no
`_StringProcessing`. A number of SQLKit declarations depend on one of those and
are the only thing standing between the SwiftNIO-free configuration and a
`wasm32-unknown-wasip1-embedded` build.

The bound-parameter constraint is the interesting case. SQLKit spells it
`Encodable`, but SQLKit itself never encodes a bound value: `SQLBind` hands the
existential to `SQLSerializer.write(bind:)`, which appends it to `binds` and emits
a placeholder. The constraint is a marker, and the actual extraction happens in
the driver.

That makes a vacuous `#if hasFeature(Embedded) public protocol Encodable {}` shim
look attractive — it would leave every use site unchanged. It does not work. The
marker exists precisely to carry a value across the module boundary to a driver
that must get the value back out, and a protocol with no requirements carries
nothing: under Embedded there is no `encode(to:)` to call, no reflection, and no
dynamic cast to fall back on, so the bind path would compile and then be inert.
Shadowing `Swift.Encodable` in a public signature would also collide with the
same shim in other modules and cannot be made `internal`, because the constraint
appears in public and `@inlinable` declarations.

Modifications:

Introduce `SQLBindable`, the constraint used for bound parameter values. It is
`typealias SQLBindable = Encodable` except under Embedded Swift, where it resolves
to a new lightweight `SQLBindValue` protocol carrying a driver-neutral
`SQLDataValue`, with conformances for the standard primitives. `SQLBindValue` is
what replaces `encode(to:)` for the driver.

The public declarations that spelled `some`/`any Encodable & Sendable` for a bound
value now spell `some`/`any SQLBindable & Sendable`. Off Embedded that is the same
type, so this is source- and ABI-compatible. Declarations that take a Codable
*model* rather than a bound value keep saying `Encodable`; they live inside
`!hasFeature(Embedded)` regions, where the two spellings are identical anyway.

Everything else is elision:

- Gate the Codable engine (`SQLQueryEncoder`, `SQLRowDecoder`, `SomeCodingKey`,
  the `SQLCodingUtilities` helpers, and the model-shaped builder overloads
  `set(model:)` / `insert(models:)` / `decode(model:)`) behind
  `#if !hasFeature(Embedded)`.
- Move the generic `withSession(_:)` protocol requirement to an extension default
  under Embedded: a generic method cannot go in a witness table there, which would
  otherwise make `any SQLDatabase` unusable.
- Replace reflection- and existential-dependent paths (metatype casts in
  `SQLDatabaseReportedVersion` and the deprecated shims, description formatting in
  `SQLSerializer`/`SQLQueryString`, the `as?`-based `LIMIT 1` optimization in
  `first()`) with Embedded-safe equivalents.
- `StringHandling`: `trimmingPrefix(_:)` and the regex-backed replacement helper
  come from `_StringProcessing`, which the Embedded stdlib does not ship; fall
  through to the existing hand-rolled implementations there.
- `SQLKitBenchmark` needs XCTest and Codable, so the whole target's contents are
  gated on `!hasFeature(Embedded)`.

Every `#if` encloses the doc comment of the declaration it gates rather than
sitting between the two, which would detach the comment and silently empty the
published documentation for that symbol.

Result:

SQLKit compiles for `wasm32-unknown-wasip1-embedded`.

On every other target the only change to the generated symbol graph is the added
`SQLBindable` typealias: every other symbol is still present, with byte-identical
`docComment` line counts, and `diagnose-api-breaking-changes` reports no
differences.

Building for the Embedded target additionally requires an Embedded-clean
`apple/swift-log`; see the pull request description.

Author: scottmarchant

Sources/SQLKit/Builders/Implementations/SQLAlterTableBuilder.swift

@@ -45,7 +45,9 @@ public final class SQLAlterTableBuilder: SQLQueryBuilder {
     @inlinable
     @discardableResult
     public func column(_ column: String, type dataType: SQLDataType, _ constraints: [SQLColumnConstraintAlgorithm]) -> Self {
-        self.column(SQLIdentifier(column), type: dataType, constraints)
+        // Box each element explicitly: the implicit `[Concrete]`→`[any SQLExpression]` array
+        // conversion is a dynamic cast, which Embedded Swift forbids.
+        self.column(SQLIdentifier(column), type: dataType, constraints.map { $0 as any SQLExpression })
     }
 
     /// Add a new column to the table.
@@ -81,7 +83,7 @@ public final class SQLAlterTableBuilder: SQLQueryBuilder {
     @inlinable
     @discardableResult
     public func modifyColumn(_ column: String, type dataType: SQLDataType, _ constraints: [SQLColumnConstraintAlgorithm]) -> Self {
-        self.modifyColumn(SQLIdentifier(column), type: dataType, constraints)
+        self.modifyColumn(SQLIdentifier(column), type: dataType, constraints.map { $0 as any SQLExpression })
     }
 
     /// Change an existing column's type and constraints.

Sources/SQLKit/Builders/Implementations/SQLConflictUpdateBuilder.swift

@@ -32,6 +32,8 @@ public final class SQLConflictUpdateBuilder: SQLColumnUpdateBuilder, SQLPredicat
         return self
     }
 
+    // Codable model encoding (SQLQueryEncoder) is unavailable in Embedded Swift.
+    #if !hasFeature(Embedded)
     /// Encodes the given `Encodable` value to a sequence of key-value pairs and adds an assignment
     /// for each pair which uses the values each column was given in the original `INSERT` query's
     /// `VALUES` list.
@@ -75,4 +77,5 @@ public final class SQLConflictUpdateBuilder: SQLColumnUpdateBuilder, SQLPredicat
     ) throws -> Self {
         try encoder.encode(model).reduce(self) { $0.set(excludedValueOf: $1.0) }
     }
+    #endif  // !hasFeature(Embedded)
 }

Sources/SQLKit/Builders/Implementations/SQLCreateTableBuilder.swift

@@ -37,7 +37,7 @@ public final class SQLCreateTableBuilder: SQLQueryBuilder {
     @inlinable
     @discardableResult
     public func column(_ column: String, type dataType: SQLDataType, _ constraints: [SQLColumnConstraintAlgorithm]) -> Self {
-        self.column(SQLIdentifier(column), type: dataType, constraints)
+        self.column(SQLIdentifier(column), type: dataType, constraints.map { $0 as any SQLExpression })
     }
 
     /// Add a new column by name, type, and constraints.
@@ -66,7 +66,9 @@ public final class SQLCreateTableBuilder: SQLQueryBuilder {
     @inlinable
     @discardableResult
     public func column(definitions: [SQLColumnDefinition]) -> SQLCreateTableBuilder {
-        self.columns.append(contentsOf: definitions)
+        // Box each element explicitly: the implicit `[Concrete]`→`[any SQLExpression]` array
+        // conversion is a dynamic cast, which Embedded Swift forbids.
+        self.columns.append(contentsOf: definitions.map { $0 as any SQLExpression })
         return self
     }
 
@@ -125,7 +127,9 @@ extension SQLCreateTableBuilder {
     @inlinable
     @discardableResult
     public func primaryKey(_ columns: [String], named constraintName: String? = nil) -> Self {
-        self.primaryKey(columns.map(SQLIdentifier.init(_:)), named: constraintName.map(SQLIdentifier.init(_:)))
+        // Box each element to `any SQLExpression`: the implicit `[Concrete]`/`Concrete?` →
+        // `[any SQLExpression]`/`(any SQLExpression)?` conversions are dynamic casts (forbidden in embedded).
+        self.primaryKey(columns.map { SQLIdentifier($0) as any SQLExpression }, named: constraintName.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Add a `PRIMARY KEY` constraint to the table.
@@ -162,7 +166,7 @@ extension SQLCreateTableBuilder {
     @inlinable
     @discardableResult
     public func unique(_ columns: [String], named constraintName: String? = nil) -> Self {
-        self.unique(columns.map(SQLIdentifier.init(_:)), named: constraintName.map(SQLIdentifier.init(_:)))
+        self.unique(columns.map { SQLIdentifier($0) as any SQLExpression }, named: constraintName.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Add a `UNIQUE` constraint to the table.
@@ -188,7 +192,7 @@ extension SQLCreateTableBuilder {
     @inlinable
     @discardableResult
     public func check(_ expression: any SQLExpression, named constraintName: String? = nil) -> Self {
-        self.check(expression, named: constraintName.map(SQLIdentifier.init(_:)))
+        self.check(expression, named: constraintName.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Add a `CHECK` constraint to the table.
@@ -226,10 +230,10 @@ extension SQLCreateTableBuilder {
         named constraintName: String? = nil
     ) -> Self {
         self.foreignKey(
-            columns.map(SQLIdentifier.init(_:)),
-            references: SQLIdentifier(foreignTable), foreignColumns.map(SQLIdentifier.init(_:)),
+            columns.map { SQLIdentifier($0) as any SQLExpression },
+            references: SQLIdentifier(foreignTable), foreignColumns.map { SQLIdentifier($0) as any SQLExpression },
             onDelete: onDelete, onUpdate: onUpdate,
-            named: constraintName.map(SQLIdentifier.init(_:))
+            named: constraintName.map { SQLIdentifier($0) as any SQLExpression }
         )
     }
 

Sources/SQLKit/Builders/Implementations/SQLCreateTriggerBuilder.swift

@@ -52,7 +52,7 @@ public final class SQLCreateTriggerBuilder: SQLQueryBuilder {
     @inlinable
     @discardableResult
     public func columns(_ columns: [String]) -> Self {
-        self.columns(columns.map(SQLIdentifier.init(_:)))
+        self.columns(columns.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Specify the columns to which the trigger applies.

Sources/SQLKit/Builders/Implementations/SQLInsertBuilder.swift

@@ -39,6 +39,8 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
         self.database = database
     }
 
+    // Codable model encoding (SQLQueryEncoder) is unavailable in Embedded Swift.
+    #if !hasFeature(Embedded)
     /// Use an `Encodable` value to generate a row to insert and add that row to the query.
     ///
     /// Example usage:
@@ -216,7 +218,8 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
         }
         return self
     }
-    
+    #endif  // !hasFeature(Embedded)
+
     /// Specify mutiple columns to be included in the list of columns for the query.
     ///
     /// Overwrites any previously specified column list.
@@ -232,7 +235,7 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
     @inlinable
     @discardableResult
     public func columns(_ columns: [String]) -> Self {
-        self.columns(columns.map(SQLIdentifier.init(_:)))
+        self.columns(columns.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Specify mutiple columns to be included in the list of columns for the query.
@@ -258,15 +261,15 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
     @inlinable
     @discardableResult
     @_disfavoredOverload
-    public func values(_ values: any Encodable & Sendable...) -> Self {
+    public func values(_ values: any SQLBindable & Sendable...) -> Self {
         self.values(values)
     }
 
     /// Add a set of values to be inserted as a single row.
     @inlinable
     @discardableResult
-    public func values(_ values: [any Encodable & Sendable]) -> Self {
-        self.values(values.map { SQLBind($0) })
+    public func values(_ values: [any SQLBindable & Sendable]) -> Self {
+        self.values(values.map { SQLBind($0) as any SQLExpression })
     }
 
     /// Add a set of values to be inserted as a single row.
@@ -334,7 +337,7 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
     @inlinable
     @discardableResult
     public func ignoringConflicts(with targetColumns: [String] = []) -> Self {
-        self.ignoringConflicts(with: targetColumns.map(SQLIdentifier.init(_:)))
+        self.ignoringConflicts(with: targetColumns.map { SQLIdentifier($0) as any SQLExpression })
     }
 
     /// Specify that constraint violations for the key over the given columns should cause the conflicting
@@ -365,7 +368,7 @@ public final class SQLInsertBuilder: SQLQueryBuilder, SQLReturningBuilder/*, SQL
         with targetColumns: [String] = [],
         `do` updatePredicate: (SQLConflictUpdateBuilder) throws -> SQLConflictUpdateBuilder
     ) rethrows -> Self {
-        try self.onConflict(with: targetColumns.map(SQLIdentifier.init(_:)), do: updatePredicate)
+        try self.onConflict(with: targetColumns.map { SQLIdentifier($0) as any SQLExpression }, do: updatePredicate)
     }
 
     /// Specify that constraint violations for the key over the given column should cause the conflicting

Sources/SQLKit/Builders/Prototypes/SQLColumnUpdateBuilder.swift

@@ -7,6 +7,8 @@ public protocol SQLColumnUpdateBuilder: AnyObject {
 }
 
 extension SQLColumnUpdateBuilder {
+    // Codable model encoding (SQLQueryEncoder) is unavailable in Embedded Swift.
+    #if !hasFeature(Embedded)
     /// Using a default-configured ``SQLQueryEncoder``, transform the provided model into a series of key/value
     /// pairs and add an assignment for each pair.
     ///
@@ -66,6 +68,7 @@ extension SQLColumnUpdateBuilder {
     ) throws -> Self {
         try encoder.encode(model).reduce(self) { $0.set(SQLColumn($1.0), to: $1.1) }
     }
+    #endif  // !hasFeature(Embedded)
 
     /// Add an assignment setting the named column to the provided `Encodable` value.
     ///
@@ -76,7 +79,7 @@ extension SQLColumnUpdateBuilder {
     ///   - bind: The value to assign to the named column.
     @inlinable
     @discardableResult
-    public func set(_ column: String, to bind: any Encodable & Sendable) -> Self {
+    public func set(_ column: String, to bind: any SQLBindable & Sendable) -> Self {
         self.set(SQLColumn(column), to: SQLBind(bind))
     }
 
@@ -102,7 +105,7 @@ extension SQLColumnUpdateBuilder {
     ///   - bind: The value to assign to the given column.
     @inlinable
     @discardableResult
-    public func set(_ column: any SQLExpression, to bind: any Encodable & Sendable) -> Self {
+    public func set(_ column: any SQLExpression, to bind: any SQLBindable & Sendable) -> Self {
         self.set(column, to: SQLBind(bind))
     }
 

Sources/SQLKit/Builders/Prototypes/SQLCommonTableExpressionBuilder.swift

@@ -34,7 +34,7 @@ extension SQLCommonTableExpressionBuilder {
     @inlinable
     @discardableResult
     public func with(_ name: some StringProtocol, columns: [String], as query: some SQLExpression) -> Self {
-        self.with(name, columns: columns.map(SQLIdentifier.init(_:)), as: query)
+        self.with(name, columns: columns.map { SQLIdentifier($0) as any SQLExpression }, as: query)
     }
 
     /// Specify a subquery to include as a _recursive_ common table expression, for use elsewhere in
@@ -70,7 +70,7 @@ extension SQLCommonTableExpressionBuilder {
     @inlinable
     @discardableResult
     public func with(recursive name: some StringProtocol, columns: [String], as query: some SQLExpression) -> Self {
-        self.with(recursive: name, columns: columns.map(SQLIdentifier.init(_:)), as: query)
+        self.with(recursive: name, columns: columns.map { SQLIdentifier($0) as any SQLExpression }, as: query)
     }
 
     // MARK: - String name, expression columns
@@ -170,7 +170,7 @@ extension SQLCommonTableExpressionBuilder {
     @inlinable
     @discardableResult
     public func with(_ name: some SQLExpression, columns: [String], as query: some SQLExpression) -> Self {
-        self.with(name, columns: columns.map(SQLIdentifier.init(_:)), as: query)
+        self.with(name, columns: columns.map { SQLIdentifier($0) as any SQLExpression }, as: query)
     }
 
     /// Specify a subquery to include as a _recursive_ common table expression, for use elsewhere in
@@ -206,7 +206,7 @@ extension SQLCommonTableExpressionBuilder {
     @inlinable
     @discardableResult
     public func with(recursive name: some SQLExpression, columns: [String], as query: some SQLExpression) -> Self {
-        self.with(recursive: name, columns: columns.map(SQLIdentifier.init(_:)), as: query)
+        self.with(recursive: name, columns: columns.map { SQLIdentifier($0) as any SQLExpression }, as: query)
     }
 
     // MARK: - Expression name, expression columns

Sources/SQLKit/Builders/Prototypes/SQLPredicateBuilder.swift

@@ -23,7 +23,7 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" = $0 ["Earth"]
     @inlinable
     @discardableResult
-    public func `where`(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: some Encodable & Sendable) -> Self {
+    public func `where`(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: some SQLBindable & Sendable) -> Self {
         self.where(SQLColumn(lhs), op, SQLBind(rhs))
     }
 
@@ -36,8 +36,8 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" IN ($0, $1) ["Earth", "Mars"]
     @inlinable
     @discardableResult
-    public func `where`(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: [some Encodable & Sendable]) -> Self {
-        self.where(SQLColumn(lhs), op, SQLBind.group(rhs))
+    public func `where`(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: [some SQLBindable & Sendable]) -> Self {
+        self.where(SQLColumn(lhs), op, SQLBind.group(rhs.map { $0 as any SQLBindable & Sendable }))
     }
 
     /// Adds a column to encodable comparison to this builder's `WHERE` clause by `AND`ing.
@@ -49,7 +49,7 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" = $0 ["Earth"]
     @inlinable
     @discardableResult
-    public func `where`(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: some Encodable & Sendable) -> Self {
+    public func `where`(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: some SQLBindable & Sendable) -> Self {
         self.where(SQLColumn(lhs), op, SQLBind(rhs))
     }
 
@@ -62,8 +62,8 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" IN ($0, $1) ["Earth", "Mars"]
     @inlinable
     @discardableResult
-    public func `where`(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: [some Encodable & Sendable]) -> Self {
-        self.where(SQLColumn(lhs), op, SQLBind.group(rhs))
+    public func `where`(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: [some SQLBindable & Sendable]) -> Self {
+        self.where(SQLColumn(lhs), op, SQLBind.group(rhs.map { $0 as any SQLBindable & Sendable }))
     }
 
     // MARK: - Column/column comparison
@@ -154,7 +154,7 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" = $0 ["Earth"]
     @inlinable
     @discardableResult
-    public func orWhere(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: some Encodable & Sendable) -> Self {
+    public func orWhere(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: some SQLBindable & Sendable) -> Self {
         self.orWhere(SQLColumn(lhs), op, SQLBind(rhs))
     }
 
@@ -167,22 +167,22 @@ extension SQLPredicateBuilder {
     ///     SELECT * FROM "planets" WHERE "name" IN ($0, $1) ["Earth", "Mars"]
     @inlinable
     @discardableResult
-    public func orWhere(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: [some Encodable & Sendable]) -> Self {
-        self.orWhere(SQLColumn(lhs), op, SQLBind.group(rhs))
+    public func orWhere(_ lhs: String, _ op: SQLBinaryOperator, _ rhs: [some SQLBindable & Sendable]) -> Self {
+        self.orWhere(SQLColumn(lhs), op, SQLBind.group(rhs.map { $0 as any SQLBindable & Sendable }))
     }
 
     /// Adds a column to encodable comparison to this builder's `WHERE` clause by `OR`ing.
     @inlinable
     @discardableResult
-    public func orWhere(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: some Encodable & Sendable) -> Self {
+    public func orWhere(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: some SQLBindable & Sendable) -> Self {
         self.orWhere(SQLColumn(lhs), op, SQLBind(rhs))
     }
 
     /// Adds a column to encodable array comparison to this builder's `WHERE` clause by `OR`ing.
     @inlinable
     @discardableResult
-    public func orWhere(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: [some Encodable & Sendable]) -> Self {
-        self.orWhere(SQLColumn(lhs), op, SQLBind.group(rhs))
+    public func orWhere(_ lhs: SQLIdentifier, _ op: SQLBinaryOperator, _ rhs: [some SQLBindable & Sendable]) -> Self {
+        self.orWhere(SQLColumn(lhs), op, SQLBind.group(rhs.map { $0 as any SQLBindable & Sendable }))
     }
 
     // MARK: - Column/column comparison

Sources/SQLKit/Builders/Prototypes/SQLQueryFetcher.swift

@@ -1,5 +1,6 @@
 // `EventLoopFuture` is unavailable where SwiftNIO is not linked. The `async` `first()`/`all()`/
-// `run(_:)` families further down are unconditional and carry the whole surface there.
+// `run(_:)` families further down are unconditional and carry the whole surface there; their
+// `<D: Decodable>` overloads additionally drop out in Embedded Swift, which has no Codable.
 #if canImport(NIOCore)
 import class NIOCore.EventLoopFuture
 #endif
@@ -80,6 +81,7 @@ extension SQLQueryFetcher {
 // MARK: - First (async)
 
 extension SQLQueryFetcher {
+    #if !hasFeature(Embedded)
     /// Returns the named column from the first output row, if any, decoded as a given type.
     ///
     /// - Parameters:
@@ -129,6 +131,7 @@ extension SQLQueryFetcher {
     public func first<D: Decodable>(decoding type: D.Type, with decoder: SQLRowDecoder) async throws -> D? {
         try await self.first()?.decode(model: D.self, with: decoder)
     }
+    #endif  // !hasFeature(Embedded)
 
     /// Returns the first output row, if any.
     /// 
@@ -142,7 +145,11 @@ extension SQLQueryFetcher {
     /// - Returns: The first output row, if any.
     @inlinable
     public func first() async throws -> Optional<any SQLRow> {
+        // `as?` to a different existential is a dynamic cast (unavailable in embedded); skip the
+        // LIMIT-1 optimization there (correctness is unaffected; we just fetch and take the first).
+        #if !hasFeature(Embedded)
         (self as? any SQLPartialResultBuilder)?.limit(1)
+        #endif
         nonisolated(unsafe) var rows = [any SQLRow]()
         try await self.run { if rows.isEmpty { rows.append($0) } }
         return rows.first
@@ -218,6 +225,7 @@ extension SQLQueryFetcher {
 // MARK: - All (async)
 
 extension SQLQueryFetcher {
+    #if !hasFeature(Embedded)
     /// Returns the named column from each output row, if any, decoded as a given type.
     ///
     /// - Parameters:
@@ -267,6 +275,7 @@ extension SQLQueryFetcher {
     public func all<D: Decodable>(decoding type: D.Type, with decoder: SQLRowDecoder) async throws -> [D] {
         try await self.all().map { try $0.decode(model: D.self, with: decoder) }
     }
+    #endif  // !hasFeature(Embedded)
 
     /// Returns all output rows, if any.
     ///
@@ -353,6 +362,7 @@ extension SQLQueryFetcher {
 // MARK: - Run (async)
 
 extension SQLQueryFetcher {
+    #if !hasFeature(Embedded)
     /// Using a default-configured ``SQLRowDecoder``, call the provided handler closure with the result of decoding
     /// each output row, if any, as a given type.
     ///
@@ -401,6 +411,7 @@ extension SQLQueryFetcher {
     ) async throws {
         try await self.run { row in handler(Result { try row.decode(model: D.self, with: decoder) }) }
     }
+    #endif  // !hasFeature(Embedded)
 
     /// Run the query specified by the builder, calling the provided handler closure with each output row, if any, as
     /// it is received.

Sources/SQLKit/Builders/Prototypes/SQLReturningBuilder.swift

@@ -10,7 +10,7 @@ extension SQLReturningBuilder {
     /// - Returns: A ``SQLReturningResultBuilder`` which must be used to execute the query.
     @inlinable
     public func returning(_ columns: String...) -> SQLReturningResultBuilder<Self> {
-        self.returning(columns.map { SQLColumn($0 == "*" ? SQLLiteral.all : SQLIdentifier($0)) })
+        self.returning(columns.map { SQLColumn($0 == "*" ? SQLLiteral.all : SQLIdentifier($0)) as any SQLExpression })
     }
 
     /// Specify a list of columns to be returned as the result of the query.