Merge pull request #23 from vapor/nio

nio

Author: tanner0101

CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to Fluent PostgreSQL
+
+👋 Welcome to the Vapor team! 
+
+## Bootstrap
+
+To prepare your computer for developing this package, you can run the bootstrap script.
+
+```sh
+./contribute_boostrap.sh
+```
+
+This script will start up a PostgreSQL docker container to test against. It will also generate and open Xcode for you.
+
+Be careful to observe the script's output, it may have errors or ask you to do additional steps manually.
+
+## Testing
+
+Once in Xcode, select the `FluentPostgreSQL-Package` scheme and use `CMD+U` to run the tests.
+
+When adding new tests (please do 😁), don't forget to add the method name to the `allTests` array. 
+If you add a new `XCTestCase` subclass, make sure to add it to the `Tests/LinuxMain.swift` file.
+
+If you are fixing a single GitHub issue in particular, you can add a test named `testGH<issue number>` to ensure
+that your fix is working. This will also help prevent regression.
+
+## SemVer
+
+Vapor follows [SemVer](https://semver.org). This means that any changes to the source code that can cause
+existing code to stop compiling _must_ wait until the next major version to be included. 
+
+Code that is only additive and will not break any existing code can be included in the next minor release.
+
+----------
+
+Join us on Slack if you have any questions: [http://vapor.team](http://vapor.team).
+
+&mdash; Thanks! 🙌

Package.swift

@@ -8,17 +8,14 @@ let package = Package(
         .library(name: "FluentPostgreSQL", targets: ["FluentPostgreSQL"]),
     ],
     dependencies: [
-        // ⏱ Promises and reactive-streams in Swift built for high-performance and scalability.
-        .package(url: "https://github.com/vapor/async.git", from: "1.0.0-rc"),
-
         // 🌎 Utility package containing tools for byte manipulation, Codable, OS APIs, and debugging.
-        .package(url: "https://github.com/vapor/core.git", from: "3.0.0-rc"),
+        .package(url: "https://github.com/vapor/core.git", .branch("master")),
 
         // Swift ORM framework (queries, models, and relations) for building NoSQL and SQL database integrations.
-        .package(url: "https://github.com/vapor/fluent.git", from: "3.0.0-rc"),
+        .package(url: "https://github.com/vapor/fluent.git", .branch("master")),
 
         // 🐘 Non-blocking, event-driven Swift client for PostgreSQL.
-        .package(url: "https://github.com/vapor/postgresql.git", from: "1.0.0-rc"),
+        .package(url: "https://github.com/vapor/postgresql.git", .branch("master")),
     ],
     targets: [
         .target(name: "FluentPostgreSQL", dependencies: ["Async", "CodableKit", "Fluent", "FluentSQL", "PostgreSQL"]),

Sources/FluentPostgreSQL/Exports.swift

@@ -1,2 +1,3 @@
 @_exported import Fluent
+@_exported import FluentSQL
 @_exported import PostgreSQL

Sources/FluentPostgreSQL/FluentPostgreSQLProvider.swift

@@ -1,3 +1,4 @@
+import Async
 import Service
 
 /// Adds Fluent PostgreSQL's services to your project.
@@ -22,8 +23,32 @@ public final class FluentPostgreSQLProvider: Provider {
     }
 
     /// See `Provider.boot(_:)`
-    public func boot(_ worker: Container) throws { }
+    public func willBoot(_ worker: Container) throws -> Future<Void> {
+        return worker.withConnection(to: .psql) { conn in
+            return conn.simpleQuery("SELECT current_setting('server_version') as version").map(to: Void.self) { rows in
+                _serverVersion = try rows[0].firstValue(forColumn: "version")!.decode(String.self)
+                if let versionString = _serverVersion {
+                    let pointIndex = versionString.index(of: ".") ?? versionString.endIndex
+                    let majorVersion = versionString[..<pointIndex]
+                    if let ver = Int(majorVersion) {
+                        _globalEnableIdentityColumns = ver < 10 ? false: _globalEnableIdentityColumns
+                    }
+                }
+            }
+        }
+    }
+
+    /// See `Provider.boot(_:)`
+    public func didBoot(_ worker: Container) throws -> Future<Void> {
+        return worker.withConnection(to: .psql) { conn in
+            return conn.simpleQuery("select * from pg_class").map(to: Void.self) { rows in
+                print(rows)
+            }
+        }
+    }
 }
 
+/// server version string
+internal var _serverVersion: String?
 /// Enabled by default
 internal var _globalEnableIdentityColumns: Bool = true

Sources/FluentPostgreSQL/PostgreSQLDatabase+LogSupporting.swift

@@ -8,7 +8,7 @@ extension PostgreSQLDatabase: LogSupporting {
 extension DatabaseLogger: PostgreSQLLogger {
     /// See `PostgreSQLLogger.log(query:parameters:)`
     public func log(query: String, parameters: [PostgreSQLData]) {
-        let log = DatabaseLog(query: query, values: parameters.map { $0.data?.description ?? "nil" }, dbID: "postgresql", date: .init())
+        let log = DatabaseLog(query: query, values: parameters.map { $0.description }, dbID: "postgresql", date: .init())
         self.record(log: log)
     }
 }

Sources/FluentPostgreSQL/PostgreSQLDatabase+QuerySupporting.swift

@@ -4,77 +4,56 @@ import FluentSQL
 import Foundation
 
 /// Adds ability to do basic Fluent queries using a `PostgreSQLDatabase`.
-extension PostgreSQLDatabase: QuerySupporting {
+extension PostgreSQLDatabase: QuerySupporting, CustomSQLSupporting {
     /// See `QuerySupporting.execute`
-    public static func execute<I, D>(query: DatabaseQuery<PostgreSQLDatabase>, into stream: I, on connection: PostgreSQLConnection)
-        where I: Async.InputStream, D: Decodable, D == I.Input
-    {
-        let future = Future<Void>.flatMap {
+    public static func execute(
+        query: DatabaseQuery<PostgreSQLDatabase>,
+        into handler: @escaping ([QueryField: PostgreSQLData], PostgreSQLConnection) throws -> (),
+        on connection: PostgreSQLConnection
+    ) -> EventLoopFuture<Void> {
+        /// wait for the table name cache before continuing
+        return PostgreSQLTableNameCache.get(for: connection).flatMap(to: Void.self) { tableNameCache in
             // Convert Fluent `DatabaseQuery` to generic FluentSQL `DataQuery`
             var (sqlQuery, bindValues) = query.makeDataQuery()
 
             // If the query has an Encodable model attached serialize it.
             // Dictionary keys should be added to the DataQuery as columns.
             // Dictionary values should be added to the parameterized array.
-            let modelData: [PostgreSQLData]
-            if let model = query.data {
-                let encoder = PostgreSQLRowEncoder()
-                try model.encode(to: encoder)
-                sqlQuery.columns += encoder.data.keys.map { key in
-                    return DataColumn(table: query.entity, name: key)
-                }
-                modelData = .init(encoder.data.values)
-            } else {
-                modelData = []
+            var modelData: [PostgreSQLData] = []
+            modelData.reserveCapacity(query.data.count)
+            for (field, data) in query.data {
+                if case .create = query.action, data.isNull && field.name == "id" { continue } // bad hack
+                sqlQuery.columns.append(DataColumn(table: field.entity, name: field.name))
+                modelData.append(data)
+            }
+
+            /// Apply custom sql transformations
+            for customSQL in query.customSQL {
+                customSQL.closure(&sqlQuery)
             }
 
             // Create a PostgreSQL-flavored SQL serializer to create a SQL string
             let sqlSerializer = PostgreSQLSQLSerializer()
             let sqlString = sqlSerializer.serialize(data: sqlQuery)
 
-            // Combine the query data with bind values from filters.
-            // All bind values must come _after_ the columns section of the query.
-            let parameters = try modelData + bindValues.map { bind in
-                let encodable = bind.encodable
-                guard let convertible = encodable as? PostgreSQLDataCustomConvertible else {
-                    let type = Swift.type(of: encodable)
-                    throw PostgreSQLError(
-                        identifier: "convertible",
-                        reason: "Unsupported encodable type: \(type)",
-                        suggestedFixes: [
-                            "Conform \(type) to PostgreSQLDataCustomConvertible"
-                        ],
-                        source: .capture()
-                    )
-                }
-                return try convertible.convertToPostgreSQLData()
-            }
+            /// Convert params
+            let parameters: [PostgreSQLData] = modelData + bindValues
 
-            // Create a push stream to accept the psql output
-            // FIXME: connect streams directly instead?
-            let pushStream = PushStream<D>()
-            pushStream.output(to: stream)
+            /// Log supporting
+            if let logger = connection.logger {
+                logger.log(query: sqlString, parameters: parameters)
+            }
 
             // Run the query
             return try connection.query(sqlString, parameters) { row in
-                do {
-                    let decoded = try D.init(from: PostgreSQLRowDecoder(row: row))
-                    pushStream.push(decoded)
-                } catch {
-                    pushStream.error(error)
+                var res: [QueryField: PostgreSQLData] = [:]
+                for (col, data) in row {
+                    let field = QueryField(entity: tableNameCache.storage[col.tableOID], name: col.name)
+                    res[field] = data
                 }
+                try handler(res, connection)
             }
         }
-
-        /// Convert Future completion / error to stream
-        future.do {
-            // Query is complete
-            stream.close()
-        }.catch { error in
-            // Query failed
-            stream.error(error)
-            stream.close()
-        }
     }
 
     /// See `QuerySupporting.modelEvent`
@@ -86,19 +65,54 @@ extension PostgreSQLDatabase: QuerySupporting {
             if M.ID.self == UUID.self {
                 var model = model
                 model.fluentID = UUID() as? M.ID
-                return Future(model)
+                return Future.map(on: connection) { model }
             }
         case .didCreate:
-            if M.ID.self == Int.self {
+            if M.ID.self == Int.self, model.fluentID == nil {
                 return connection.simpleQuery("SELECT LASTVAL();").map(to: M.self) { row in
                     var model = model
-                    try model.fluentID = row[0]["lastval"]?.decode(Int.self) as? M.ID
+                    try model.fluentID = row[0].firstValue(forColumn: "lastval")?.decode(Int.self) as? M.ID
                     return model
                 }
             }
         default: break
         }
-        
-        return Future(model)
+
+        return Future.map(on: connection) { model }
+    }
+
+    /// See `QuerySupporting.QueryDataConvertible`
+    public typealias QueryDataConvertible = PostgreSQLDataConvertible
+
+    /// See `QuerySupporting.queryDataParse(_:from:)`
+    public static func queryDataParse<T>(_ type: T.Type, from data: PostgreSQLData) throws -> T? {
+        if data.isNull {
+            return nil
+        }
+        guard let convertibleType = T.self as? PostgreSQLDataConvertible.Type else {
+            throw PostgreSQLError(identifier: "queryDataParse", reason: "Cannot parse \(T.self) from PostgreSQLData", source: .capture())
+        }
+        let t: T = try convertibleType.convertFromPostgreSQLData(data) as! T
+        return t
     }
+
+    /// See `QuerySupporting.queryDataSerialize(data:)`
+    public static func queryDataSerialize<T>(data: T?) throws -> PostgreSQLData {
+        if let data = data {
+            guard let convertible = data as? PostgreSQLDataConvertible else {
+                throw PostgreSQLError(identifier: "queryDataSerialize", reason: "Cannot serialize \(T.self) to PostgreSQLData", source: .capture())
+            }
+            return try convertible.convertToPostgreSQLData()
+        } else {
+            guard let convertibleType = T.self as? PostgreSQLDataConvertible.Type else {
+                throw PostgreSQLError(identifier: "queryDataParse", reason: "Cannot parse \(T.self) from PostgreSQLData", source: .capture())
+            }
+            return PostgreSQLData(type: convertibleType.postgreSQLDataType, format: .binary, data: nil)
+        }
+    }
+
+    /// See `QuerySupporting.QueryFilter`
+    public typealias QueryFilter = DataPredicateComparison
 }
+
+extension PostgreSQLData: FluentData {}

Sources/FluentPostgreSQL/PostgreSQLDatabase+ReferenceSupporting.swift

@@ -4,13 +4,13 @@ extension PostgreSQLDatabase: ReferenceSupporting {
     /// See `ReferenceSupporting.enableReferences(on:)`
     public static func enableReferences(on connection: PostgreSQLConnection) -> Future<Void> {
         // enabled by default
-        return .done
+        return .done(on: connection)
     }
 
     /// See `ReferenceSupporting.disableReferences(on:)`
     public static func disableReferences(on connection: PostgreSQLConnection) -> Future<Void> {
-        return Future(
-            error: PostgreSQLError(identifier: "disableReferences", reason: "PostgreSQL does not support disabling foreign key checks.", source: .capture())
-        )
+        return Future.map(on: connection) {
+            throw PostgreSQLError(identifier: "disableReferences", reason: "PostgreSQL does not support disabling foreign key checks.", source: .capture())
+        }
     }
 }

Sources/FluentPostgreSQL/PostgreSQLDatabase+SchemaSupporting.swift

@@ -57,10 +57,16 @@ extension PostgreSQLDatabase: SchemaSupporting, IndexSupporting {
 
     /// See `SchemaSupporting.execute`
     public static func execute(schema: DatabaseSchema<PostgreSQLDatabase>, on connection: PostgreSQLConnection) -> Future<Void> {
-        do {
+        /// schema is changing, invalidate the table name cache
+        PostgreSQLTableNameCache.invalidate(for: connection)
+
+        return Future.flatMap(on: connection) {
             var schemaQuery = schema.makeSchemaQuery(dataTypeFactory: dataType)
             schema.applyReferences(to: &schemaQuery)
             let sqlString = PostgreSQLSQLSerializer().serialize(schema: schemaQuery)
+            if let logger = connection.logger {
+                logger.log(query: sqlString, parameters: [])
+            }
             return try connection.query(sqlString).map(to: Void.self) { rows in
                 assert(rows.count == 0)
             }.flatMap(to: Void.self) {
@@ -81,12 +87,8 @@ extension PostgreSQLDatabase: SchemaSupporting, IndexSupporting {
                     }
                     indexFutures.append(remove)
                 }
-                return indexFutures.flatten()
+                return indexFutures.flatten(on: connection)
             }
-
-            
-        } catch {
-            return Future(error: error)
         }
     }
 }

Sources/FluentPostgreSQL/PostgreSQLRowDecoder.swift

@@ -71,7 +71,7 @@ fileprivate struct PostgreSQLRowKeyedDecodingContainer<K>: KeyedDecodingContaine
     func decode(_ type: Bool.Type, forKey key: K) throws -> Bool { return try decoder.require(key: key).decode(Bool.self) }
     func decode(_ type: String.Type, forKey key: K) throws -> String { return try decoder.require(key: key).decode(String.self) }
     func decode<T>(_ type: T.Type, forKey key: K) throws -> T where T: Decodable {
-        guard let convertible = type as? PostgreSQLDataCustomConvertible.Type else {
+        guard let convertible = type as? PostgreSQLDataConvertible.Type else {
             throw PostgreSQLError(
                 identifier: "convertible",
                 reason: "Unsupported decodable type: \(type)",

Sources/FluentPostgreSQL/PostgreSQLRowEncoder.swift

@@ -65,15 +65,15 @@ fileprivate struct PostgreSQLRowKeyedEncodingContainer<K>: KeyedEncodingContaine
         if let value = value {
             try encode(value, forKey: key)
         } else {
-            if let convertibleType = T.self as? PostgreSQLDataCustomConvertible.Type {
+            if let convertibleType = T.self as? PostgreSQLDataConvertible.Type {
                 encoder.data[key.stringValue] = PostgreSQLData(type: convertibleType.postgreSQLDataType, data: nil)
             } else {
                 try encodeNil(forKey: key)
             }
         }
     }
     mutating func encode<T>(_ value: T, forKey key: K) throws where T: Encodable {
-        guard let convertible = value as? PostgreSQLDataCustomConvertible else {
+        guard let convertible = value as? PostgreSQLDataConvertible else {
             let type = Swift.type(of: value)
             throw PostgreSQLError(
                 identifier: "convertible",