Support expression aliasing

This commit adds support for expression aliasing:

    let maxAge = max(age).alias("max_age")
    for row in users.select(name, maxAge).group(name) {
       println("the oldest \(row[name]) is \(row[maxAge]!)")
       // the oldest Stephen is 30
    }
    // SELECT "name", (max("age")) AS "max_age" FROM "users" GROUP BY "name"

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

Author: stephencelis

SQLite Tests/ExpressionTests.swift

@@ -28,6 +28,11 @@ class ExpressionTests: XCTestCase {
         CreateUsersTable(db)
     }
 
+    func test_alias_aliasesExpression() {
+        let aliased = stringA.alias("string_a")
+        ExpectExecutionMatches("('A') AS \"string_a\"", aliased)
+    }
+
     func test_stringExpressionPlusStringExpression_buildsConcatenatingStringExpression() {
         ExpectExecutionMatches("('A' || 'A')", stringA + stringA)
         ExpectExecutionMatches("('A' || 'B')", stringA + stringB)

SQLite Tests/QueryTests.swift

@@ -131,6 +131,16 @@ class QueryTests: XCTestCase {
         XCTAssertEqual(alice[email], betty[managers[email]])
     }
 
+    func test_aliasedColumnRowValueAccess() {
+        users.insert(email <- "[email protected]")!
+
+        let alias = email.alias("user_email")
+        let query = users.select(alias)
+        let alice = query.first!
+
+        XCTAssertEqual("[email protected]", alice[alias])
+    }
+
     func test_filter_compilesWhereClause() {
         let query = users.filter(admin == true)
 

SQLite/Expression.swift

@@ -29,7 +29,9 @@ public struct Expression<T> {
 
     public let bindings: [Binding?]
 
-    internal var ascending: Bool?
+    private var ascending: Bool?
+
+    private var original: Expressible?
 
     /// Builds a SQL expression with a literal string and an optional list of
     /// bindings.
@@ -76,6 +78,14 @@ public struct Expression<T> {
         return expression
     }
 
+    /// 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 {
+        var expression = Expression(alias)
+        expression.original = self
+        return expression
+    }
+
     internal static func join(separator: String, _ expressions: [Expressible]) -> Expression<()> {
         var (SQL, bindings) = ([String](), [Binding?]())
         for expressible in expressions {
@@ -89,6 +99,7 @@ public struct Expression<T> {
     internal init<V>(_ expression: Expression<V>) {
         self.init(literal: expression.SQL, expression.bindings)
         ascending = expression.ascending
+        original = expression.original
     }
 
     internal var ordered: Expression<()> {
@@ -98,6 +109,13 @@ public struct Expression<T> {
         return Expression<()>(self)
     }
 
+    internal var aliased: Expression {
+        if let aliased = original?.expression {
+            return Expression(literal: "(\(aliased.SQL)) AS \(SQL)", aliased.bindings + bindings)
+        }
+        return self
+    }
+
     internal func reverse() -> Expression {
         var expression = self
         expression.ascending = expression.ascending.map(!) ?? false

SQLite/Query.swift

@@ -389,7 +389,7 @@ 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))
+        expressions.append(Expression<()>.join(", ", columns.map { $0.expression.aliased }))
         expressions.append(Expression<()>(literal: "FROM \(self)"))
         return Expression<()>.join(" ", expressions)
     }