add tablenamecache

Author: tanner0101

Package.swift

@@ -9,13 +9,13 @@ let package = Package(
     ],
     dependencies: [
         // 🌎 Utility package containing tools for byte manipulation, Codable, OS APIs, and debugging.
-        .package(url: "https://github.com/vapor/core.git", .branch("nio")),
+        .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", .branch("nio")),
+        .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", .branch("nio")),
+        .package(url: "https://github.com/vapor/postgresql.git", .branch("master")),
     ],
     targets: [
         .target(name: "FluentPostgreSQL", dependencies: ["Async", "CodableKit", "Fluent", "FluentSQL", "PostgreSQL"]),

Sources/FluentPostgreSQL/FluentPostgreSQLProvider.swift

@@ -1,3 +1,4 @@
+import Async
 import Service
 
 /// Adds Fluent PostgreSQL's services to your project.
@@ -17,29 +18,14 @@ public final class FluentPostgreSQLProvider: Provider {
 
     /// See `Provider.register(_:)`
     public func register(_ services: inout Services) throws {
-        try services.register(PostgreSQLVersionCheckProvider())
         try services.register(FluentProvider())
         try services.register(PostgreSQLProvider())
     }
 
     /// See `Provider.boot(_:)`
-    public func boot(_ worker: Container) throws { }
-}
-
-/// check server version and override _globalEnableIdentityColumns
-/// dirty workaround for missing pre migration hook 
-public final class PostgreSQLVersionCheckProvider: Provider {
-    /// See `Provider.repositoryName`
-    public static let repositoryName = "fluent-postgresql"
-
-    public init() {}
-    /// See `Provider.register(_:)`
-    public func register(_ services: inout Services) throws {}
-
-    /// See `Provider.boot(_:)`
-    public func boot(_ worker: Container) throws {
-        try worker.withConnection(to: .psql) { conn in
-            conn.simpleQuery("SELECT current_setting('server_version') as version").map(to: Void.self) { rows in
+    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
@@ -49,12 +35,16 @@ public final class PostgreSQLVersionCheckProvider: Provider {
                     }
                 }
             }
-        }.wait()
+        }
     }
 
-    // get current server version
-    public static func getServerVersion() -> String {
-        return _serverVersion ?? "N/A"
+    /// 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)
+            }
+        }
     }
 }
 

Sources/FluentPostgreSQL/PostgreSQLDatabase+QuerySupporting.swift

