Basic subquery support

Signed-off-by: Stephen Celis <[email protected]>

Author: stephencelis

SQLite Tests/QueryTests.swift

@@ -54,6 +54,18 @@ class QueryTests: XCTestCase {
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
+    func test_select_withSubquery() {
+        let subquery = users.select(id)
+
+        var query = users.select(subquery)
+        var SQL = "SELECT (SELECT \"id\" FROM \"users\") FROM \"users\""
+        ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
+
+        query = users.select(subquery.alias("u"))
+        SQL = "SELECT (SELECT \"id\" FROM (\"users\") AS \"u\") AS \"u\" FROM \"users\""
+        ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
+    }
+
     func test_join_compilesJoinClause() {
         let managers = db["users"].alias("managers")
 
@@ -117,6 +129,28 @@ class QueryTests: XCTestCase {
         ExpectExecutions(db, [SQL: 1]) { _ in for row in query { println(row) } }
     }
 
+    func test_join_withSubquery_joinsSubquery() {
+        let maxId = max(id).alias("max_id")
+        let subquery = users.select(maxId).group(age)
+        let query = users.join(subquery, on: maxId == id)
+
+        let SQL = "SELECT * FROM \"users\" " +
+            "INNER JOIN (SELECT (max(\"id\")) AS \"max_id\" FROM \"users\" GROUP BY \"age\") " +
+            "ON (\"max_id\" = \"id\")"
+        ExpectExecutions(db, [SQL: 1]) { _ in for row in query { println(row) } }
+    }
+
+    func test_join_withAliasedSubquery_joinsSubquery() {
+        let maxId = max(id).alias("max_id")
+        let subquery = users.select(maxId).group(age).alias("u")
+        let query = users.join(subquery, on: subquery[maxId] == id)
+
+        let SQL = "SELECT * FROM \"users\" " +
+            "INNER JOIN (SELECT (max(\"id\")) AS \"max_id\" FROM (\"users\") AS \"u\" GROUP BY \"age\") AS \"u\" " +
+            "ON (\"u\".\"max_id\" = \"id\")"
+        ExpectExecutions(db, [SQL: 1]) { _ in for row in query { println(row) } }
+    }
+
     func test_namespacedColumnRowValueAccess() {
         let aliceId = users.insert(email <- "[email protected]")!
         let bettyId = users.insert(email <- "[email protected]", manager_id <- Int64(aliceId))!

SQLite/Expression.swift

@@ -81,6 +81,10 @@ public struct Expression<T> {
     /// Returns an aliased version of the expression using AS. The expression is
     /// expanded contextually (e.g., in SELECT clauses).
     public func alias(alias: String) -> Expression {
+        return self.alias(Expression(alias))
+    }
+
+    private func alias(alias: Expression) -> Expression {
         var expression = Expression(alias)
         expression.original = self
         return expression
@@ -200,6 +204,17 @@ extension Expression: Expressible {
 
 }
 
+extension Query: Expressible {
+
+    public var expression: Expression<()> {
+        if tableName.original != nil {
+            return selectExpression.alias(tableName)
+        }
+        return wrap("", selectExpression)
+    }
+
+}
+
 // MARK: - Expressions
 
 public func + (lhs: Expression<String>, rhs: Expression<String>) -> Expression<String> { return infix("||", lhs, rhs) }

SQLite/Query.swift

@@ -52,7 +52,7 @@ public struct Query {
 
     }
 
-    private var columns: [Expressible] = [Expression<()>(literal: "*")]
+    private var columns: [Expressible]?
     private var distinct: Bool = false
     internal var tableName: Expression<()>
     private var joins: [(type: JoinType, table: Query, condition: Expression<Bool>)] = []
@@ -96,7 +96,9 @@ public struct Query {
     ///
     /// :returns: A query with SELECT * applied.
     public func select(all star: Star) -> Query {
-        return select(star(nil, nil))
+        var query = self
+        (query.distinct, query.columns) = (false, nil)
+        return query
     }
 
     /// Sets the SELECT DISTINCT * clause on the query.
@@ -392,15 +394,16 @@ public struct Query {
     private var selectClause: Expressible {
         var expressions: [Expressible] = [Expression<()>(literal: "SELECT")]
         if distinct { expressions.append(Expression<()>(literal: "DISTINCT")) }
-        expressions.append(Expression<()>.join(", ", columns.map { $0.expression.aliased }))
+        expressions.append(Expression<()>.join(", ", (columns ?? [Expression<()>(literal: "*")]).map { $0.expression.aliased }))
         expressions.append(Expression<()>(literal: "FROM \(tableName.aliased.SQL)"))
         return Expression<()>.join(" ", expressions)
     }
 
     private var joinClause: Expressible? {
         if joins.count == 0 { return nil }
         return Expression<()>.join(" ", joins.map { type, table, condition in
-            Expression<()>(literal: "\(type.rawValue) JOIN \(table.tableName.aliased.SQL) ON \(condition.SQL)", condition.bindings)
+            let join = (table.columns == nil ? table.tableName : table.expression).aliased
+            return Expression<()>(literal: "\(type.rawValue) JOIN \(join.SQL) ON \(condition.SQL)", join.bindings + condition.bindings)
         })
     }
 
@@ -824,7 +827,7 @@ public struct QueryGenerator: GeneratorType {
 
     private lazy var columnNames: [String: Int] = {
         var (columnNames, idx) = ([String: Int](), 0)
-        column: for each in self.query.columns {
+        column: for each in self.query.columns ?? [Expression<()>(literal: "*")] {
             let pair = split(each.expression.SQL) { $0 == "." }
             let (tableName, column) = (pair.count > 1 ? pair.first : nil, pair.last!)