import XCTest
import Dispatch
import Foundation
@testable import GRDB

class DatabasePoolConcurrencyTests: GRDBTestCase {
    
    func testDatabasePoolFundamental1() throws {
        // Constraint: the sum of values, the balance, must remain zero.
        //
        // This test shows (if needed) that writes that are not wrapped in a
        // transaction can not provide our guarantee, and that deferred
        // transaction provide the immutable view of the database needed by
        // dbPool.read().
        //
        // Reader                                   Writer
        // BEGIN DEFERRED TRANSACTION
        let s1 = DispatchSemaphore(value: 0)
        //                                          INSERT INTO moves VALUES (1)
        let s2 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves
        let s3 = DispatchSemaphore(value: 0)
        //                                          INSERT INTO moves VALUES (-1)
        let s4 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves
        // END
        
        do {
            let dbQueue = try makeDatabaseQueue(filename: "test.sqlite")
            try dbQueue.writeWithoutTransaction { db in
                let journalMode = try String.fetchOne(db, sql: "PRAGMA journal_mode = wal")
                XCTAssertEqual(journalMode, "wal")
                try db.create(table: "moves") { $0.column("value", .integer) }
                try db.execute(sql: "INSERT INTO moves VALUES (0)")
            }
        }
        let s0 = DispatchSemaphore(value: 0)
        let block1 = { () in
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            s0.signal() // Avoid "database is locked" error: don't open the two databases at the same time
            try! dbQueue.writeWithoutTransaction { db in
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 1)  // Non-zero balance
                s3.signal()
                _ = s4.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 1)  // Non-zero balance
                try db.execute(sql: "END")
            }
        }
        let block2 = { () in
            _ = s0.wait(timeout: .distantFuture) // Avoid "database is locked" error: don't open the two databases at the same time
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            try! dbQueue.writeWithoutTransaction { db in
                _ = s1.wait(timeout: .distantFuture)
                try db.execute(sql: "INSERT INTO moves VALUES (1)")
                s2.signal()
                _ = s3.wait(timeout: .distantFuture)
                try db.execute(sql: "INSERT INTO moves VALUES (-1)")
                s4.signal()
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testDatabasePoolFundamental2() throws {
        // Constraint: the sum of values, the balance, must remain zero.
        //
        // This test shows that deferred transactions play well with concurrent
        // immediate transactions.
        //
        // Reader                                   Writer
        //                                          BEGIN IMMEDIATE TRANSACTION
        let s1 = DispatchSemaphore(value: 0)
        // BEGIN DEFERRED TRANSACTION
        let s2 = DispatchSemaphore(value: 0)
        //                                          INSERT INTO moves VALUES (1)
        let s3 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves
        let s4 = DispatchSemaphore(value: 0)
        //                                          INSERT INTO moves VALUES (-1)
        let s5 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves
        // END                                      END
        
        do {
            let dbQueue = try makeDatabaseQueue(filename: "test.sqlite")
            try dbQueue.writeWithoutTransaction { db in
                let journalMode = try String.fetchOne(db, sql: "PRAGMA journal_mode = wal")
                XCTAssertEqual(journalMode, "wal")
                try db.create(table: "moves") { $0.column("value", .integer) }
                try db.execute(sql: "INSERT INTO moves VALUES (0)")
            }
        }
        let s0 = DispatchSemaphore(value: 0)
        let block1 = { () in
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            s0.signal() // Avoid "database is locked" error: don't open the two databases at the same time
            try! dbQueue.writeWithoutTransaction { db in
                _ = s1.wait(timeout: .distantFuture)
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                s2.signal()
                _ = s3.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 0)  // Zero balance
                s4.signal()
                _ = s5.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 0)  // Zero balance
                try db.execute(sql: "END")
            }
        }
        let block2 = { () in
            _ = s0.wait(timeout: .distantFuture) // Avoid "database is locked" error: don't open the two databases at the same time
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            try! dbQueue.writeWithoutTransaction { db in
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                try db.execute(sql: "INSERT INTO moves VALUES (1)")
                s3.signal()
                _ = s4.wait(timeout: .distantFuture)
                try db.execute(sql: "INSERT INTO moves VALUES (-1)")
                s5.signal()
                try db.execute(sql: "END")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testDatabasePoolFundamental3() throws {
        // Constraint: the sum of values, the balance, must remain zero.
        //
        // This test shows that deferred transactions play well with concurrent
        // immediate transactions.
        //
        // Reader                                   Writer
        // BEGIN DEFERRED TRANSACTION
        let s1 = DispatchSemaphore(value: 0)
        //                                          BEGIN IMMEDIATE TRANSACTION
        //                                          INSERT INTO moves VALUES (1)
        let s2 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves
        let s3 = DispatchSemaphore(value: 0)
        //                                          INSERT INTO moves VALUES (-1)
        let s4 = DispatchSemaphore(value: 0)
        // SELECT SUM(value) AS balance FROM moves  END
        // END
        
        do {
            let dbQueue = try makeDatabaseQueue(filename: "test.sqlite")
            try dbQueue.writeWithoutTransaction { db in
                let journalMode = try String.fetchOne(db, sql: "PRAGMA journal_mode = wal")
                XCTAssertEqual(journalMode, "wal")
                try db.create(table: "moves") { $0.column("value", .integer) }
                try db.execute(sql: "INSERT INTO moves VALUES (0)")
            }
        }
        let s0 = DispatchSemaphore(value: 0)
        let block1 = { () in
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            s0.signal() // Avoid "database is locked" error: don't open the two databases at the same time
            try! dbQueue.writeWithoutTransaction { db in
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 0)  // Zero balance
                s3.signal()
                _ = s4.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT SUM(value) AS balance FROM moves"), 0)  // Zero balance
                try db.execute(sql: "END")
            }
        }
        let block2 = { () in
            _ = s0.wait(timeout: .distantFuture) // Avoid "database is locked" error: don't open the two databases at the same time
            let dbQueue = try! self.makeDatabaseQueue(filename: "test.sqlite")
            try! dbQueue.writeWithoutTransaction { db in
                _ = s1.wait(timeout: .distantFuture)
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                try db.execute(sql: "INSERT INTO moves VALUES (1)")
                s2.signal()
                _ = s3.wait(timeout: .distantFuture)
                try db.execute(sql: "INSERT INTO moves VALUES (-1)")
                s4.signal()
                try db.execute(sql: "END")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testWrappedReadWrite() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
        }
        let id = try dbPool.read { db in
            try Int.fetchOne(db, sql: "SELECT id FROM items")!
        }
        XCTAssertEqual(id, 1)
    }
    
    func testReadFromPreviousNonWALDatabase() throws {
        do {
            let dbQueue = try makeDatabaseQueue(filename: "test.sqlite")
            try dbQueue.writeWithoutTransaction { db in
                try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        do {
            let dbPool = try makeDatabasePool(filename: "test.sqlite")
            let id = try dbPool.read { db in
                try Int.fetchOne(db, sql: "SELECT id FROM items")!
            }
            XCTAssertEqual(id, 1)
        }
    }
    
    func testWriteOpensATransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            XCTAssertTrue(db.isInsideTransaction)
            do {
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                XCTFail("Expected error")
            } catch let error as DatabaseError {
                XCTAssertEqual(error.resultCode, .SQLITE_ERROR)
                XCTAssertEqual(error.message!, "cannot start a transaction within a transaction")
                XCTAssertEqual(error.sql!, "BEGIN DEFERRED TRANSACTION")
                XCTAssertEqual(error.description, "SQLite error 1: cannot start a transaction within a transaction - while executing `BEGIN DEFERRED TRANSACTION`")
            }
        }
    }
    
    func testWriteWithoutTransactionDoesNotOpenATransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.writeWithoutTransaction { db in
            XCTAssertFalse(db.isInsideTransaction)
            try db.beginTransaction()
            try db.commit()
        }
    }
    
    func testReadOpensATransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.read { db in
            XCTAssertTrue(db.isInsideTransaction)
            do {
                try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                XCTFail("Expected error")
            } catch let error as DatabaseError {
                XCTAssertEqual(error.resultCode, .SQLITE_ERROR)
                XCTAssertEqual(error.message!, "cannot start a transaction within a transaction")
                XCTAssertEqual(error.sql!, "BEGIN DEFERRED TRANSACTION")
                XCTAssertEqual(error.description, "SQLite error 1: cannot start a transaction within a transaction - while executing `BEGIN DEFERRED TRANSACTION`")
            }
        }
    }
    
    func testReadError() throws {
        // Necessary for this test to run as quickly as possible
        dbConfiguration.readonlyBusyMode = .immediateError
        let dbPool = try makeDatabasePool()
        
        // Block 1                          Block 2
        // PRAGMA locking_mode=EXCLUSIVE
        // CREATE TABLE
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                                  dbPool.read // throws
        
        let block1 = { () in
            try! dbPool.writeWithoutTransaction { db in
                try db.execute(sql: "PRAGMA locking_mode=EXCLUSIVE")
                try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
                s1.signal()
            }
        }
        let block2 = { () in
            _ = s1.wait(timeout: .distantFuture)
            do {
                try dbPool.read { _ in }
                XCTFail("Expected error")
            } catch let error as DatabaseError {
                XCTAssertEqual(error.resultCode, .SQLITE_BUSY)
                XCTAssertEqual(error.message!, "database is locked")
            } catch {
                XCTFail("Expected DatabaseError")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testConcurrentRead() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            for _ in 0..<3 {
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        
        // Block 1                      Block 2
        // dbPool.read {                dbPool.read {
        // SELECT * FROM items          SELECT * FROM items
        // step                         step
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              step
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // step                         step
        // step                         end
        // end                          }
        // }
        
        let block1 = { () in
            try! dbPool.read { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
            }
        }
        let block2 = { () in
            try! dbPool.read { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                _ = s1.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                s2.signal()
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadMethodIsolationOfStatement() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            for _ in 0..<2 {
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        
        // Block 1                      Block 2
        // dbPool.read {
        // SELECT * FROM items
        // step
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              DELETE * FROM items
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // step
        // end
        // }
        
        let block1 = { () in
            try! dbPool.read { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "DELETE FROM items")
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadMethodIsolationOfStatementWithCheckpoint() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            for _ in 0..<2 {
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        
        // Block 1                      Block 2
        // dbPool.read {
        // SELECT * FROM items
        // step
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              DELETE * FROM items
        //                              Checkpoint
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // step
        // end
        // }
        
        let block1 = { () in
            try! dbPool.read { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "DELETE FROM items")
                    try db.checkpoint()
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadBlockIsolationStartingWithRead() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        // Block 1                      Block 2
        // dbPool.read {
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              INSERT INTO items (id) VALUES (NULL)
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // SELECT COUNT(*) FROM items -> 0
        // >
        let s3 = DispatchSemaphore(value: 0)
        //                              INSERT INTO items (id) VALUES (NULL)
        //                              <
        let s4 = DispatchSemaphore(value: 0)
        // SELECT COUNT(*) FROM items -> 0
        // }
        
        let block1 = { () in
            try! dbPool.read { db in
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                // We read 0 due to snaphot isolation: the reader has checked
                // the schema version before `s1` could let the writer insert
                // an item.
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
                s3.signal()
                _ = s4.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s2.signal()
                    _ = s3.wait(timeout: .distantFuture)
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s4.signal()
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadBlockIsolationStartingWithSelect() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        // Block 1                      Block 2
        // dbPool.read {
        // SELECT COUNT(*) FROM items -> 0
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              INSERT INTO items (id) VALUES (NULL)
        //                              Checkpoint
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // SELECT COUNT(*) FROM items -> 0
        // }
        
        let block1 = { () in
            try! dbPool.read { db in
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    try db.checkpoint()
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadBlockIsolationStartingWithWrite() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        // Block 1                      Block 2
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              dbPool.read {
        //                              SELECT COUNT(*) FROM items -> 1
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s3 = DispatchSemaphore(value: 0)
        //                              SELECT COUNT(*) FROM items -> 1
        //                              <
        let s4 = DispatchSemaphore(value: 0)
        // >
        let s5 = DispatchSemaphore(value: 0)
        //                              SELECT COUNT(*) FROM items -> 1
        //                              }
        
        let block1 = { () in
            do {
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s1.signal()
                    _ = s2.wait(timeout: .distantFuture)
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s3.signal()
                    _ = s4.wait(timeout: .distantFuture)
                }
                s5.signal()
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let block2 = { () in
            try! dbPool.read { db in
                _ = s1.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
                s2.signal()
                _ = s3.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
                s4.signal()
                _ = s5.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testReadBlockIsolationStartingWithWriteTransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        // Block 1                      Block 2
        // BEGIN IMMEDIATE TRANSACTION
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              dbPool.read {
        //                              SELECT COUNT(*) FROM items -> 0
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s3 = DispatchSemaphore(value: 0)
        //                              SELECT COUNT(*) FROM items -> 0
        //                              <
        let s4 = DispatchSemaphore(value: 0)
        // COMMIT
        // >
        let s5 = DispatchSemaphore(value: 0)
        //                              SELECT COUNT(*) FROM items -> 0
        //                              }
        
        let block1 = { () in
            do {
                try dbPool.writeInTransaction(.immediate) { db in
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s1.signal()
                    _ = s2.wait(timeout: .distantFuture)
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    s3.signal()
                    _ = s4.wait(timeout: .distantFuture)
                    return .commit
                }
                s5.signal()
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let block2 = { () in
            try! dbPool.read { db in
                _ = s1.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
                s2.signal()
                _ = s3.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
                s4.signal()
                _ = s5.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testUnsafeReadMethodIsolationOfStatement() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            for _ in 0..<2 {
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        
        // Block 1                      Block 2
        // dbPool.unsafeRead {
        // SELECT * FROM items
        // step
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              DELETE * FROM items
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // step
        // end
        // SELECT COUNT(*) FROM items -> 0
        // }
        
        let block1 = { () in
            try! dbPool.unsafeRead { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "DELETE FROM items")
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testUnsafeReadMethodIsolationOfStatementWithCheckpoint() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            for _ in 0..<2 {
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
            }
        }
        
        // Block 1                      Block 2
        // dbPool.unsafeRead {
        // SELECT * FROM items
        // step
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              DELETE * FROM items
        //                              Checkpoint
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // step
        // end
        // }
        
        let block1 = { () in
            try! dbPool.unsafeRead { db in
                let cursor = try Row.fetchCursor(db, sql: "SELECT * FROM items")
                XCTAssertTrue(try cursor.next() != nil)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertTrue(try cursor.next() != nil)
                XCTAssertTrue(try cursor.next() == nil)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "DELETE FROM items")
                    try db.checkpoint()
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testUnsafeReadMethodIsolationOfBlock() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        // Block 1                      Block 2
        // dbPool.unsafeRead {
        // SELECT COUNT(*) FROM items -> 0
        // >
        let s1 = DispatchSemaphore(value: 0)
        //                              INSERT INTO items (id) VALUES (NULL)
        //                              Checkpoint
        //                              <
        let s2 = DispatchSemaphore(value: 0)
        // SELECT COUNT(*) FROM items -> 1
        // }
        
        let block1 = { () in
            try! dbPool.unsafeRead { db in
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 0)
                s1.signal()
                _ = s2.wait(timeout: .distantFuture)
                XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
            }
        }
        let block2 = { () in
            do {
                _ = s1.wait(timeout: .distantFuture)
                defer { s2.signal() }
                try dbPool.writeWithoutTransaction { db in
                    try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                    try db.checkpoint()
                }
            } catch {
                XCTFail("error: \(error)")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testLongRunningReadTransaction() throws {
        // A test for a "user-defined" DatabaseSnapshot based on DatabaseQueue
        let dbName = "test.sqlite"
        let dbPool = try makeDatabasePool(filename: dbName)
        dbConfiguration.allowsUnsafeTransactions = true
        dbConfiguration.readonly = true
        let dbQueue = try makeDatabaseQueue(filename: dbName)
        
        try dbPool.write { db in
            try db.create(table: "t") { $0.primaryKey("id", .integer) }
            try db.execute(sql: "INSERT INTO t DEFAULT VALUES")
        }
        
        try dbQueue.writeWithoutTransaction { db in
            try db.beginTransaction(.deferred)
        }
        
        try dbQueue.writeWithoutTransaction { db in
            try XCTAssertEqual(Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!, 1)
        }
        
        try dbPool.write { db in
            try db.execute(sql: "INSERT INTO t DEFAULT VALUES")
        }
        
        try dbQueue.writeWithoutTransaction { db in
            try XCTAssertEqual(Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!, 1)
            try db.rollback()
            try XCTAssertEqual(Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!, 2)
        }
    }
    
    func testIssue80() throws {
        // See https://github.com/groue/GRDB.swift/issues/80
        //
        // Here we test that `SELECT * FROM search`, which is announced by
        // SQLite has a statement that modifies the sqlite_master table, is
        // still allowed as a regular select statement.
        //
        // This test uses a database pool, a connection for creating the
        // search virtual table, and another connection for reading.
        //
        // This is the tested setup: don't change it.
        
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE VIRTUAL TABLE search USING fts3(title)")
        }
        try dbPool.read { db in
            _ = try Row.fetchAll(db, sql: "SELECT * FROM search")
        }
    }
    
    func testDefaultLabel() throws {
        let dbPool = try makeDatabasePool()
        dbPool.writeWithoutTransaction { db in
            XCTAssertEqual(db.configuration.label, nil)
            XCTAssertEqual(db.description, "GRDB.DatabasePool.writer")
            
            // This test CAN break in future releases: the dispatch queue labels
            // are documented to be a debug-only tool.
            let label = String(utf8String: __dispatch_queue_get_label(nil))
            XCTAssertEqual(label, "GRDB.DatabasePool.writer")
        }
        
        let s1 = DispatchSemaphore(value: 0)
        let s2 = DispatchSemaphore(value: 0)
        let block1 = { () in
            try! dbPool.read { db in
                XCTAssertEqual(db.configuration.label, nil)
                XCTAssertEqual(db.description, "GRDB.DatabasePool.reader.1")
                
                // This test CAN break in future releases: the dispatch queue labels
                // are documented to be a debug-only tool.
                let label = String(utf8String: __dispatch_queue_get_label(nil))
                XCTAssertEqual(label, "GRDB.DatabasePool.reader.1")
                
                _ = s1.signal()
                _ = s2.wait(timeout: .distantFuture)
            }
        }
        let block2 = { () in
            _ = s1.wait(timeout: .distantFuture)
            try! dbPool.read { db in
                _ = s2.signal()
                XCTAssertEqual(db.configuration.label, nil)
                XCTAssertEqual(db.description, "GRDB.DatabasePool.reader.2")
                
                // This test CAN break in future releases: the dispatch queue labels
                // are documented to be a debug-only tool.
                let label = String(utf8String: __dispatch_queue_get_label(nil))
                XCTAssertEqual(label, "GRDB.DatabasePool.reader.2")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testCustomLabel() throws {
        dbConfiguration.label = "Toreador"
        let dbPool = try makeDatabasePool()
        dbPool.writeWithoutTransaction { db in
            XCTAssertEqual(db.configuration.label, "Toreador")
            XCTAssertEqual(db.description, "Toreador.writer")
            
            // This test CAN break in future releases: the dispatch queue labels
            // are documented to be a debug-only tool.
            let label = String(utf8String: __dispatch_queue_get_label(nil))
            XCTAssertEqual(label, "Toreador.writer")
        }
        
        let s1 = DispatchSemaphore(value: 0)
        let s2 = DispatchSemaphore(value: 0)
        let block1 = { () in
            try! dbPool.read { db in
                XCTAssertEqual(db.configuration.label, "Toreador")
                XCTAssertEqual(db.description, "Toreador.reader.1")
                
                // This test CAN break in future releases: the dispatch queue labels
                // are documented to be a debug-only tool.
                let label = String(utf8String: __dispatch_queue_get_label(nil))
                XCTAssertEqual(label, "Toreador.reader.1")
                
                _ = s1.signal()
                _ = s2.wait(timeout: .distantFuture)
            }
        }
        let block2 = { () in
            _ = s1.wait(timeout: .distantFuture)
            try! dbPool.read { db in
                _ = s2.signal()
                XCTAssertEqual(db.configuration.label, "Toreador")
                XCTAssertEqual(db.description, "Toreador.reader.2")
                
                // This test CAN break in future releases: the dispatch queue labels
                // are documented to be a debug-only tool.
                let label = String(utf8String: __dispatch_queue_get_label(nil))
                XCTAssertEqual(label, "Toreador.reader.2")
            }
        }
        let blocks = [block1, block2]
        DispatchQueue.concurrentPerform(iterations: blocks.count) { index in
            blocks[index]()
        }
    }
    
    func testTargetQueue() throws {
        func test(targetQueue: DispatchQueue) throws {
            dbConfiguration.targetQueue = targetQueue
            let dbPool = try makeDatabasePool()
            try dbPool.write { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
            try dbPool.read { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
        }
        
        // background queue
        try test(targetQueue: .global(qos: .background))
        
        // main queue
        let expectation = self.expectation(description: "main")
        DispatchQueue.global(qos: .default).async {
            try! test(targetQueue: .main)
            expectation.fulfill()
        }
        waitForExpectations(timeout: 2, handler: nil)
    }
    
    func testWriteTargetQueue() throws {
        func test(targetQueue: DispatchQueue, writeTargetQueue: DispatchQueue) throws {
            dbConfiguration.targetQueue = targetQueue
            dbConfiguration.writeTargetQueue = writeTargetQueue
            let dbPool = try makeDatabasePool()
            try dbPool.write { _ in
                dispatchPrecondition(condition: .onQueue(writeTargetQueue))
            }
            try dbPool.read { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
        }
        
        // background queue
        try test(targetQueue: .global(qos: .background), writeTargetQueue: DispatchQueue(label: "writer"))
        
        // main queue
        let expectation = self.expectation(description: "main")
        DispatchQueue.global(qos: .default).async {
            try! test(targetQueue: .main, writeTargetQueue: .main)
            expectation.fulfill()
        }
        waitForExpectations(timeout: 2, handler: nil)
    }
    
    func testWriteTargetQueueReadOnly() throws {
        // Create a database before we perform read-only accesses
        _ = try makeDatabasePool(filename: "test")
        
        func test(targetQueue: DispatchQueue, writeTargetQueue: DispatchQueue) throws {
            dbConfiguration.readonly = true
            dbConfiguration.targetQueue = targetQueue
            dbConfiguration.writeTargetQueue = writeTargetQueue // unused
            let dbPool = try makeDatabasePool(filename: "test")
            try dbPool.write { _ in
                // Not on writeTargetQueue because read-only
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
            try dbPool.read { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
        }
        
        try test(targetQueue: .global(qos: .background), writeTargetQueue: DispatchQueue(label: "writer"))
    }

    func testQoS() throws {
        func test(qos: DispatchQoS) throws {
            // https://forums.swift.org/t/what-is-the-default-target-queue-for-a-serial-queue/18094/5
            //
            // > [...] the default target queue [for a serial queue] is the
            // > [default] overcommit [global concurrent] queue.
            //
            // We want this default target queue in order to test database QoS
            // with dispatchPrecondition(condition:).
            //
            // > [...] You can get a reference to the overcommit queue by
            // > dropping down to the C function dispatch_get_global_queue
            // > (available in Swift with a __ prefix) and passing the private
            // > value of DISPATCH_QUEUE_OVERCOMMIT.
            // >
            // > [...] Of course you should not do this in production code,
            // > because DISPATCH_QUEUE_OVERCOMMIT is not a public API. I don't
            // > know of a way to get a reference to the overcommit queue using
            // > only public APIs.
            let DISPATCH_QUEUE_OVERCOMMIT: UInt = 2
            let targetQueue = __dispatch_get_global_queue(
                Int(qos.qosClass.rawValue.rawValue),
                DISPATCH_QUEUE_OVERCOMMIT)
            
            dbConfiguration.qos = qos
            let dbPool = try makeDatabasePool()
            try dbPool.write { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
            try dbPool.read { _ in
                dispatchPrecondition(condition: .onQueue(targetQueue))
            }
        }
        
        try test(qos: .background)
        try test(qos: .userInitiated)
    }
    
    // MARK: - ConcurrentRead
    
    func testConcurrentReadOpensATransaction() throws {
        let dbPool = try makeDatabasePool()
        let future = dbPool.writeWithoutTransaction { db in
            dbPool.concurrentRead { db in
                XCTAssertTrue(db.isInsideTransaction)
                do {
                    try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                    XCTFail("Expected error")
                } catch {
                }
            }
        }
        try future.wait()
    }
    
    func testConcurrentReadOutsideOfTransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.create(table: "persons") { t in
                t.primaryKey("id", .integer)
            }
        }
        
        // Writer                       Reader
        // dbPool.writeWithoutTransaction {
        // >
        //                              dbPool.concurrentRead {
        //                              <
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s1 = DispatchSemaphore(value: 0)
        // }                            SELECT COUNT(*) FROM persons -> 0
        //                              <
        //                              }
        
        let future: DatabaseFuture<Int> = try dbPool.writeWithoutTransaction { db in
            let future: DatabaseFuture<Int> = dbPool.concurrentRead { db in
                _ = s1.wait(timeout: .distantFuture)
                return try! Int.fetchOne(db, sql: "SELECT COUNT(*) FROM persons")!
            }
            try db.execute(sql: "INSERT INTO persons DEFAULT VALUES")
            s1.signal()
            return future
        }
        XCTAssertEqual(try future.wait(), 0)
    }
    
    func testConcurrentReadError() throws {
        // Necessary for this test to run as quickly as possible
        dbConfiguration.readonlyBusyMode = .immediateError
        let dbPool = try makeDatabasePool()
        try dbPool.writeWithoutTransaction { db in
            try db.execute(sql: "PRAGMA locking_mode=EXCLUSIVE")
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            let future = dbPool.concurrentRead { db in
                fatalError("Should not run")
            }
            do {
                try future.wait()
            } catch let error as DatabaseError {
                XCTAssertEqual(error.resultCode, .SQLITE_BUSY)
                XCTAssertEqual(error.message!, "database is locked")
            }
        }
    }
    
    // MARK: - AsyncConcurrentRead
    
    func testAsyncConcurrentReadOpensATransaction() throws {
        let dbPool = try makeDatabasePool()
        var isInsideTransaction: Bool? = nil
        let expectation = self.expectation(description: "read")
        dbPool.writeWithoutTransaction { db in
            dbPool.asyncConcurrentRead { dbResult in
                do {
                    let db = try dbResult.get()
                    isInsideTransaction = db.isInsideTransaction
                    do {
                        try db.execute(sql: "BEGIN DEFERRED TRANSACTION")
                        XCTFail("Expected error")
                    } catch {
                    }
                } catch {
                    XCTFail("Unexpected error: \(error)")
                }
                expectation.fulfill()
            }
        }
        waitForExpectations(timeout: 1, handler: nil)
        XCTAssertEqual(isInsideTransaction, true)
    }
    
    func testAsyncConcurrentReadOutsideOfTransaction() throws {
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.create(table: "persons") { t in
                t.primaryKey("id", .integer)
            }
        }
        
        // Writer                       Reader
        // dbPool.writeWithoutTransaction {
        // >
        //                              dbPool.concurrentRead {
        //                              <
        // INSERT INTO items (id) VALUES (NULL)
        // >
        let s1 = DispatchSemaphore(value: 0)
        // }                            SELECT COUNT(*) FROM persons -> 0
        //                              <
        //                              }
        
        var count: Int? = nil
        let expectation = self.expectation(description: "read")
        try dbPool.writeWithoutTransaction { db in
            dbPool.asyncConcurrentRead { dbResult in
                do {
                    _ = s1.wait(timeout: .distantFuture)
                    let db = try dbResult.get()
                    count = try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM persons")!
                } catch {
                    XCTFail("Unexpected error: \(error)")
                }
                expectation.fulfill()
            }
            try db.execute(sql: "INSERT INTO persons DEFAULT VALUES")
            s1.signal()
        }
        waitForExpectations(timeout: 1, handler: nil)
        XCTAssertEqual(count, 0)
    }
    
    func testAsyncConcurrentReadError() throws {
        // Necessary for this test to run as quickly as possible
        dbConfiguration.readonlyBusyMode = .immediateError
        let dbPool = try makeDatabasePool()
        var readError: DatabaseError? = nil
        let expectation = self.expectation(description: "read")
        try dbPool.writeWithoutTransaction { db in
            try db.execute(sql: "PRAGMA locking_mode=EXCLUSIVE")
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
            dbPool.asyncConcurrentRead { dbResult in
                guard case let .failure(error) = dbResult,
                    let dbError = error as? DatabaseError
                    else {
                        XCTFail("Unexpected result: \(dbResult)")
                        return
                }
                readError = dbError
                expectation.fulfill()
            }
            waitForExpectations(timeout: 1, handler: nil)
            XCTAssertEqual(readError!.resultCode, .SQLITE_BUSY)
            XCTAssertEqual(readError!.message!, "database is locked")
        }
    }
    
    // MARK: - Barrier
    
    func testBarrierLocksReads() throws {
        let expectation = self.expectation(description: "lock")
        expectation.isInverted = true
        
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        var fetchedValue: Int?
        let s1 = DispatchSemaphore(value: 0)
        let s2 = DispatchSemaphore(value: 0)
        let s3 = DispatchSemaphore(value: 0)
        
        DispatchQueue.global().async {
            try! dbPool.barrierWriteWithoutTransaction { db in
                try db.execute(sql: "INSERT INTO items (id) VALUES (NULL)")
                s1.signal()
                s2.wait()
            }
        }
        
        DispatchQueue.global().async {
            // Wait for barrier to start
            s1.wait()
            
            fetchedValue = try! dbPool.read { db in
                try Int.fetchOne(db, sql: "SELECT id FROM items")!
            }
            expectation.fulfill()
            s3.signal()
        }
        
        // Assert that read is blocked
        waitForExpectations(timeout: 1)
        
        // Release barrier
        s2.signal()
        
        // Wait for read to complete
        s3.wait()
        XCTAssertEqual(fetchedValue, 1)
    }
    
    func testBarrierIsLockedByOneUnfinishedRead() throws {
        let expectation = self.expectation(description: "lock")
        expectation.isInverted = true
        
        let dbPool = try makeDatabasePool()
        try dbPool.write { db in
            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
        }
        
        let s1 = DispatchSemaphore(value: 0)
        let s2 = DispatchSemaphore(value: 0)
        let s3 = DispatchSemaphore(value: 0)
        let s4 = DispatchSemaphore(value: 0)
        
        DispatchQueue.global().async {
            try! dbPool.read { _ in
                s1.signal()
                s2.signal()
                s3.wait()
            }
        }
        
        DispatchQueue.global().async {
            // Wait for read to start
            s1.wait()
            
            try! dbPool.barrierWriteWithoutTransaction { _ in }
            expectation.fulfill()
            s4.signal()
        }
        
        // Assert that barrier is blocked
        waitForExpectations(timeout: 1)
        
        // Release read
        s3.signal()
        
        // Wait for barrier to complete
        s4.wait()
    }
    
    // MARK: - Concurrent opening
    
    func testConcurrentOpening() throws {
        for _ in 0..<50 {
            let dbDirectoryName = "DatabasePoolConcurrencyTests-\(ProcessInfo.processInfo.globallyUniqueString)"
            let directoryURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
                .appendingPathComponent(dbDirectoryName, isDirectory: true)
            let dbURL = directoryURL.appendingPathComponent("db.sqlite")
            try FileManager.default.createDirectory(atPath: directoryURL.path, withIntermediateDirectories: true, attributes: nil)
            defer { try! FileManager.default.removeItem(at: directoryURL) }
            DispatchQueue.concurrentPerform(iterations: 10) { n in
                // WTF I could never Google for the proper correct error handling
                // of NSFileCoordinator. What a weird API.
                let coordinator = NSFileCoordinator(filePresenter: nil)
                var coordinatorError: NSError?
                var poolError: Error?
                coordinator.coordinate(writingItemAt: dbURL, options: .forMerging, error: &coordinatorError) { url in
                    do {
                        _ = try DatabasePool(path: url.path)
                    } catch {
                        poolError = error
                    }
                }
                XCTAssert(poolError ?? coordinatorError == nil)
            }
        }
    }
    
    // MARK: - NSFileCoordinator sample code tests
    
    // Test for sample code in Documentation.docc/DatabaseSharing.md.
    // This test passes if this method compiles
    private func openSharedDatabase(at databaseURL: URL) throws -> DatabasePool {
        let coordinator = NSFileCoordinator(filePresenter: nil)
        var coordinatorError: NSError?
        var dbPool: DatabasePool?
        var dbError: Error?
        coordinator.coordinate(writingItemAt: databaseURL, options: .forMerging, error: &coordinatorError) { url in
            do {
                dbPool = try openDatabase(at: url)
            } catch {
                dbError = error
            }
        }
        if let error = dbError ?? coordinatorError {
            throw error
        }
        return dbPool!
    }
    
    // Test for sample code in Documentation.docc/DatabaseSharing.md.
    // This test passes if this method compiles
    private func openDatabase(at databaseURL: URL) throws -> DatabasePool {
        let dbPool = try DatabasePool(path: databaseURL.path)
        // Perform here other database setups, such as defining
        // the database schema with a DatabaseMigrator.
        return dbPool
    }
    
    // Test for sample code in Documentation.docc/DatabaseSharing.md.
    // This test passes if this method compiles
    private func openSharedReadOnlyDatabase(at databaseURL: URL) throws -> DatabasePool? {
        let coordinator = NSFileCoordinator(filePresenter: nil)
        var coordinatorError: NSError?
        var dbPool: DatabasePool?
        var dbError: Error?
        coordinator.coordinate(readingItemAt: databaseURL, options: .withoutChanges, error: &coordinatorError) { url in
            do {
                dbPool = try openReadOnlyDatabase(at: url)
            } catch {
                dbError = error
            }
        }
        if let error = dbError ?? coordinatorError {
            throw error
        }
        return dbPool
    }
    
    // Test for sample code in Documentation.docc/DatabaseSharing.md.
    // This test passes if this method compiles
    private func openReadOnlyDatabase(at databaseURL: URL) throws -> DatabasePool? {
        do {
            var configuration = Configuration()
            configuration.readonly = true
            return try DatabasePool(path: databaseURL.path, configuration: configuration)
        } catch {
            if FileManager.default.fileExists(atPath: databaseURL.path) {
                // Something went wrong
                throw error
            } else {
                // Database file does not exist
                return nil
            }
        }
    }
}