Merge pull request #31 from vapor/nio

thread specific table name caches

Author: tanner0101

Sources/FluentPostgreSQL/FluentPostgreSQLProvider.swift

@@ -40,11 +40,7 @@ public final class FluentPostgreSQLProvider: Provider {
 
     /// 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)
-            }
-        }
+        return .done(on: worker)
     }
 }
 

Sources/FluentPostgreSQL/PostgreSQLTableNameCache.swift

@@ -6,21 +6,34 @@ final class PostgreSQLTableNameCache {
     var storage: [Int32: String]
 
     /// Static shared cache, stored by connections.
-    private static var shared: [ObjectIdentifier: PostgreSQLTableNameCache] = [:]
+    private static var _shared: ThreadSpecificVariable<PostgreSQLTableNameCaches> = .init()
+
+    /// Getter for `_shared` that will initialize if it has not already been initialized.
+    private static var shared: PostgreSQLTableNameCaches {
+        get {
+            if let existing = _shared.currentValue {
+                return existing
+            } else {
+                let new = PostgreSQLTableNameCaches()
+                _shared.currentValue = new
+                return new
+            }
+        }
+    }
 
     /// Creates a new cache.
-    private init(cache: [Int32: String]) {
+    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
+        shared.storage[ObjectIdentifier(connection)] = nil
     }
 
     /// Generates a cache for the supplied connection.
     static func get(for connection: PostgreSQLConnection) -> Future<PostgreSQLTableNameCache> {
-        if let existing = shared[ObjectIdentifier(connection)] {
+        if let existing = shared.storage[ObjectIdentifier(connection)] {
             return Future.map(on: connection) { existing }
         } else {
             return connection.simpleQuery("select oid, relname from pg_class").map(to: PostgreSQLTableNameCache.self) { rows in
@@ -32,10 +45,21 @@ final class PostgreSQLTableNameCache {
                     cache[oid] = name
                 }
 
-                let new = PostgreSQLTableNameCache(cache: cache)
-                shared[ObjectIdentifier(connection)] = new
+                let new = PostgreSQLTableNameCache(cache)
+                shared.storage[ObjectIdentifier(connection)] = new
                 return new
             }
         }
     }
 }
+
+/// Stores connection caches per thread.
+final class PostgreSQLTableNameCaches {
+    /// Psql connection is used as object id.
+    var storage: [ObjectIdentifier: PostgreSQLTableNameCache]
+
+    /// Creates a new cache.
+    internal init() {
+        self.storage = [:]
+    }
+}