@@ -11,7 +11,8 @@ extension PostgreSQLDatabase: QuerySupporting, CustomSQLSupporting {
         into handler: @escaping ([QueryField: PostgreSQLData], PostgreSQLConnection) throws -> (),
         on connection: PostgreSQLConnection
     ) -> EventLoopFuture<Void> {
-        return Future<Void>.flatMap(on: connection) {
+        /// 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()
 
@@ -47,7 +48,7 @@ extension PostgreSQLDatabase: QuerySupporting, CustomSQLSupporting {
             return try connection.query(sqlString, parameters) { row in
                 var res: [QueryField: PostgreSQLData] = [:]
                 for (col, data) in row {
-                    let field = QueryField(entity: col.table, name: col.name)
+                    let field = QueryField(entity: tableNameCache.storage[col.tableOID], name: col.name)
                     res[field] = data
                 }
                 try handler(res, connection)
@@ -109,6 +110,9 @@ extension PostgreSQLDatabase: QuerySupporting, CustomSQLSupporting {
             return PostgreSQLData(type: convertibleType.postgreSQLDataType, format: .binary, data: nil)
         }
     }
+
+    /// See `QuerySupporting.QueryFilter`
+    public typealias QueryFilter = DataPredicateComparison
 }
 
 extension PostgreSQLData: FluentData {}

Sources/FluentPostgreSQL/PostgreSQLDatabase+SchemaSupporting.swift

@@ -57,6 +57,9 @@ extension PostgreSQLDatabase: SchemaSupporting, IndexSupporting {
 
     /// See `SchemaSupporting.execute`
     public static func execute(schema: DatabaseSchema<PostgreSQLDatabase>, on connection: PostgreSQLConnection) -> Future<Void> {
+        /// 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)

Sources/FluentPostgreSQL/PostgreSQLTableNameCache.swift

@@ -0,0 +1,41 @@
+import Async
+
+/// Caches table OID to string name associations.
+final class PostgreSQLTableNameCache {
+    /// The internal cache.
+    var storage: [Int32: String]
+
+    /// Static shared cache, stored by connections.
+    private static var shared: [ObjectIdentifier: PostgreSQLTableNameCache] = [:]
+
+    /// Creates a new cache.
+    private init(cache: [Int32: String]) {
+        self.storage = cache
+    }
+
+    /// Invalidates the cache for the supplied connection.
+    static func invalidate(for connection: PostgreSQLConnection) {
+        shared[ObjectIdentifier(connection)] = nil
+    }
+
+    /// Generates a cache for the supplied connection.
+    static func get(for connection: PostgreSQLConnection) -> Future<PostgreSQLTableNameCache> {
+        if let existing = shared[ObjectIdentifier(connection)] {
+            return Future.map(on: connection) { existing }
+        } else {
+            return connection.simpleQuery("select oid, relname from pg_class").map(to: PostgreSQLTableNameCache.self) { rows in
+                var cache: [Int32: String] = [:]
+
+                for row in rows {
+                    let oid = try row.firstValue(forColumn: "oid")!.decode(Int32.self)
+                    let name = try row.firstValue(forColumn: "relname")!.decode(String.self)
+                    cache[oid] = name
+                }
+
+                let new = PostgreSQLTableNameCache(cache: cache)
+                shared[ObjectIdentifier(connection)] = new
+                return new
+            }
+        }
+    }
+}

Tests/FluentPostgreSQLTests/FluentPostgreSQLTests.swift

@@ -1,4 +1,5 @@
 import Async
+import Core
 import XCTest
 import FluentBenchmark
 import FluentPostgreSQL
@@ -9,15 +10,16 @@ class FluentPostgreSQLTests: XCTestCase {
     var database: PostgreSQLDatabase!
 
     override func setUp() {
-        let eventLoop = MultiThreadedEventLoopGroup(numThreads: 1)
         let config = PostgreSQLDatabaseConfig(
-            hostname: ProcessInfo.processInfo.environment["PSQL_HOSTNAME"] ?? "localhost",
+            hostname: (try? Process.execute("docker-machine", "ip")) ?? "192.168.99.100",
             port: 5432,
             username: "vapor_username",
             database: "vapor_database",
             password: nil
         )
-        database = PostgreSQLDatabase(config: config)
+        let main = MultiThreadedEventLoopGroup(numThreads: 1)
+        database = PostgreSQLDatabase(config: config, on: main)
+        let eventLoop = MultiThreadedEventLoopGroup(numThreads: 1)
         benchmarker = Benchmarker(database, on: eventLoop, onFail: XCTFail)
     }
 
@@ -197,6 +199,10 @@ class FluentPostgreSQLTests: XCTestCase {
         XCTAssertEqual(123.456, fetched.date!.value!.timeIntervalSinceReferenceDate, accuracy: 1e-6)
     }
 
+    func testContains() throws {
+        try benchmarker.benchmarkContains_withSchema()
+    }
+
     static let allTests = [
         ("testSchema", testSchema),
         ("testModels", testModels),
@@ -214,6 +220,7 @@ class FluentPostgreSQLTests: XCTestCase {
         ("testGH24", testGH24),
         ("testGH21", testGH21),
         ("testPersistsDateMillisecondPart", testPersistsDateMillisecondPart),
+        ("testContains", testContains),
     ]
 }
 

circle.yml

@@ -10,18 +10,12 @@ jobs:
       - run: swift test
   linux:
     docker:
-      - image: norionomura/swift:swift-4.1-branch
+      - image: codevapor/swift:4.1
       - image: circleci/postgres:latest
         environment:
           POSTGRES_USER: vapor_username
           POSTGRES_DB: vapor_database
     steps:
-      - run:
-          name: Update APT
-          command: apt-get update
-      - run:
-          name: Install Swift NIO dependencies
-          command: apt-get install -yq pkg-config libssl-dev
       - checkout
       - run: 
           name: Compile code