add PostgresDriver type

Author: tanner0101

Sources/FluentPostgresDriver/Postgres+Fluent.swift

@@ -1,59 +1,60 @@
 import FluentSQL
 
-extension PostgresConnection: FluentDatabase {
-    public func execute(_ query: FluentQuery, _ onOutput: @escaping (FluentOutput) throws -> ()) -> EventLoopFuture<Void> {
-        return FluentSQLDatabase(delegate: PostgresConnectionSQLDelegate(self))
-            .execute(query, onOutput)
-    }
+#warning("TODO: fix to allow conformance")
+struct SQLOutput: FluentOutput {
+    let row: SQLRow
 
-    public func execute(_ schema: FluentSchema) -> EventLoopFuture<Void> {
-        return FluentSQLDatabase(delegate: PostgresConnectionSQLDelegate(self))
-            .execute(schema)
-    }
-}
-
-extension ConnectionPool: FluentDatabase where Source.Connection: FluentDatabase {
-    public var eventLoop: EventLoop {
-        return self.source.eventLoop
+    var description: String {
+        return "\(self.row)"
     }
 
-    public func execute(_ query: FluentQuery, _ onOutput: @escaping (FluentOutput) throws -> ()) -> EventLoopFuture<Void> {
-        return self.withConnection { conn in
-            return conn.execute(query, onOutput)
-        }
+    public init(row: SQLRow) {
+        self.row = row
     }
 
-    public func execute(_ schema: FluentSchema) -> EventLoopFuture<Void> {
-        return self.withConnection { conn in
-            return conn.execute(schema)
-        }
+    func decode<T>(field: String, as type: T.Type) throws -> T where T : Decodable {
+        return try self.row.decode(column: field, as: T.self)
     }
 }
 
-
-private struct PostgresConnectionSQLDelegate: FluentSQLDatabaseDelegate {
-    var eventLoop: EventLoop {
-        return self.connection.eventLoop
+public struct PostgresDriver: FluentDatabase {
+    public var eventLoop: EventLoop {
+        return self.connectionPool.source.eventLoop
     }
 
-    let connection: PostgresConnection
+    public let connectionPool: ConnectionPool<PostgresDatabase>
 
-    var database: SQLDatabase {
-        return self.connection
+    public init(connectionPool: ConnectionPool<PostgresDatabase>) {
+        self.connectionPool = connectionPool
     }
 
-    init(_ connection: PostgresConnection) {
-        self.connection = connection
+    public func execute(_ query: FluentQuery, _ onOutput: @escaping (FluentOutput) throws -> ()) -> EventLoopFuture<Void> {
+        return connectionPool.withConnection { connection in
+            var sql = SQLQueryConverter().convert(query)
+            switch query.action {
+            case .create:
+                sql = PostgresReturning(sql)
+            default: break
+            }
+            return connection.sqlQuery(sql) { row in
+                let output = SQLOutput(row: row)
+                try onOutput(output)
+            }
+        }
     }
 
-    func convert(_ fluent: FluentQuery, _ sql: SQLExpression) -> SQLExpression {
-        switch fluent.action {
-        case .create:
-            return PostgresReturning(sql)
-        default:
-            return sql
+    public func execute(_ schema: FluentSchema) -> EventLoopFuture<Void> {
+        return self.connectionPool.withConnection { connection in
+            return connection.sqlQuery(SQLSchemaConverter().convert(schema)) { row in
+                fatalError("unexpected output")
+            }
         }
     }
+    
+    public func close() -> EventLoopFuture<Void> {
+        #warning("TODO: implement connectionPool.close()")
+        fatalError("")
+    }
 }
 
 private struct PostgresReturning: SQLExpression {

Tests/FluentPostgresDriverTests/FluentPostgresDriverTests.swift

@@ -38,10 +38,12 @@ final class FluentPostgresDriverTests: XCTestCase {
     }
 
     func testEagerLoadSubqueryJSONEncode() throws {
+        #warning("TODO: fix connection pool alg")
         try self.benchmarker.testEagerLoadSubqueryJSONEncode()
     }
 
     func testEagerLoadJoinJSONEncode() throws {
+        #warning("TODO: fix connection pool alg")
         try self.benchmarker.testEagerLoadJoinJSONEncode()
     }
 
@@ -89,8 +91,9 @@ final class FluentPostgresDriverTests: XCTestCase {
             database: "vapor_database",
             tlsConfig: nil
         )
-        let conn = try! PostgresDatabase(config: config, on: eventLoop).makeConnection().wait()
-        self.benchmarker = FluentBenchmarker(database: conn)
+        let pool = PostgresDatabase(config: config, on: eventLoop).makeConnectionPool(config: .init(maxConnections: 1))
+        let driver = PostgresDriver(connectionPool: pool)
+        self.benchmarker = FluentBenchmarker(database: driver)
     }
 
     static let allTests = [