Make asc/desc idempotent, query reversible

This commit adds behavior that internally tracks ascending/descending
state on expressions, expanding only when necessary. This makes it
possible to reverse queries by reversing each of the stored sort
descriptors.

    let sorted = users.order(name)
    // SELECT * FROM "users" ORDER BY "name"
    let reversed = sorted.reverse()
    // SELECT * FROM "users" ORDER BY "name" DESC
    let rereversed = reversed.reverse()
    // SELECT * FROM "users" ORDER BY "name" ASC

This also allows for more array-like access, including `last`:

    users.last
    // SELECT * FROM "users" ORDER BY "ROWID" DESC LIMIT 1

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

Author: stephencelis

SQLite Tests/QueryTests.swift

@@ -198,6 +198,27 @@ class QueryTests: XCTestCase {
         ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
     }
 
+    func test_order_whenChained_overridesOrder() {
+        let query = users.order(email).order(age)
+
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"age\""
+        ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
+    }
+
+    func test_reverse_withoutOrder_ordersByRowIdDescending() {
+        let query = users.reverse()
+
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"ROWID\" DESC"
+        ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
+    }
+
+    func test_reverse_withOrder_reversesOrder() {
+        let query = users.order(age, email.desc).reverse()
+
+        let SQL = "SELECT * FROM \"users\" ORDER BY \"age\" DESC, \"email\" ASC"
+        ExpectExecutions(db, [SQL: 1]) { _ in for _ in query {} }
+    }
+
     func test_limit_compilesLimitClause() {
         let query = users.limit(5)
 

SQLite Tests/SchemaTests.swift

@@ -350,7 +350,7 @@ class SchemaTests: XCTestCase {
     func test_index_withMultipleColumns_executesCompoundIndexStatement() {
         CreateUsersTable(db)
         ExpectExecution(db,
-            "CREATE INDEX \"index_users_on_age_DESC_email\" ON \"users\" (\"age\" DESC, \"email\")",
+            "CREATE INDEX \"index_users_on_age_email\" ON \"users\" (\"age\" DESC, \"email\")",
             db.create(index: users, on: age.desc, email)
         )
     }

SQLite/Expression.swift

@@ -29,6 +29,8 @@ public struct Expression<T> {
 
     public let bindings: [Binding?]
 
+    internal var ascending: Bool?
+
     /// Builds a SQL expression with a literal string and an optional list of
     /// bindings.
     ///
@@ -61,17 +63,17 @@ public struct Expression<T> {
     }
 
     /// Returns an ascending sort version of the expression.
-    public var asc: Expression<()> {
-        return Expression.join(" ", [self, Expression(literal: "ASC")])
+    public var asc: Expression {
+        var expression = self
+        expression.ascending = true
+        return expression
     }
 
     /// Returns an descending sort version of the expression.
-    public var desc: Expression<()> {
-        return Expression.join(" ", [self, Expression(literal: "DESC")])
-    }
-
-    internal init<V>(_ expression: Expression<V>) {
-        self.init(literal: expression.SQL, expression.bindings)
+    public var desc: Expression {
+        var expression = self
+        expression.ascending = false
+        return expression
     }
 
     internal static func join(separator: String, _ expressions: [Expressible]) -> Expression<()> {
@@ -84,6 +86,24 @@ public struct Expression<T> {
         return Expression<()>(literal: Swift.join(separator, SQL), bindings)
     }
 
+    internal init<V>(_ expression: Expression<V>) {
+        self.init(literal: expression.SQL, expression.bindings)
+        ascending = expression.ascending
+    }
+
+    internal var ordered: Expression<()> {
+        if let ascending = ascending {
+            return Expression.join(" ", [self, Expression(literal: ascending ? "ASC" : "DESC")])
+        }
+        return Expression<()>(self)
+    }
+
+    internal func reverse() -> Expression {
+        var expression = self
+        expression.ascending = expression.ascending.map(!) ?? false
+        return expression
+    }
+
     // naïve compiler for statements that can't be bound, e.g., CREATE TABLE
     internal func compile() -> String {
         var idx = 0
@@ -882,6 +902,8 @@ public postfix func -- (column: Expression<Int?>) -> Setter {
 
 // MARK: - Internal
 
+internal let rowid = Expression<Int>("ROWID")
+
 internal func transcode(literal: Binding?) -> String {
     if let literal = literal {
         if let literal = literal as? Blob { return literal.description }

SQLite/Query.swift

@@ -239,6 +239,15 @@ public struct Query {
     ///
     /// :returns: A query with the given ORDER BY clause applied.
     public func order(by: Expressible...) -> Query {
+        return order(by)
+    }
+
+    /// Sets an ORDER BY clause on the query.
+    ///
+    /// :param: by An ordered list of columns and directions to sort by.
+    ///
+    /// :returns: A query with the given ORDER BY clause applied.
+    public func order(by: [Expressible]) -> Query {
         var query = self
         query.order = by
         return query
@@ -398,7 +407,7 @@ public struct Query {
 
     private var orderClause: Expressible? {
         if order.count == 0 { return nil }
-        let clause = Expression<()>.join(", ", order)
+        let clause = Expression<()>.join(", ", order.map { $0.expression.ordered })
         return Expression<()>(literal: "ORDER BY \(clause.SQL)", clause.bindings)
     }
 
@@ -413,17 +422,6 @@ public struct Query {
         return nil
     }
 
-    // MARK: - Array
-
-    /// The first result (or nil if the query has no results).
-    public var first: Row? {
-        var generator = limit(1).generate()
-        return generator.next()
-    }
-
-    /// Returns true if the query has no results.
-    public var isEmpty: Bool { return first == nil }
-
     // MARK: - Modifying
 
     /// Runs an INSERT statement against the query.
@@ -585,9 +583,6 @@ public struct Query {
 
     // MARK: - Aggregate Functions
 
-    /// Runs count(*) against the query and returns it.
-    public var count: Int { return calculate(SQLite_count(*))! }
-
     /// Runs count() against the query.
     ///
     /// :param: column The column used for the calculation.
@@ -715,6 +710,30 @@ public struct Query {
         return select(expression).selectStatement.scalar() as? U
     }
 
+    // MARK: - Array
+
+    /// Runs count(*) against the query and returns it.
+    public var count: Int { return calculate(SQLite_count(*))! }
+
+    /// Returns true if the query has no rows.
+    public var isEmpty: Bool { return first == nil }
+
+    /// The first row (or nil if the query returns no rows).
+    public var first: Row? {
+        var generator = limit(1).generate()
+        return generator.next()
+    }
+
+    /// The last row (or nil if the query returns no rows).
+    public var last: Row? {
+        return reverse().first
+    }
+
+    /// A query in reverse order.
+    public func reverse() -> Query {
+        return order(order.isEmpty ? [rowid.desc] : order.map { $0.expression.reverse() })
+    }
+
 }
 
 /// A row object. Returned by iterating over a Query. Provides typed subscript

SQLite/Schema.swift

@@ -117,7 +117,7 @@ public extension Database {
         on columns: Expressible...
     ) -> Statement {
         let create = createSQL("INDEX", false, unique, ifNotExists, indexName(table, on: columns))
-        let joined = Expression<()>.join(", ", columns)
+        let joined = Expression<()>.join(", ", columns.map { $0.expression.ordered })
         return run("\(create) ON \(quote(identifier: table.tableName)) (\(joined.compile()))")
     }