Added support for the union query clause

Sources/SQLite/Typed/Query.swift

@@ -180,6 +180,27 @@ extension QueryType {
         return query
     }
 
+    // MARK: UNION
+
+    /// Adds a `UNION` clause to the query.
+    ///
+    ///     let users = Table("users")
+    ///     let email = Expression<String>("email")
+    ///
+    ///     users.filter(email == "alice@example.com").union(users.filter(email == "sally@example.com"))
+    ///     // SELECT * FROM "users" WHERE email = 'alice@example.com' UNION SELECT * FROM "users" WHERE email = 'sally@example.com'
+    ///
+    /// - Parameters:
+    ///
+    ///   - table: A query representing the other table.
+    ///
+    /// - Returns: A query with the given `UNION` clause applied.
+    public func union(_ table: QueryType) -> Self {
+        var query = self
+        query.clauses.union.append(table)
+        return query
+    }
+
     // MARK: JOIN
 
     /// Adds a `JOIN` clause to the query.
@@ -565,6 +586,19 @@ extension QueryType {
             Expression<Void>(literal: "OFFSET \(offset)")
         ])
     }
+
+    fileprivate var unionClause: Expressible? {
+        guard !clauses.union.isEmpty else {
+            return nil
+        }
+
+        return " ".join(clauses.union.map { query in
+            " ".join([
+                Expression<Void>(literal: "UNION"),
+                query
+            ])
+        })
+    }
 
     // MARK: -
 
@@ -779,6 +813,7 @@ extension QueryType {
             joinClause,
             whereClause,
             groupByClause,
+            unionClause,
             orderClause,
             limitOffsetClause
         ]
@@ -1154,6 +1189,8 @@ public struct QueryClauses {
     var order = [Expressible]()
 
     var limit: (length: Int, offset: Int?)?
+
+    var union = [QueryType]()
 
     fileprivate init(_ name: String, alias: String?, database: String?) {
         self.from = (name, alias, database)

Tests/SQLiteTests/QueryTests.swift

@@ -361,5 +361,25 @@ class QueryIntegrationTests : SQLiteTestCase {
         let changes = try! db.run(users.delete())
         XCTAssertEqual(0, changes)
     }
-
+
+    func test_union() throws {
+        let expectedIDs = [
+            try db.run(users.insert(email <- "alice@example.com")),
+            try db.run(users.insert(email <- "sally@example.com"))
+        ]
+
+        let query1 = users.filter(email == "alice@example.com")
+        let query2 = users.filter(email == "sally@example.com")
+
+        let actualIDs = try db.prepare(query1.union(query2)).map { $0[id] }
+        XCTAssertEqual(expectedIDs, actualIDs)
+
+        let query3 = users.select(users[*], Expression<Int>(literal: "1 AS weight")).filter(email == "sally@example.com")
+        let query4 = users.select(users[*], Expression<Int>(literal: "2 AS weight")).filter(email == "alice@example.com")
+
+        print(query3.union(query4).order(Expression<Int>(literal: "weight")).asSQL())
+
+        let orderedIDs = try db.prepare(query3.union(query4).order(Expression<Int>(literal: "weight"), email)).map { $0[id] }
+        XCTAssertEqual(Array(expectedIDs.reversed()), orderedIDs)
+    }
 }