order by updates

Author: tanner0101

Sources/FluentPostgreSQL/PostgreSQLDatabase+Fluent.swift

@@ -82,7 +82,8 @@ extension PostgreSQLQuery {
         case .insert:
             query = .insert(.init(
                 table: fluent.table,
-                values: fluent.values,
+                columns: .init(fluent.values.keys),
+                values: [.init(fluent.values.values)],
                 returning: fluent.returning
             ))
         case .select:
@@ -165,10 +166,6 @@ extension PostgreSQLDatabase: QuerySupporting & JoinSupporting & MigrationSuppor
         query.joins.append(join)
     }
 
-    public static func prepareMigrationMetadata(on conn: PostgreSQLConnection) -> EventLoopFuture<Void> {
-        fatalError()
-    }
-    
     public static func query(_ entity: String) -> PostgreSQLQuery.FluentQuery {
         return .init(table: .init(name: entity))
     }
@@ -363,7 +360,7 @@ extension PostgreSQLDatabase: QuerySupporting & JoinSupporting & MigrationSuppor
     }
 
     public static func querySort(_ column: PostgreSQLQuery.Column, _ direction: PostgreSQLQuery.OrderBy.Direction) -> PostgreSQLQuery.OrderBy {
-        return .init(columns: [column], direction: direction)
+        return .init(.column(column), direction: direction)
     }
 
     public static var querySortDirectionAscending: PostgreSQLQuery.OrderBy.Direction {

Tests/FluentPostgreSQLTests/FluentPostgreSQLTests.swift

@@ -226,8 +226,8 @@ class FluentPostgreSQLTests: XCTestCase {
         try DefaultTest.prepare(on: conn).wait()
         _ = try DefaultTest().save(on: conn).wait()
         let fetched = try DefaultTest.query(on: conn).first().wait()!
-        // within 10 seconds
-        XCTAssertEqual(Date().timeIntervalSinceReferenceDate, fetched.date!.timeIntervalSinceReferenceDate, accuracy: 15)
+        // within 1 minute
+        XCTAssertEqual(Date().timeIntervalSinceReferenceDate, fetched.date!.timeIntervalSinceReferenceDate, accuracy: 60)
     }
 
     func testGH30() throws {
@@ -411,6 +411,29 @@ class FluentPostgreSQLTests: XCTestCase {
         _ = try User.query(on: conn).filter(\.id ~~ [1, 2]).all().wait()
         _ = try User.query(on: conn).filter(\.id ~~ [1, 2, 3]).all().wait()
     }
+    
+    func testSort() throws {
+        struct Planet: PostgreSQLModel, PostgreSQLMigration, Equatable {
+            var id: Int?
+            var name: String
+            init(id: Int? = nil, name: String) {
+                self.id = id
+                self.name = name
+            }
+        }
+        let conn = try benchmarker.pool.requestConnection().wait()
+        defer { benchmarker.pool.releaseConnection(conn) }
+        try Planet.prepare(on: conn).wait()
+        defer { _ = try? Planet.revert(on: conn).wait() }
+        
+        _ = try Planet(name: "Jupiter").save(on: conn).wait()
+        _ = try Planet(name: "Earth").save(on: conn).wait()
+        _ = try Planet(name: "Mars").save(on: conn).wait()
+        
+        let unordered = try Planet.query(on: conn).all().wait()
+        let ordered = try Planet.query(on: conn).sort(\.name).all().wait()
+        XCTAssertNotEqual(unordered, ordered)
+    }
 
     static let allTests = [
         ("testSchema", testSchema),
@@ -437,6 +460,7 @@ class FluentPostgreSQLTests: XCTestCase {
         ("testDocs_type", testDocs_type),
         ("testContains", testContains),
         ("testEmptySubset", testEmptySubset),
+        ("testSort", testSort),
     ]
 }