Reuse SQLiteFeature in SchemaChanger

Author: jberkel

Sources/SQLite/Core/SQLiteFeature.swift

@@ -3,11 +3,17 @@ import Foundation
 enum SQLiteFeature {
     case partialIntegrityCheck      // PRAGMA integrity_check(table)
     case sqliteSchemaTable          // sqlite_master => sqlite_schema
+    case renameColumn               // ALTER TABLE ... RENAME COLUMN
+    case dropColumn                 // ALTER TABLE ... DROP COLUMN
 
     func isSupported(by version: SQLiteVersion) -> Bool {
         switch self {
         case .partialIntegrityCheck, .sqliteSchemaTable:
-            return version > SQLiteVersion(major: 3, minor: 33)
+            return version >= .init(major: 3, minor: 33)
+        case .renameColumn:
+            return version >= .init(major: 3, minor: 25)
+        case .dropColumn:
+            return version >= .init(major: 3, minor: 35)
         }
     }
 }

Sources/SQLite/Schema/Connection+Schema.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 public extension Connection {
-    var schemaReader: SchemaReader { SchemaReader(connection: self) }
+    var schema: SchemaReader { SchemaReader(connection: self) }
 
     // There are four columns in each result row.
     // The first column is the name of the table that
@@ -14,7 +14,7 @@ public extension Connection {
     // https://sqlite.org/pragma.html#pragma_foreign_key_check
     func foreignKeyCheck(table: String? = nil) throws -> [ForeignKeyError] {
         try run("PRAGMA foreign_key_check" + (table.map { "(\($0.quote()))" } ?? ""))
-            .compactMap { row -> ForeignKeyError? in
+            .compactMap { (row: [Binding?]) -> ForeignKeyError? in
                 guard let table = row[0] as? String,
                       let rowId = row[1] as? Int64,
                       let target = row[2] as? String else { return nil }

Sources/SQLite/Schema/SchemaChanger.swift

@@ -52,9 +52,9 @@ public class SchemaChanger: CustomStringConvertible {
             switch self {
             case .addColumn(let definition):
                 return "ALTER TABLE \(table.quote()) ADD COLUMN \(definition.toSQL())"
-            case .renameColumn(let from, let to) where version >= .init(major: 3, minor: 25):
+            case .renameColumn(let from, let to) where SQLiteFeature.renameColumn.isSupported(by: version):
                 return "ALTER TABLE \(table.quote()) RENAME COLUMN \(from.quote()) TO \(to.quote())"
-            case .dropColumn(let column) where version >= .init(major: 3, minor: 35):
+            case .dropColumn(let column) where SQLiteFeature.dropColumn.isSupported(by: version):
                 return "ALTER TABLE \(table.quote()) DROP COLUMN \(column.quote())"
             default: return nil
             }
@@ -128,7 +128,7 @@ public class SchemaChanger: CustomStringConvertible {
 
     init(connection: Connection, version: SQLiteVersion) {
         self.connection = connection
-        schemaReader = connection.schemaReader
+        schemaReader = connection.schema
         self.version = version
     }
 

Sources/SQLite/Schema/SchemaDefinitions.swift

@@ -245,8 +245,9 @@ public struct IndexDefinition: Equatable {
         }
 
         func orders(sql: String) -> [String: IndexDefinition.Order] {
-            IndexDefinition.orderRe.matches(in: sql, range: NSRange(location: 0, length: sql.count))
-                    .reduce([String: IndexDefinition.Order]()) { (memo, result) in
+            IndexDefinition.orderRe
+                .matches(in: sql, range: NSRange(location: 0, length: sql.count))
+                .reduce([String: IndexDefinition.Order]()) { (memo, result) in
                         var memo2 = memo
                         let column = (sql as NSString).substring(with: result.range(at: 1))
                         memo2[column] = .DESC

Sources/SQLite/Schema/SchemaReader.swift

@@ -38,7 +38,7 @@ public class SchemaReader {
     public func objectDefinitions(name: String? = nil,
                                   type: ObjectDefinition.ObjectType? = nil,
                                   temp: Bool = false) throws -> [ObjectDefinition] {
-        var query: QueryType = connection.schemaTable(temp: temp)
+        var query: QueryType = SchemaTable.get(for: connection, temp: temp)
         if let name = name {
             query = query.where(SchemaTable.nameColumn == name)
         }
@@ -125,22 +125,30 @@ public class SchemaReader {
     }
 }
 
-private class SchemaTable {
-    internal static let name = Table("sqlite_schema", database: "main")
-    internal static let tempName = Table("sqlite_schema", database: "temp")
+private enum SchemaTable {
+    private static let name = Table("sqlite_schema", database: "main")
+    private static let tempName = Table("sqlite_schema", database: "temp")
+    // legacy names (< 3.33.0)
+    private static let masterName = Table("sqlite_master")
+    private static let tempMasterName = Table("sqlite_temp_master")
 
-    // legacy table names
-    internal static let masterName = Table("sqlite_master")
-    internal static let tempMasterName = Table("sqlite_temp_master")
+    static func get(for connection: Connection, temp: Bool = false) -> Table {
+        if connection.supports(.sqliteSchemaTable) {
+            return temp ? SchemaTable.tempName : SchemaTable.name
+        } else {
+            return temp ? SchemaTable.tempMasterName : SchemaTable.masterName
+        }
+    }
 
+    // columns
     static let typeColumn = Expression<String>("type")
     static let nameColumn = Expression<String>("name")
     static let tableNameColumn = Expression<String>("tbl_name")
     static let rootPageColumn = Expression<Int64?>("rootpage")
     static let sqlColumn = Expression<String?>("sql")
 }
 
-private class TableInfoTable {
+private enum TableInfoTable {
     static let idColumn = Expression<Int64>("cid")
     static let nameColumn = Expression<String>("name")
     static let typeColumn = Expression<String>("type")
@@ -149,7 +157,7 @@ private class TableInfoTable {
     static let primaryKeyColumn = Expression<Int64?>("pk")
 }
 
-private class IndexInfoTable {
+private enum IndexInfoTable {
     // The rank of the column within the index. (0 means left-most.)
     static let seqnoColumn = Expression<Int64>("seqno")
     // The rank of the column within the table being indexed.
@@ -159,7 +167,7 @@ private class IndexInfoTable {
     static let nameColumn = Expression<String?>("name")
 }
 
-private class IndexListTable {
+private enum IndexListTable {
     // A sequence number assigned to each index for internal tracking purposes.
     static let seqColumn = Expression<Int64>("seq")
     // The name of the index
@@ -174,7 +182,7 @@ private class IndexListTable {
     static let partialColumn = Expression<Int64>("partial")
 }
 
-private class ForeignKeyListTable {
+private enum ForeignKeyListTable {
     static let idColumn = Expression<Int64>("id")
     static let seqColumn = Expression<Int64>("seq")
     static let tableColumn = Expression<String>("table")
@@ -184,13 +192,3 @@ private class ForeignKeyListTable {
     static let onDeleteColumn = Expression<String>("on_delete")
     static let matchColumn = Expression<String>("match")
 }
-
-private extension Connection {
-    func schemaTable(temp: Bool = false) -> Table {
-        if supports(.sqliteSchemaTable) {
-            return temp ? SchemaTable.tempName : SchemaTable.name
-        } else {
-            return temp ? SchemaTable.tempMasterName : SchemaTable.masterName
-        }
-    }
-}

Tests/SQLiteTests/Schema/SchemaReaderTests.swift

@@ -8,7 +8,7 @@ class SchemaReaderTests: SQLiteTestCase {
         try super.setUpWithError()
         try createUsersTable()
 
-        schemaReader = db.schemaReader
+        schemaReader = db.schema
     }
 
     func test_columnDefinitions() throws {
@@ -168,6 +168,7 @@ class SchemaReaderTests: SQLiteTestCase {
         XCTAssertEqual(tables.map { table in [table.name, table.tableName, table.type.rawValue]}, [
             ["users", "users", "table"]
         ])
+        XCTAssertTrue((try schemaReader.objectDefinitions(type: .trigger)).isEmpty)
     }
 
     func test_objectDefinitionsFilterByName() throws {
@@ -176,5 +177,6 @@ class SchemaReaderTests: SQLiteTestCase {
         XCTAssertEqual(tables.map { table in [table.name, table.tableName, table.type.rawValue]}, [
             ["users", "users", "table"]
         ])
+        XCTAssertTrue((try schemaReader.objectDefinitions(name: "xxx")).isEmpty)
     }
 }