A better implementation for 'map'

Sources/StructuredQueriesCore/Optional.swift

@@ -275,7 +275,11 @@ extension QueryExpression where QueryValue: _OptionalProtocol {
   public func map<T>(
     _ transform: (SQLQueryExpression<QueryValue.Wrapped>) -> some QueryExpression<T>
   ) -> some QueryExpression<T?> {
-    SQLQueryExpression(transform(SQLQueryExpression(queryFragment)).queryFragment)
+    SQLQueryExpression(
+      """
+      IIF(\(self), \(transform(SQLQueryExpression(queryFragment))), NULL)
+      """
+    )
   }
 
   /// Creates a new optional expression from this one by applying an unwrapped version of this

Tests/StructuredQueriesTests/MapTests.swift

@@ -0,0 +1,54 @@
+import Dependencies
+import Foundation
+import InlineSnapshotTesting
+import SQLite3
+import StructuredQueries
+import StructuredQueriesSQLite
+import StructuredQueriesTestSupport
+import Testing
+import _StructuredQueriesSQLite
+
+extension SnapshotTests {
+  @Suite struct MapTests {
+    @Dependency(\.defaultDatabase) var database
+
+    @Test func mapWithDatabaseFunction() throws {
+      $increment.install(database.handle)
+      try database.execute("""
+        CREATE TABLE "optionalIntegers" (
+          "value" INTEGER
+        ) STRICT
+        """)
+      try database.execute("""
+        INSERT INTO "optionalIntegers" ("value") VALUES (1), (NULL), (3)
+        """)
+
+      assertQuery(
+        OptionalInteger.select {
+          $0.value.map { $increment($0) }
+        }
+      ) {
+        """
+        SELECT IIF("optionalIntegers"."value", "increment"("optionalIntegers"."value"), NULL)
+        FROM "optionalIntegers"
+        """
+      } results: {
+        """
+        ┌─────┐
+        │ 2   │
+        │ nil │
+        │ 4   │
+        └─────┘
+        """
+      }
+    }
+  }
+}
+
+@Table struct OptionalInteger {
+  let value: Int?
+}
+@DatabaseFunction(isDeterministic: true)
+private func increment(_ value: Int) -> Int {
+  value + 1
+}