Re-use expression aliasing on a query's table

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

Author: stephencelis

Documentation/Index.md

@@ -617,7 +617,7 @@ let managers = users.alias("managers")
 
 let query = users.join(managers, on: managers[id] == users[manager_id])
 // SELECT * FROM "users"
-// INNER JOIN "users" AS "managers" ON ("managers"."id" = "users"."manager_id")
+// INNER JOIN ("users") AS "managers" ON ("managers"."id" = "users"."manager_id")
 ```
 
 If query results can have ambiguous column names, row values should be accessed with namespaced [column expressions](#expressions). In the above case, `SELECT *` immediately namespaces all columns of the result set.

SQLite Tests/QueryTests.swift

@@ -60,7 +60,7 @@ class QueryTests: XCTestCase {
         let query = users.join(managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
+            "INNER JOIN (\"users\") AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -70,7 +70,7 @@ class QueryTests: XCTestCase {
         let query = users.join(.LeftOuter, managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "LEFT OUTER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
+            "LEFT OUTER JOIN (\"users\") AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
@@ -81,7 +81,7 @@ class QueryTests: XCTestCase {
         let query = users.join(managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" " +
+            "INNER JOIN (\"users\") AS \"managers\" " +
             "ON ((\"managers\".\"id\" = \"users\".\"manager_id\") " +
             "AND \"managers\".\"admin\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
@@ -96,8 +96,8 @@ class QueryTests: XCTestCase {
             .join(managed, on: managed[manager_id] == users[id])
 
         let SQL = "SELECT * FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\") " +
-            "INNER JOIN \"users\" AS \"managed\" ON (\"managed\".\"manager_id\" = \"users\".\"id\")"
+            "INNER JOIN (\"users\") AS \"managers\" ON (\"managers\".\"id\" = \"users\".\"manager_id\") " +
+            "INNER JOIN (\"users\") AS \"managed\" ON (\"managed\".\"manager_id\" = \"users\".\"id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in middleManagers {} }
     }
 
@@ -112,7 +112,7 @@ class QueryTests: XCTestCase {
             .join(managers, on: managers[id] == users[manager_id])
 
         let SQL = "SELECT \"users\".*, \"managers\".* FROM \"users\" " +
-            "INNER JOIN \"users\" AS \"managers\" " +
+            "INNER JOIN (\"users\") AS \"managers\" " +
             "ON (\"managers\".\"id\" = \"users\".\"manager_id\")"
         ExpectExecutions(db, [SQL: 1]) { _ in for row in query { println(row) } }
     }
@@ -265,7 +265,7 @@ class QueryTests: XCTestCase {
 
     func test_alias_compilesAliasInSelectClause() {
         let managers = users.alias("managers")
-        var SQL = "SELECT * FROM \"users\" AS \"managers\""
+        var SQL = "SELECT * FROM (\"users\") AS \"managers\""
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in managers {} }
     }
 
@@ -279,11 +279,11 @@ class QueryTests: XCTestCase {
 
     func test_subscript_withAliasAndExpression_returnsAliasedExpression() {
         let managers = users.alias("managers")
-        ExpectExecution(db, "SELECT \"managers\".\"admin\" FROM \"users\" AS \"managers\"", managers.select(managers[admin]))
-        ExpectExecution(db, "SELECT \"managers\".\"salary\" FROM \"users\" AS \"managers\"", managers.select(managers[salary]))
-        ExpectExecution(db, "SELECT \"managers\".\"age\" FROM \"users\" AS \"managers\"", managers.select(managers[age]))
-        ExpectExecution(db, "SELECT \"managers\".\"email\" FROM \"users\" AS \"managers\"", managers.select(managers[email]))
-        ExpectExecution(db, "SELECT \"managers\".* FROM \"users\" AS \"managers\"", managers.select(managers[*]))
+        ExpectExecution(db, "SELECT \"managers\".\"admin\" FROM (\"users\") AS \"managers\"", managers.select(managers[admin]))
+        ExpectExecution(db, "SELECT \"managers\".\"salary\" FROM (\"users\") AS \"managers\"", managers.select(managers[salary]))
+        ExpectExecution(db, "SELECT \"managers\".\"age\" FROM (\"users\") AS \"managers\"", managers.select(managers[age]))
+        ExpectExecution(db, "SELECT \"managers\".\"email\" FROM (\"users\") AS \"managers\"", managers.select(managers[email]))
+        ExpectExecution(db, "SELECT \"managers\".* FROM (\"users\") AS \"managers\"", managers.select(managers[*]))
     }
 
     func test_SQL_compilesProperly() {
@@ -300,7 +300,7 @@ class QueryTests: XCTestCase {
             .limit(1, offset: 2)
 
         let SQL = "SELECT \"users\".\"email\", count(\"users\".\"age\") FROM \"users\" " +
-            "LEFT OUTER JOIN \"users\" AS \"managers\" " +
+            "LEFT OUTER JOIN (\"users\") AS \"managers\" " +
             "ON ((\"managers\".\"id\" = \"users\".\"manager_id\") AND (\"managers\".\"admin\" = 1)) " +
             "WHERE \"users\".\"age\" BETWEEN 21 AND 32 " +
             "GROUP BY \"users\".\"age\" HAVING (count(\"users\".\"age\") > 1) " +

SQLite/Expression.swift

@@ -116,6 +116,10 @@ public struct Expression<T> {
         return self
     }
 
+    internal var unaliased: Expression {
+        return original.map { Expression($0.expression) } ?? self
+    }
+
     internal func reverse() -> Expression {
         var expression = self
         expression.ascending = expression.ascending.map(!) ?? false

SQLite/Query.swift

@@ -29,6 +29,10 @@ public struct Query {
     internal var database: Database
 
     internal init(_ database: Database, _ tableName: String) {
+        (self.database, self.tableName) = (database, Expression(tableName))
+    }
+
+    private init(_ database: Database, _ tableName: Expression<()>) {
         (self.database, self.tableName) = (database, tableName)
     }
 
@@ -50,17 +54,16 @@ public struct Query {
 
     private var columns: [Expressible] = [Expression<()>(literal: "*")]
     private var distinct: Bool = false
-    internal var tableName: String
-    private var alias: String?
+    internal var tableName: Expression<()>
     private var joins: [(type: JoinType, table: Query, condition: Expression<Bool>)] = []
     private var filter: Expression<Bool>?
     private var group: Expressible?
     private var order = [Expressible]()
     private var limit: (to: Int, offset: Int?)? = nil
 
-    public func alias(alias: String?) -> Query {
+    public func alias(alias: String) -> Query {
         var query = self
-        query.alias = alias
+        query.tableName = query.tableName.alias(alias)
         return query
     }
 
@@ -293,7 +296,7 @@ public struct Query {
     /// :returns: A column expression namespaced with the query’s table name or
     ///           alias.
     public func namespace<V>(column: Expression<V>) -> Expression<V> {
-        return Expression(literal: "\(quote(identifier: alias ?? tableName)).\(column.SQL)", column.bindings)
+        return Expression(.join(".", [tableName, column]))
     }
 
     // FIXME: rdar://18673897 // ... subscript<T>(expression: Expression<V>) -> Expression<V>
@@ -361,7 +364,7 @@ public struct Query {
     private func insertStatement(values: [Setter], or: OnConflict? = nil) -> Statement {
         var insertClause = "INSERT"
         if let or = or { insertClause = "\(insertClause) OR \(or.rawValue)" }
-        var expressions: [Expressible] = [Expression<()>(literal: "\(insertClause) INTO \(quote(identifier: tableName))")]
+        var expressions: [Expressible] = [Expression<()>(literal: "\(insertClause) INTO \(tableName.unaliased.SQL)")]
         let (c, v) = (Expression<()>.join(", ", values.map { $0.0 }), Expression<()>.join(", ", values.map { $0.1 }))
         expressions.append(Expression<()>(literal: "(\(c.SQL)) VALUES (\(v.SQL))", c.bindings + v.bindings))
         whereClause.map(expressions.append)
@@ -370,15 +373,15 @@ public struct Query {
     }
 
     private func updateStatement(values: [Setter]) -> Statement {
-        var expressions: [Expressible] = [Expression<()>(literal: "UPDATE \(quote(identifier: tableName)) SET")]
+        var expressions: [Expressible] = [Expression<()>(literal: "UPDATE \(tableName.unaliased.SQL) SET")]
         expressions.append(Expression<()>.join(", ", values.map { Expression<()>.join(" = ", [$0, $1]) }))
         whereClause.map(expressions.append)
         let expression = Expression<()>.join(" ", expressions)
         return database.prepare(expression.SQL, expression.bindings)
     }
 
     private var deleteStatement: Statement {
-        var expressions: [Expressible] = [Expression<()>(literal: "DELETE FROM \(quote(identifier: tableName))")]
+        var expressions: [Expressible] = [Expression<()>(literal: "DELETE FROM \(tableName.unaliased.SQL)")]
         whereClause.map(expressions.append)
         let expression = Expression<()>.join(" ", expressions)
         return database.prepare(expression.SQL, expression.bindings)
@@ -390,14 +393,14 @@ public struct Query {
         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<()>(literal: "FROM \(self)"))
+        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) ON \(condition.SQL)", condition.bindings)
+            Expression<()>(literal: "\(type.rawValue) JOIN \(table.tableName.aliased.SQL) ON \(condition.SQL)", condition.bindings)
         })
     }
 
@@ -473,7 +476,7 @@ public struct Query {
 
     public func insert(query: Query) -> (changes: Int?, statement: Statement) {
         let expression = query.selectExpression
-        let statement = database.run("INSERT INTO \(quote(identifier: tableName)) \(expression.SQL)", expression.bindings)
+        let statement = database.run("INSERT INTO \(tableName.unaliased.SQL) \(expression.SQL)", expression.bindings)
         return (statement.failed ? nil : database.lastChanges, statement)
     }
 
@@ -482,7 +485,7 @@ public struct Query {
     public func insert() -> Statement { return insert().statement }
 
     public func insert() -> (id: Int64?, statement: Statement) {
-        let statement = database.run("INSERT INTO \(quote(identifier: tableName)) DEFAULT VALUES")
+        let statement = database.run("INSERT INTO \(tableName.unaliased.SQL) DEFAULT VALUES")
         return (statement.failed ? nil : database.lastId, statement)
     }
 
@@ -827,8 +830,8 @@ public struct QueryGenerator: GeneratorType {
 
             func expandGlob(namespace: Bool) -> Query -> () {
                 return { table in
-                    var names = self.query.database[table.tableName].selectStatement.columnNames.map { quote(identifier: $0) }
-                    if namespace { names = names.map { "\(quote(identifier: table.alias ?? table.tableName)).\($0)" } }
+                    var names = Query(self.query.database, self.query.tableName.unaliased).selectStatement.columnNames.map { quote(identifier: $0) }
+                    if namespace { names = names.map { "\(table.tableName.SQL).\($0)" } }
                     for name in names { columnNames[name] = idx++ }
                 }
             }
@@ -837,7 +840,7 @@ public struct QueryGenerator: GeneratorType {
                 let tables = [self.query] + self.query.joins.map { $0.table }
                 if let tableName = tableName {
                     for table in tables {
-                        if quote(identifier: table.alias ?? table.tableName) == tableName {
+                        if table.tableName.SQL == tableName {
                             expandGlob(true)(table)
                             continue column
                         }
@@ -867,8 +870,7 @@ public struct QueryGenerator: GeneratorType {
 extension Query: Printable {
 
     public var description: String {
-        if let alias = alias { return "\(quote(identifier: tableName)) AS \(quote(identifier: alias))" }
-        return quote(identifier: tableName)
+        return tableName.SQL
     }
 
 }

SQLite/Schema.swift

@@ -32,19 +32,19 @@ public extension Database {
     ) -> Statement {
         var builder = SchemaBuilder(table)
         block(builder)
-        let create = createSQL("TABLE", temporary, false, ifNotExists, table.tableName)
+        let create = createSQL("TABLE", temporary, false, ifNotExists, table.tableName.unaliased.SQL)
         let columns = Expression<()>.join(", ", builder.columns).compile()
         return run("\(create) (\(columns))")
     }
 
     public func create(#table: Query, temporary: Bool = false, ifNotExists: Bool = false, from: Query) -> Statement {
-        let create = createSQL("TABLE", temporary, false, ifNotExists, table.tableName)
+        let create = createSQL("TABLE", temporary, false, ifNotExists, table.tableName.unaliased.SQL)
         let expression = from.selectExpression
         return run("\(create) AS \(expression.SQL)", expression.bindings)
     }
 
     public func rename(#table: Query, to tableName: String) -> Statement {
-        return run("ALTER TABLE \(quote(identifier: table.tableName)) RENAME TO \(quote(identifier: tableName))")
+        return run("ALTER TABLE \(table.tableName.unaliased.SQL) RENAME TO \(quote(identifier: tableName))")
     }
 
     public func alter<V: Value>(
@@ -103,11 +103,11 @@ public extension Database {
     }
 
     private func alter(table: Query, _ definition: Expressible) -> Statement {
-        return run("ALTER TABLE \(quote(identifier: table.tableName)) ADD COLUMN \(definition.expression.compile())")
+        return run("ALTER TABLE \(table.tableName.unaliased.SQL) ADD COLUMN \(definition.expression.compile())")
     }
 
     public func drop(#table: Query, ifExists: Bool = false) -> Statement {
-        return run(dropSQL("TABLE", ifExists, table.tableName))
+        return run(dropSQL("TABLE", ifExists, table.tableName.unaliased.SQL))
     }
 
     public func create(
@@ -116,32 +116,33 @@ public extension Database {
         ifNotExists: Bool = false,
         on columns: Expressible...
     ) -> Statement {
-        let create = createSQL("INDEX", false, unique, ifNotExists, indexName(table, on: columns))
+        let tableName = table.tableName.unaliased.SQL
+        let create = createSQL("INDEX", false, unique, ifNotExists, indexName(tableName, on: columns))
         let joined = Expression<()>.join(", ", columns.map { $0.expression.ordered })
-        return run("\(create) ON \(quote(identifier: table.tableName)) (\(joined.compile()))")
+        return run("\(create) ON \(tableName) (\(joined.compile()))")
     }
 
     public func drop(index table: Query, ifExists: Bool = false, on columns: Expressible...) -> Statement {
-        return run(dropSQL("INDEX", ifExists, indexName(table, on: columns)))
+        return run(dropSQL("INDEX", ifExists, indexName(table.tableName.unaliased.SQL, on: columns)))
     }
 
-    private func indexName(table: Query, on columns: [Expressible]) -> String {
-        let string = join(" ", ["index", table.tableName, "on"] + columns.map { $0.expression.SQL })
-        return reduce(string, "") { underscored, character in
+    private func indexName(table: String, on columns: [Expressible]) -> String {
+        let string = join(" ", ["index", table, "on"] + columns.map { $0.expression.SQL })
+        return quote(identifier: reduce(string, "") { underscored, character in
             if character == "\"" { return underscored }
             if "A"..."Z" ~= character || "a"..."z" ~= character { return underscored + String(character) }
             return underscored + "_"
-        }
+        })
     }
 
     public func create(#view: Query, temporary: Bool = false, ifNotExists: Bool = false, from: Query) -> Statement {
-        let create = createSQL("VIEW", temporary, false, ifNotExists, view.tableName)
+        let create = createSQL("VIEW", temporary, false, ifNotExists, view.tableName.unaliased.SQL)
         let expression = from.selectExpression
         return run("\(create) AS \(expression.SQL)", expression.bindings)
     }
 
     public func drop(#view: Query, ifExists: Bool = false) -> Statement {
-        return run(dropSQL("VIEW", ifExists, view.tableName))
+        return run(dropSQL("VIEW", ifExists, view.tableName.unaliased.SQL))
     }
 
 }
@@ -246,7 +247,7 @@ public final class SchemaBuilder {
             name,
             unique: unique,
             check: check,
-            references: Expression(literal: references.tableName)
+            references: Expression(references.tableName)
         )
     }
 
@@ -471,13 +472,13 @@ private func createSQL(
     if unique { parts.append("UNIQUE") }
     parts.append(type)
     if ifNotExists { parts.append("IF NOT EXISTS") }
-    parts.append(quote(identifier: name))
+    parts.append(name)
     return Swift.join(" ", parts)
 }
 
 private func dropSQL(type: String, ifExists: Bool, name: String) -> String {
     var parts: [String] = ["DROP \(type)"]
     if ifExists { parts.append("IF EXISTS") }
-    parts.append(quote(identifier: name))
+    parts.append(name)
     return Swift.join(" ", parts)
 }