Native user_version support in Connection

Documentation/Index.md

@@ -1457,21 +1457,11 @@ try db.run(users.drop(ifExists: true))
 
 ### Migrations and Schema Versioning
 
-You can add a convenience property on `Connection` to query and set the
+You can use the convenience property on `Connection` to query and set the
 [`PRAGMA user_version`](https://sqlite.org/pragma.html#pragma_user_version).
 
 This is a great way to manage your schema’s version over migrations.
-
-```swift
-extension Connection {
-    public var userVersion: Int32 {
-        get { return Int32(try! scalar("PRAGMA user_version") as! Int64)}
-        set { try! run("PRAGMA user_version = \(newValue)") }
-    }
-}
-```
-
-Then you can conditionally run your migrations along the lines of:
+You can conditionally run your migrations along the lines of:
 
 ```swift
 if db.userVersion == 0 {

Sources/SQLite/Core/Connection.swift

@@ -152,6 +152,19 @@ public final class Connection {
         Int(sqlite3_total_changes(handle))
     }
 
+    /// The user version of the database.
+    /// See SQLite [PRAGMA user_version](https://sqlite.org/pragma.html#pragma_user_version)
+    public var userVersion: Int32? {
+        get {
+            (try? scalar("PRAGMA user_version") as? Int64).map(Int32.init)
+        }
+        set {
+            if let userVersion = newValue {
+                _ = try? run("PRAGMA user_version = \(userVersion)")
+            }
+        }
+    }
+
     // MARK: - Execute
 
     /// Executes a batch of SQL statements.

Tests/SQLiteTests/ConnectionTests.swift

@@ -96,6 +96,11 @@ class ConnectionTests: SQLiteTestCase {
         XCTAssertEqual(2, db.totalChanges)
     }
 
+    func test_userVersion() {
+        db.userVersion = 2
+        XCTAssertEqual(2, db.userVersion!)
+    }
+
     func test_prepare_preparesAndReturnsStatements() {
         _ = try! db.prepare("SELECT * FROM users WHERE admin = 0")
         _ = try! db.prepare("SELECT * FROM users WHERE admin = ?", 0)

Tests/SQLiteTests/QueryTests.swift

@@ -391,15 +391,27 @@ class QueryTests: XCTestCase {
         let value = TestCodable(int: 1, string: "2", bool: true, float: 3, double: 4,
                                 date: Date(timeIntervalSince1970: 0), optional: nil, sub: value1)
         let update = try emails.update(value)
-        let encodedJSON = try JSONEncoder().encode(value1)
-        let encodedJSONString = String(data: encodedJSON, encoding: .utf8)!
-        assertSQL(
+
+        // NOTE: As Linux JSON decoding doesn't order keys the same way, we need to check prefix, suffix,
+        // and extract JSON to decode it and check the decoded object.
+
+        let expectedPrefix =
             """
             UPDATE \"emails\" SET \"int\" = 1, \"string\" = '2', \"bool\" = 1, \"float\" = 3.0, \"double\" = 4.0,
-             \"date\" = '1970-01-01T00:00:00.000', \"sub\" = '\(encodedJSONString)'
-            """.replacingOccurrences(of: "\n", with: ""),
-            update
-        )
+             \"date\" = '1970-01-01T00:00:00.000', \"sub\" = '
+            """.replacingOccurrences(of: "\n", with: "")
+        let expectedSuffix = "'"
+
+        let sql = update.asSQL()
+        XCTAssert(sql.hasPrefix(expectedPrefix))
+        XCTAssert(sql.hasSuffix(expectedSuffix))
+
+        let extractedJSON = String(sql[
+            sql.index(sql.startIndex, offsetBy: expectedPrefix.count) ..<
+            sql.index(sql.endIndex, offsetBy: -expectedSuffix.count)
+        ])
+        let decodedJSON = try JSONDecoder().decode(TestCodable.self, from: extractedJSON.data(using: .utf8)!)
+        XCTAssertEqual(decodedJSON, value1)
     }
 
     func test_delete_compilesDeleteExpression() {

Tests/SQLiteTests/TestHelpers.swift

@@ -105,7 +105,7 @@ let qualifiedTable = Table("table", database: "main")
 let virtualTable = VirtualTable("virtual_table")
 let _view = View("view") // avoid Mac XCTestCase collision
 
-class TestCodable: Codable {
+class TestCodable: Codable, Equatable {
     let int: Int
     let string: String
     let bool: Bool
@@ -125,4 +125,15 @@ class TestCodable: Codable {
         self.optional = optional
         self.sub = sub
     }
+
+    static func == (lhs: TestCodable, rhs: TestCodable) -> Bool {
+        lhs.int == rhs.int &&
+        lhs.string == rhs.string &&
+        lhs.bool == rhs.bool &&
+        lhs.float == rhs.float &&
+        lhs.double == rhs.double &&
+        lhs.date == rhs.date &&
+        lhs.optional == rhs.optional &&
+        lhs.sub == rhs.sub
+    }
 }