update to PostgresDatabase protocol

Author: tanner0101

Sources/FluentPostgresDriver/Postgres+Fluent.swift

@@ -1,56 +1,50 @@
 import FluentSQL
 
-extension FluentDatabaseID {
-    public static var psql: FluentDatabaseID {
+extension DatabaseID {
+    public static var psql: DatabaseID {
         return .init(string: "psql")
     }
 }
 
-extension FluentDatabases {
+extension Databases {
     public mutating func postgres(
-        config: PostgresDatabase.Config,
+        config: PostgresConfig,
         poolConfig: ConnectionPoolConfig = .init(),
-        as id: FluentDatabaseID = .psql,
+        as id: DatabaseID = .psql,
         isDefault: Bool = true
     ) {
-        let driver = PostgresDriver(connectionPool: .init(
-            config: poolConfig,
-            source: .init(config: config, on: self.eventLoop)
-        ))
-        self.add(driver, as: id, isDefault: isDefault)
+        let db = PostgresConnectionSource(
+            config: config,
+            on: self.eventLoop
+        )
+        let pool = ConnectionPool(config: poolConfig, source: db)
+        self.add(pool, as: id, isDefault: isDefault)
     }
 }
 
-public struct PostgresDriver: FluentDatabase {
+extension ConnectionPool: Database where Source.Connection: SQLDatabase {
     public var eventLoop: EventLoop {
-        return self.connectionPool.source.eventLoop
+        return self.source.eventLoop
     }
-    
-    public let connectionPool: ConnectionPool<PostgresDatabase>
-    
-    public init(connectionPool: ConnectionPool<PostgresDatabase>) {
-        self.connectionPool = connectionPool
-    }
-    
-    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
-                try onOutput(row.fluentOutput)
-            }
+}
+extension PostgresConnection: Database { }
+
+extension Database where Self: SQLDatabase {
+    public func execute(_ query: DatabaseQuery, _ onOutput: @escaping (DatabaseOutput) throws -> ()) -> EventLoopFuture<Void> {
+        var sql = SQLQueryConverter().convert(query)
+        switch query.action {
+        case .create:
+            sql = PostgresReturning(sql)
+        default: break
+        }
+        return self.sqlQuery(sql) { row in
+            try onOutput(row.fluentOutput)
         }
     }
 
-    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 execute(_ schema: DatabaseSchema) -> EventLoopFuture<Void> {
+        return self.sqlQuery(SQLSchemaConverter().convert(schema)) { row in
+            fatalError("unexpected output")
         }
     }
 

Tests/FluentPostgresDriverTests/FluentPostgresDriverTests.swift

@@ -70,6 +70,10 @@ final class FluentPostgresDriverTests: XCTestCase {
     func testNestedModel() throws {
         try self.benchmarker.testNestedModel()
     }
+    
+    func testAggregateCount() throws {
+        try self.benchmarker.testAggregateCount()
+    }
 //    
 //    func testWorkUnit() throws {
 //        try self.benchmarker.testWorkUnit()
@@ -83,17 +87,17 @@ final class FluentPostgresDriverTests: XCTestCase {
         #else
         hostname = "localhost"
         #endif
-        let config = PostgresDatabase.Config(
+        let config = PostgresConfig(
             hostname: hostname,
             port: 5432,
             username: "vapor_username",
             password: "vapor_password",
             database: "vapor_database",
             tlsConfig: nil
         )
-        let pool = PostgresDatabase(config: config, on: eventLoop).makeConnectionPool(config: .init(maxConnections: 1))
-        let driver = PostgresDriver(connectionPool: pool)
-        self.benchmarker = FluentBenchmarker(database: driver)
+        let db = PostgresConnectionSource(config: config, on: eventLoop)
+        let pool = ConnectionPool(config: .init(maxConnections: 1), source: db)
+        self.benchmarker = FluentBenchmarker(database: pool)
     }
 
     static let allTests = [

docker-compose.yml

@@ -7,6 +7,14 @@ services:
       dockerfile: test.Dockerfile
     depends_on: 
       - psql-10
+  psql-11:
+    image: postgres:11
+    environment:
+      POSTGRES_USER: vapor_username
+      POSTGRES_DB: vapor_database
+      POSTGRES_PASSWORD: vapor_password
+    ports:
+      - 5432:5432
   psql-10:
     image: postgres:10
     environment: