Use vfs for exclusivity

vfs seems to be a more reliable handling of exclusive mode.

Author: kdubb

SQLite/Core/Connection.swift

@@ -268,9 +268,9 @@ public final class DBConnection : Connection, Equatable {
     ///     Default: `false`.
     ///
     /// - Returns: A new database connection.
-    public convenience init(_ location: Location = .InMemory, readonly: Bool = false) throws {
+    public convenience init(_ location: Location = .InMemory, readonly: Bool = false, vfsName: String? = nil) throws {
         let flags = readonly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE
-        try self.init(location, flags: flags, dispatcher: ReentrantDispatcher("SQLite.Connection"))
+        try self.init(location, flags: flags, dispatcher: ReentrantDispatcher("SQLite.Connection"), vfsName: vfsName)
     }
 
     /// Initializes a new SQLite connection.
@@ -285,9 +285,14 @@ public final class DBConnection : Connection, Equatable {
     ///   - dispatcher: Dispatcher synchronization blocks
     ///
     /// - Returns: A new database connection.
-    public init(_ location: Location, flags: Int32, dispatcher: Dispatcher) throws {
+    public init(_ location: Location, flags: Int32, dispatcher: Dispatcher, vfsName: String? = nil) throws {
         self.dispatcher = dispatcher
-        try check(sqlite3_open_v2(location.description, &_handle, flags, nil))
+        if let vfsName = vfsName {
+            try check(sqlite3_open_v2(location.description, &_handle, flags, vfsName))
+        }
+        else {
+            try check(sqlite3_open_v2(location.description, &_handle, flags, nil))
+        }
         try check(sqlite3_extended_result_codes(handle, 1))
     }
 

SQLite/Core/ConnectionPool.swift

@@ -25,6 +25,9 @@
 import Foundation
 
 
+private let vfsName = "unix-excl"
+
+
 /// Connection pool delegate
 public protocol ConnectionPoolDelegate {
 
@@ -44,15 +47,13 @@ public final class ConnectionPool {
     private var unavailableReadConnections = [DBConnection]()
     private let lockQueue : dispatch_queue_t
     private var writeConnection : DBConnection!
-    private let writeQueue : dispatch_queue_t
 
     public var delegate : ConnectionPoolDelegate?
 
     public init(_ location: DBConnection.Location) throws {
         self.location = location
         self.lockQueue = dispatch_queue_create("SQLite.ConnectionPool.Lock", DISPATCH_QUEUE_SERIAL)
-        self.writeQueue = dispatch_queue_create("SQLite.ConnectionPool.Write", DISPATCH_QUEUE_SERIAL)
-        try writable.execute("PRAGMA locking_mode = EXCLUSIVE; PRAGMA journal_mode = WAL;")
+        try writable.execute("PRAGMA journal_mode = WAL;")
     }
 
     public var totalReadableConnectionCount : Int {
@@ -114,12 +115,16 @@ public final class ConnectionPool {
     // Acquires a read/write connection to the database
     public var writable : DBConnection {
 
-        
         var writeConnectionInit = dispatch_once_t()
         dispatch_once(&writeConnectionInit) {
-            let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_WAL
-            self.writeConnection = try! DBConnection(self.location, flags: flags, dispatcher: ReentrantDispatcher("SQLite.WriteConnection"))
+        
+            let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_WAL | SQLITE_OPEN_NOMUTEX
+            self.writeConnection = try! DBConnection(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)
+            }
         }
 
         return writeConnection
@@ -141,8 +146,9 @@ public final class ConnectionPool {
                 }
                 else if self.delegate?.poolShouldAddConnection(self) ?? true {
 
-                    let flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_WAL
-                    connection = try! DBConnection(self.location, flags: flags, dispatcher: ImmediateDispatcher())
+                    let flags = SQLITE_OPEN_READONLY | SQLITE_OPEN_WAL | SQLITE_OPEN_NOMUTEX
+                    
+                    connection = try! DBConnection(self.location, flags: flags, dispatcher: ImmediateDispatcher(), vfsName: vfsName)
                     connection.busyTimeout = 2
 
                     self.delegate?.pool(self, didAddConnection: connection)

SQLiteTests/ConnectionPoolTests.swift

@@ -34,7 +34,7 @@ class ConnectionPoolTests : SQLiteTestCase {
 
                 let conn = pool.readable
 
-                let stmt = conn.prepare("SELECT name FROM test WHERE id = ?")
+                let stmt = try! conn.prepare("SELECT name FROM test WHERE id = ?")
                 var curr = stmt.scalar(x) as! String
                 while !quit {
 
@@ -65,7 +65,7 @@ class ConnectionPoolTests : SQLiteTestCase {
                 XCTFail((error as? CustomStringConvertible)?.description ?? "Unknown")
             }
 
-            usleep(15000)
+            usleep(1500)
         }
 
         quit = true