Replace pool delegate with setup closures

Author: kdubb

SQLite/Core/ConnectionPool.swift

@@ -29,15 +29,6 @@ import CSQLite
 private let vfsName = "unix-excl"
 
 
-/// Connection pool delegate
-public protocol ConnectionPoolDelegate {
-    
-    func poolShouldAddConnection(pool: ConnectionPool) -> Bool
-    func pool(pool: ConnectionPool, didAddConnection: Connection)
-    
-}
-
-
 // Connection pool for accessing an SQLite database
 // with multiple readers & a single writer. Utilizes
 // WAL mode.
@@ -49,12 +40,29 @@ public final class ConnectionPool {
     private let lockQueue : dispatch_queue_t
     private var writeConnection : DirectConnection!
 
-    public var delegate : ConnectionPoolDelegate?
+    public var foreignKeys : Bool {
+        get {
+            return internalSetup[.ForeignKeys] != nil
+        }
+        set {
+            internalSetup[.ForeignKeys] = newValue ? { try $0.execute("PRAGMA foreign_keys = ON;") } : nil
+        }
+    }
+    
+    public typealias ConnectionProcessor = Connection throws -> Void
+    public var setup = [ConnectionProcessor]()
+    
+    private enum InternalOption {
+        case WriteAheadLogging
+        case ForeignKeys
+    }
+    
+    private var internalSetup = [InternalOption: ConnectionProcessor]()
 
     public init(_ location: DirectConnection.Location) throws {
         self.location = location
         self.lockQueue = dispatch_queue_create("SQLite.ConnectionPool.Lock", DISPATCH_QUEUE_SERIAL)
-        try writable.execute("PRAGMA journal_mode = WAL;")
+        self.internalSetup[.WriteAheadLogging] = { try $0.execute("PRAGMA journal_mode = WAL;") }
     }
 
     public var totalReadableConnectionCount : Int {
@@ -123,9 +131,14 @@ public final class ConnectionPool {
             self.writeConnection = try! DirectConnection(self.location, flags: flags, dispatcher: ReentrantDispatcher("SQLite.ConnectionPool.Write"), vfsName: vfsName)
             self.writeConnection.busyTimeout = 2
 
-            if let delegate = self.delegate {
-                delegate.pool(self, didAddConnection: self.writeConnection)
+            for setupProcessor in self.internalSetup.values {
+                try! setupProcessor(self.writeConnection)
             }
+            
+            for setupProcessor in self.setup {
+                try! setupProcessor(self.writeConnection)
+            }
+            
         }
 
         return writeConnection
@@ -140,23 +153,32 @@ public final class ConnectionPool {
 
             dispatch_sync(lockQueue) {
 
+                // Ensure database is open
+                self.writable
+                
                 let connection : DirectConnection
 
                 if let availableConnection = self.availableReadConnections.popLast() {
                     connection = availableConnection
                 }
-                else if self.delegate?.poolShouldAddConnection(self) ?? true {
+                else {
 
                     let flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_WAL | SQLITE_OPEN_NOMUTEX
 
                     connection = try! DirectConnection(self.location, flags: flags, dispatcher: ImmediateDispatcher(), vfsName: vfsName)
                     connection.busyTimeout = 2
 
-                    self.delegate?.pool(self, didAddConnection: connection)
+                    for (type, setupProcessor) in self.internalSetup {
+                        if type == .WriteAheadLogging {
+                            continue
+                        }
+                        try! setupProcessor(connection)
+                    }
+                    
+                    for setupProcessor in self.setup {
+                        try! setupProcessor(connection)
+                    }
 
-                }
-                else {
-                    return
                 }
 
                 self.unavailableReadConnections.append(connection)

SQLiteTests/ConnectionPoolTests.swift

@@ -6,6 +6,19 @@ class ConnectionPoolTests : SQLiteTestCase {
     override func setUp() {
         super.setUp()
     }
+    
+    func testConnectionSetupClosures() {
+        
+        let _ = try? NSFileManager.defaultManager().removeItemAtPath("\(NSTemporaryDirectory())/SQLite.swift Pool Tests.sqlite")
+        let pool = try! ConnectionPool(.URI("\(NSTemporaryDirectory())/SQLite.swift Pool Tests.sqlite"))
+        
+        pool.foreignKeys = true
+        pool.setup.append { try $0.execute("CREATE TABLE IF NOT EXISTS test(value INT)") }
+        
+        XCTAssertTrue(try pool.readable.scalar("PRAGMA foreign_keys") as! Int64 == 1)
+        try! pool.writable.execute("INSERT INTO test(value) VALUES (1)")
+        try! pool.readable.execute("SELECT value FROM test")
+    }
 
     func testConcurrentAccess2() {