325 lines
10 KiB
Swift
325 lines
10 KiB
Swift
import Foundation
|
|
import GRDB
|
|
|
|
/// AppDatabase lets the application access the database.
|
|
///
|
|
/// It applies the pratices recommended at
|
|
/// <https://github.com/groue/GRDB.swift/blob/master/Documentation/GoodPracticesForDesigningRecordTypes.md>
|
|
struct AppDatabase {
|
|
/// Creates an `AppDatabase`, and make sure the database schema is ready.
|
|
init(_ dbWriter: any DatabaseWriter) throws {
|
|
self.dbWriter = dbWriter
|
|
try migrator.migrate(dbWriter)
|
|
}
|
|
|
|
/// Provides access to the database.
|
|
///
|
|
/// Application can use a `DatabasePool`, while SwiftUI previews and tests
|
|
/// can use a fast in-memory `DatabaseQueue`.
|
|
///
|
|
/// See <https://swiftpackageindex.com/groue/grdb.swift/documentation/grdb/databaseconnections>
|
|
private let dbWriter: any DatabaseWriter
|
|
|
|
/// The DatabaseMigrator that defines the database schema.
|
|
///
|
|
/// See <https://swiftpackageindex.com/groue/grdb.swift/documentation/grdb/migrations>
|
|
private var migrator: DatabaseMigrator {
|
|
var migrator = DatabaseMigrator()
|
|
|
|
#if DEBUG
|
|
// Speed up development by nuking the database when migrations change
|
|
// See <https://swiftpackageindex.com/groue/grdb.swift/documentation/grdb/migrations>
|
|
migrator.eraseDatabaseOnSchemaChange = true
|
|
#endif
|
|
|
|
migrator.registerMigration("createLine") { db in
|
|
// Create a table
|
|
// See <https://swiftpackageindex.com/groue/grdb.swift/documentation/grdb/databaseschema>
|
|
try db.create(table: "Line") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("body", .text).notNull()
|
|
t.column("chap", .integer).notNull()
|
|
t.column("line_id", .integer).notNull()
|
|
t.column("book", .text).notNull()
|
|
t.column("verse", .integer)
|
|
}
|
|
|
|
try db.create(table: "Seg") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("seg_id", .integer).notNull()
|
|
t.column("line_id", .integer).notNull()
|
|
t.column("book", .text).notNull()
|
|
}
|
|
|
|
try db.create(table: "RibbonGroup") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("currentUndoLevel", .integer).notNull()
|
|
t.column("minLevel", .integer).notNull()
|
|
t.column("maxLevel", .text).notNull()
|
|
t.column("pos", .integer).notNull()
|
|
t.column("title", .text).notNull()
|
|
}
|
|
|
|
try db.create(table: "Ribbon") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("group", .integer).notNull()
|
|
t.column("undoLevel", .integer).notNull()
|
|
t.column("book", .text).notNull()
|
|
t.column("scrollOffset", .integer).notNull()
|
|
t.column("scrollId", .text)
|
|
}
|
|
|
|
try db.create(table: "SelectedRibbon") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("ribbonGroupId", .integer).notNull()
|
|
}
|
|
|
|
try db.create(table: "ScrollState") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("scrollId", .text).notNull()
|
|
t.column("scrollOffset", .integer).notNull()
|
|
}
|
|
|
|
// change this to nuke/remake the database
|
|
try db.create(table: "foo1") { t in
|
|
t.autoIncrementedPrimaryKey("id")
|
|
t.column("ribbonId", .integer).notNull()
|
|
}
|
|
}
|
|
|
|
|
|
// Migrations for future application versions will be inserted here:
|
|
// migrator.registerMigration(...) { db in
|
|
// ...
|
|
// }
|
|
|
|
return migrator
|
|
}
|
|
}
|
|
|
|
// MARK: - Database Access: Writes
|
|
|
|
|
|
func load<T: Decodable>(_ filename: String) -> T {
|
|
let data: Data
|
|
|
|
guard let file = Bundle.main.url(forResource: filename, withExtension: nil)
|
|
else {
|
|
fatalError("Couldn't find \(filename) in main bundle.")
|
|
}
|
|
|
|
do {
|
|
data = try Data(contentsOf: file)
|
|
} catch {
|
|
fatalError("Couldn't load \(filename) from main bundle:\n\(error)")
|
|
}
|
|
|
|
do {
|
|
let decoder = JSONDecoder()
|
|
return try decoder.decode(T.self, from: data)
|
|
} catch {
|
|
fatalError("Couldn't parse \(filename) as \(T.self):\n\(error)")
|
|
}
|
|
}
|
|
|
|
extension AppDatabase {
|
|
|
|
func updateRibbonPosition(_ ribbon: inout Ribbon, _ oldPos: Int, _ newPos: Int) async throws {
|
|
try await dbWriter.write { [ribbon] db in
|
|
|
|
// This is only for moving back rn
|
|
|
|
print("MEOW HERE")
|
|
print(oldPos)
|
|
print(newPos)
|
|
print(ribbon)
|
|
print(ribbon.id!)
|
|
print("MEOW HERE 2")
|
|
|
|
|
|
// try db.execute(sql: """
|
|
// BEGIN TRANSACTION;
|
|
// """)
|
|
do {
|
|
|
|
if (newPos < oldPos) {
|
|
|
|
try db.execute(sql: """
|
|
UPDATE Ribbon
|
|
SET pos =
|
|
CASE
|
|
WHEN pos = ? THEN ?
|
|
ELSE
|
|
pos + 1
|
|
END
|
|
WHERE (pos >= ? AND pos <= ?)
|
|
""", arguments: [oldPos, newPos, newPos, oldPos])
|
|
} else {
|
|
|
|
print("DIFFFFF")
|
|
|
|
try db.execute(sql: """
|
|
UPDATE Ribbon
|
|
SET pos =
|
|
CASE
|
|
WHEN pos = ? THEN ?
|
|
ELSE
|
|
pos - 1
|
|
END
|
|
WHERE (pos >= ? AND pos <= ?)
|
|
""", arguments: [oldPos, newPos, oldPos, newPos])
|
|
|
|
}
|
|
|
|
// try db.execute(sql: """
|
|
// UPDATE Ribbon
|
|
// SET pos = ?
|
|
// WHERE (id = ?)
|
|
// """, arguments: [newPos, ribbon.id!])
|
|
|
|
var ret = try Ribbon.fetchAll(db, sql: "SELECT * FROM Ribbon ORDER BY pos ASC") // [Player]
|
|
// print(ret)
|
|
print("all")
|
|
print(ret)
|
|
} catch {
|
|
print("Error info: \(error)")
|
|
}
|
|
|
|
// try ribbon.saved(db)
|
|
|
|
// try db.execute(sql: """
|
|
// COMMIT;
|
|
// """)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func saveRibbon(_ ribbon: inout Ribbon) async throws {
|
|
// if ribbon.name.isEmpty {
|
|
// throw ValidationError.missingName
|
|
// }
|
|
ribbon = try await dbWriter.write { [ribbon] db in
|
|
try ribbon.saved(db)
|
|
}
|
|
}
|
|
|
|
func saveSelectedRibbon(_ selectedRibbon: inout SelectedRibbon) async throws {
|
|
// if ribbon.name.isEmpty {
|
|
// throw ValidationError.missingName
|
|
// }
|
|
try await dbWriter.write { [selectedRibbon] db in
|
|
try selectedRibbon.update(db)
|
|
}
|
|
}
|
|
|
|
func saveScrollState(_ scrollState: inout ScrollState) async throws {
|
|
// if ribbon.name.isEmpty {
|
|
// throw ValidationError.missingName
|
|
// }
|
|
try await dbWriter.write { [scrollState] db in
|
|
try scrollState.update(db)
|
|
}
|
|
}
|
|
|
|
func importJson(_ filename: String, _ db: Database) throws {
|
|
let importJson: JsonImport = load(filename)
|
|
|
|
var x = 0
|
|
// if try Line.all().isEmpty(db) {
|
|
for l in importJson.lines {
|
|
// print("importing Lines")
|
|
if x < 5 {
|
|
print(l)
|
|
x += 1
|
|
}
|
|
_ = try l.inserted(db)
|
|
}
|
|
|
|
x = 0
|
|
for l in importJson.segs {
|
|
// print("importing SEGS")
|
|
|
|
if x < 5 {
|
|
print(l)
|
|
x += 1
|
|
}
|
|
_ = try l.inserted(db)
|
|
}
|
|
}
|
|
|
|
/// Create random Lines if the database is empty.
|
|
func initDatabase() throws {
|
|
do {
|
|
try dbWriter.write { db in
|
|
if try Line.all().isEmpty(db) {
|
|
try importJson("john_export.json", db)
|
|
try importJson("mark_export.json", db)
|
|
|
|
_ = try RibbonGroup(id: 1,
|
|
pos: 1,
|
|
title: "John",
|
|
current_undo_level: 1,
|
|
min_level: 1,
|
|
max_level: 1).inserted(db)
|
|
|
|
_ = try Ribbon(id: 1,
|
|
group: 1,
|
|
undoLevel: 1,
|
|
book: "bible.john",
|
|
scrollId: "1",
|
|
scrollOffset: 0).inserted(db)
|
|
|
|
_ = try RibbonGroup(id: 2,
|
|
pos: 2,
|
|
title: "Second",
|
|
current_undo_level: 1,
|
|
min_level: 1,
|
|
max_level: 1).inserted(db)
|
|
|
|
_ = try Ribbon(id: 2,
|
|
group: 2,
|
|
undoLevel: 1,
|
|
book: "bible.mark",
|
|
scrollId: "1",
|
|
scrollOffset: 0).inserted(db)
|
|
|
|
_ = try RibbonGroup(id: 3,
|
|
pos: 3,
|
|
title: "Another one",
|
|
current_undo_level: 1,
|
|
min_level: 1,
|
|
max_level: 1).inserted(db)
|
|
|
|
_ = try Ribbon(id: 3,
|
|
group: 3,
|
|
undoLevel: 1,
|
|
book: "bible.john",
|
|
scrollId: "1",
|
|
scrollOffset: 0).inserted(db)
|
|
|
|
_ = try SelectedRibbon(id: 1, ribbonGroupId: 1).inserted(db)
|
|
}
|
|
}
|
|
} catch {
|
|
print("Error info: \(error)")
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - Database Access: Reads
|
|
|
|
// This demo app does not provide any specific reading method, and insteadKK
|
|
// gives an unrestricted read-only access to the rest of the application.
|
|
// In your app, you are free to choose another path, and define focused
|
|
// reading methods.
|
|
extension AppDatabase {
|
|
/// Provides a read-only access to the database
|
|
var reader: DatabaseReader {
|
|
dbWriter
|
|
}
|
|
}
|