Add support for explicit schema names

Sources/StructuredQueries/Macros.swift

@@ -16,12 +16,16 @@ import StructuredQueriesCore
   named(init(_:)),
   named(init(decoder:)),
   named(QueryValue),
+  named(schemaName),
   named(tableName)
 )
 @attached(
   memberAttribute
 )
-public macro Table(_ name: String? = nil) =
+public macro Table(
+  _ name: String? = nil,
+  schema schemaName: String? = nil
+) =
   #externalMacro(
     module: "StructuredQueriesMacros",
     type: "TableMacro"

Sources/StructuredQueriesCore/QueryFragment.swift

@@ -262,6 +262,10 @@ extension QueryFragment: ExpressibleByStringInterpolation {
     ///
     /// - Parameter table: A table.
     public mutating func appendInterpolation<T: Table>(_ table: T.Type) {
+      if let schemaName = table.schemaName {
+        appendInterpolation(quote: schemaName)
+        appendLiteral(".")
+      }
       appendInterpolation(quote: table.tableAlias ?? table.tableName)
     }
 

Sources/StructuredQueriesCore/Statements/CommonTableExpression.swift

@@ -39,10 +39,10 @@ public struct With<QueryValue>: Statement {
 
 public struct CommonTableExpressionClause: QueryExpression {
   public typealias QueryValue = ()
-  let tableName: String
+  let tableName: QueryFragment
   let select: QueryFragment
   public var queryFragment: QueryFragment {
-    "\(quote: tableName) AS (\(.newline)\(select.indented())\(.newline))"
+    "\(tableName) AS (\(.newline)\(select.indented())\(.newline))"
   }
 }
 
@@ -55,7 +55,7 @@ public enum CommonTableExpressionBuilder {
   public static func buildExpression<CTETable: Table>(
     _ expression: some PartialSelectStatement<CTETable>
   ) -> CommonTableExpressionClause {
-    CommonTableExpressionClause(tableName: CTETable.tableName, select: expression.query)
+    CommonTableExpressionClause(tableName: "\(CTETable.self)", select: expression.query)
   }
 
   public static func buildBlock(

Sources/StructuredQueriesCore/Statements/Delete.swift

@@ -135,7 +135,11 @@ extension Delete: Statement {
   public typealias QueryValue = Returning
 
   public var query: QueryFragment {
-    var query: QueryFragment = "DELETE FROM \(quote: From.tableName)"
+    var query: QueryFragment = "DELETE FROM "
+    if let schemaName = From.schemaName {
+      query.append("\(quote: schemaName).")
+    }
+    query.append("\(quote: From.tableName)")
     if let tableAlias = From.tableAlias {
       query.append(" AS \(quote: tableAlias)")
     }

Sources/StructuredQueriesCore/Statements/Insert.swift

@@ -403,7 +403,11 @@ extension Insert: Statement {
     if let conflictResolution {
       query.append(" OR \(conflictResolution)")
     }
-    query.append(" INTO \(quote: Into.tableName)")
+    query.append(" INTO ")
+    if let schemaName = Into.schemaName {
+      query.append("\(quote: schemaName).")
+    }
+    query.append("\(quote: Into.tableName)")
     if let tableAlias = Into.tableAlias {
       query.append(" AS \(quote: tableAlias)")
     }

Sources/StructuredQueriesCore/Statements/Select.swift

@@ -1410,7 +1410,11 @@ extension Select: SelectStatement {
       query.append(" DISTINCT")
     }
     query.append(" \(columns.joined(separator: ", "))")
-    query.append("\(.newlineOrSpace)FROM \(quote: From.tableName)")
+    query.append("\(.newlineOrSpace)FROM ")
+    if let schemaName = From.schemaName {
+      query.append("\(quote: schemaName).")
+    }
+    query.append("\(quote: From.tableName)")
     if let tableAlias = From.tableAlias {
       query.append(" AS \(quote: tableAlias)")
     }

Sources/StructuredQueriesCore/Statements/Update.swift

@@ -196,11 +196,14 @@ extension Update: Statement {
     guard !updates.isEmpty
     else { return "" }
 
-    var query: QueryFragment = "UPDATE"
+    var query: QueryFragment = "UPDATE "
     if let conflictResolution {
-      query.append(" OR \(conflictResolution)")
+      query.append("OR \(conflictResolution) ")
     }
-    query.append(" \(quote: From.tableName)")
+    if let schemaName = From.schemaName {
+      query.append("\(quote: schemaName).")
+    }
+    query.append("\(quote: From.tableName)")
     if let tableAlias = From.tableAlias {
       query.append(" AS \(quote: tableAlias)")
     }

Sources/StructuredQueriesCore/Table.swift

@@ -21,6 +21,9 @@ public protocol Table: QueryRepresentable where TableColumns.QueryValue == Self
   /// This property should always return `nil` unless called on a ``TableAlias``.
   static var tableAlias: String? { get }
 
+  /// The table schema's name.
+  static var schemaName: String? { get }
+
   /// A select statement for this table.
   ///
   /// The default implementation of this property returns a fully unscoped query for the table
@@ -90,6 +93,10 @@ extension Table {
     nil
   }
 
+  public static var schemaName: String? {
+    nil
+  }
+
   /// Returns a table column to the resulting value of a given key path.
   ///
   /// Allows, _e.g._ `Reminder.columns.id` to be abbreviated `Reminder.id`, which is useful when

Sources/StructuredQueriesMacros/TableMacro.swift

@@ -49,32 +49,56 @@ extension TableMacro: ExtensionMacro {
     let selfRewriter = SelfRewriter(
       selfEquivalent: type.as(IdentifierTypeSyntax.self)?.name ?? "QueryValue"
     )
-    let tableName: ExprSyntax
-    if case let .argumentList(arguments) = node.arguments,
-      let expression = arguments.first?.expression
-    {
-      if node.attributeName.identifier == "_Draft" {
-        let memberAccess = expression.cast(MemberAccessExprSyntax.self)
-        let base = memberAccess.base!
-        draftTableType = TypeSyntax("\(base)")
-        tableName = "\(base).tableName"
-      } else {
-        if !expression.isNonEmptyStringLiteral {
-          diagnostics.append(
-            Diagnostic(
-              node: expression,
-              message: MacroExpansionErrorMessage("Argument must be a non-empty string literal")
-            )
-          )
+    var schemaName: ExprSyntax?
+    var tableName = ExprSyntax(
+      StringLiteralExprSyntax(
+        content: declaration.name.trimmed.text.lowerCamelCased().pluralized()
+      )
+    )
+    if case let .argumentList(arguments) = node.arguments {
+      for argumentIndex in arguments.indices {
+        let argument = arguments[argumentIndex]
+        switch argument.label {
+        case nil:
+          if node.attributeName.identifier == "_Draft" {
+            let memberAccess = argument.expression.cast(MemberAccessExprSyntax.self)
+            let base = memberAccess.base!
+            draftTableType = TypeSyntax("\(base)")
+            tableName = "\(base).tableName"
+          } else {
+            if !argument.expression.isNonEmptyStringLiteral {
+              diagnostics.append(
+                Diagnostic(
+                  node: argument.expression,
+                  message: MacroExpansionErrorMessage("Argument must be a non-empty string literal")
+                )
+              )
+            }
+            tableName = argument.expression.trimmed
+          }
+
+        case let .some(label) where label.text == "schema":
+          if node.attributeName.identifier == "_Draft" {
+            let memberAccess = argument.expression.cast(MemberAccessExprSyntax.self)
+            let base = memberAccess.base!
+            draftTableType = TypeSyntax("\(base)")
+            schemaName = "\(base).schemaName"
+          } else {
+            if !argument.expression.isNonEmptyStringLiteral {
+              diagnostics.append(
+                Diagnostic(
+                  node: argument.expression,
+                  message: MacroExpansionErrorMessage("Argument must be a non-empty string literal")
+                )
+              )
+            }
+            schemaName = argument.expression.trimmed
+          }
+
+        case let argument?:
+          fatalError("Unexpected argument: \(argument)")
         }
-        tableName = expression.trimmed
       }
-    } else {
-      tableName = ExprSyntax(
-        StringLiteralExprSyntax(
-          content: declaration.name.trimmed.text.lowerCamelCased().pluralized()
-        )
-      )
     }
     for member in declaration.memberBlock.members {
       guard
@@ -545,6 +569,12 @@ extension TableMacro: ExtensionMacro {
     }
 
     var typeAliases: [DeclSyntax] = []
+    var letSchemaName: DeclSyntax?
+    if let schemaName {
+      letSchemaName = """
+        public static let schemaName: Swift.String? = \(schemaName)
+        """
+    }
     var initDecoder: DeclSyntax?
     if declaration.hasMacroApplication("Selection") {
       conformances.append("\(moduleName).PartialSelectStatement")
@@ -579,7 +609,7 @@ extension TableMacro: ExtensionMacro {
         }
         }\(draft)\(typeAliases, separator: "\n")
         public static let columns = TableColumns()
-        public static let tableName = \(tableName)\(initDecoder)\(initFromOther)
+        public static let tableName = \(tableName)\(letSchemaName)\(initDecoder)\(initFromOther)
         }
         """
       )

Sources/StructuredQueriesTestSupport/AssertQuery.swift

@@ -97,6 +97,22 @@ public func assertQuery<each V: QueryRepresentable, S: Statement<(repeat each V)
         line: line,
         column: column
       )
+    } else {
+      assertInlineSnapshot(
+        of: table,
+        as: .lines,
+        message: "Results did not match",
+        syntaxDescriptor: InlineSnapshotSyntaxDescriptor(
+          trailingClosureLabel: "results",
+          trailingClosureOffset: snapshotTrailingClosureOffset + 1
+        ),
+        matches: nil,
+        fileID: fileID,
+        file: filePath,
+        function: function,
+        line: line,
+        column: column
+      )
     }
   } catch {
     assertInlineSnapshot(

Tests/StructuredQueriesMacrosTests/TableMacroTests.swift

@@ -198,15 +198,15 @@ extension SnapshotTests {
     @Test func tableNameEmpty() {
       assertMacro {
         """
-        @Table(nil)
+        @Table("")
         struct Foo {
           var bar: Int
         }
         """
       } diagnostics: {
         """
-        @Table(nil)
-               ┬──
+        @Table("")
+               ┬─
                ╰─ 🛑 Argument must be a non-empty string literal
         struct Foo {
           var bar: Int
@@ -215,6 +215,83 @@ extension SnapshotTests {
       }
     }
 
+    @Test func schemaName() {
+      assertMacro {
+        """
+        @Table("bar", schema: "foo")
+        struct Bar {
+          var baz: Int
+        }
+        """
+      } expansion: {
+        #"""
+        struct Bar {
+          var baz: Int
+        }
+
+        extension Bar: StructuredQueries.Table {
+          public struct TableColumns: StructuredQueries.TableDefinition {
+            public typealias QueryValue = Bar
+            public let baz = StructuredQueries.TableColumn<QueryValue, Int>("baz", keyPath: \QueryValue.baz)
+            public static var allColumns: [any StructuredQueries.TableColumnExpression] {
+              [QueryValue.columns.baz]
+            }
+          }
+          public static let columns = TableColumns()
+          public static let tableName = "bar"
+          public static let schemaName: Swift.String? = "foo"
+          public init(decoder: inout some StructuredQueries.QueryDecoder) throws {
+            let baz = try decoder.decode(Int.self)
+            guard let baz else {
+              throw QueryDecodingError.missingRequiredColumn
+            }
+            self.baz = baz
+          }
+        }
+        """#
+      }
+    }
+
+    @Test func schemaNameNil() {
+      assertMacro {
+        """
+        @Table(schema: nil)
+        struct Foo {
+          var bar: Int
+        }
+        """
+      } diagnostics: {
+        """
+        @Table(schema: nil)
+                       ┬──
+                       ╰─ 🛑 Argument must be a non-empty string literal
+        struct Foo {
+          var bar: Int
+        }
+        """
+      }
+    }
+
+    @Test func schemaNameEmpty() {
+      assertMacro {
+        """
+        @Table(schema: "")
+        struct Foo {
+          var bar: Int
+        }
+        """
+      } diagnostics: {
+        """
+        @Table(schema: "")
+                       ┬─
+                       ╰─ 🛑 Argument must be a non-empty string literal
+        struct Foo {
+          var bar: Int
+        }
+        """
+      }
+    }
+
     @Test func literals() {
       assertMacro {
         """