App crashes with many (not all) users running iOS 17.4.1 about grdb.swift HOT 8 CLOSED

import Foundation
import GRDB
import MapKit
import CSV
 :  :
    // Table = 'trail'
    struct Trail: Codable, FetchableRecord, PersistableRecord {
        var id: Int
        var title: String
        var descr: String
        var colour: String
    }

    // Table = 'coord'
    struct Coord: Codable, FetchableRecord, PersistableRecord {
        //var seqno: Int - auto-incremented primary key
        var trailid: Int
        var latitude: Double
        var longitude: Double
        var speed: Double
    }
    
    // Table = 'location'
    struct Location: Codable, FetchableRecord, PersistableRecord {
        var id: Int
        var title: String
        var descr: String
        var colour: String
        var longitude: Double
        var latitude: Double
    }
    
    // If these 4 values are the same in 2 trails or 2 locations, then assume they are duplicates
    // Although, theoretically the 2 trails could be different, it is exteremely unlikely
    struct UniqFeature {
        var title : String
        var descr : String
        var longitude : Double  // first longitude in a trail
        var latitude : Double   // first latitude in a trail
    }

    // ***************************
    init() throws {

        let folder = MyUtils.getAppFolder("trails")
        let filemgr = FileManager.default
        var isDir = ObjCBool(true)
        
        let exists = filemgr.fileExists(atPath: folder, isDirectory: &isDir)
        if !exists {
            // create folder and SQLite file
            do {
                try filemgr.createDirectory(atPath: folder, withIntermediateDirectories: true, attributes: nil)
            } catch let error as NSError {
                let str = "Unable to create trails directory: \(error.debugDescription)"
                throw myError(str)
            }
        }
        
        // Create SQLite file if it doesn't exist, else just connect ..
        do {
            let path = folder + "trails.sqlite"
            //trailsDB = try Connection(folder + "trails.sqlite")
            dbQueue = try DatabaseQueue(path: path)
            MyUtils.Log(TAG, "Opened trails.sqlite (un-encrypted)")
            
        } catch let error as NSError {
            let str = "Unable to create trails SQLite file: \(error.debugDescription)"
            throw myError(str)
        }

        // Create 'location' table if it doesn't exist
        /*
        let location = Table("location")
        let id = Expression<Int>("id")
        let title = Expression<String>("title")
        let descr = Expression<String>("descr")
        let colour = Expression<String>("colour")
        let longitude = Expression<Double>("longitude")
        let latitude = Expression<Double>("latitude")
        */

        do {
            try dbQueue!.write { db in
                try db.create(table: "location", ifNotExists: true) { t in
                    t.column("id", .integer)
                    t.column("title", .text)
                    t.column("descr", .text)
                    t.column("longitude", .double)
                    t.column("latitude", .double)
                    t.primaryKey(["id"])
                }
                try db.execute(sql: "CREATE INDEX IF NOT EXISTS index_location_on_longitude_latitude ON location(longitude, latitude)")
            }
          
        } catch let error as NSError {
            let str = "Unable to create 'location' table: \(error.debugDescription)"
            throw myError(str)
        }

        // Add 'colour' table to hold RGB value
        // Been tested on iPhone 7 - colour(TEXT) field is created.
        do {
            try dbQueue!.write { db in
                try db.execute(sql: "ALTER TABLE location ADD COLUMN colour text")
            }
        } catch let error as NSError {
            let str = "Unable to add 'colour' column to 'location' table: \(error.debugDescription)"
            MyUtils.Log(TAG, str)
        }

        // Create 'trail' and 'coord' tables if they don't exist
        /*
        let trail = Table("trail")
        let id = Expression<Int>("id")
        let title = Expression<String>("title")
        let descr = Expression<String>("descr")
        */
 
        do {
            try dbQueue!.write { db in
                try db.create(table: "trail", ifNotExists: true) { t in
                    t.column("id", .integer)
                    t.column("title", .text)
                    t.column("descr", .text)
                    t.primaryKey(["id"])
                }
            }
            /*
            try trailsDB.run(trail.create(ifNotExists: true) { t in
                t.column(id, primaryKey: true)        // "id" INTEGER PRIMARY KEY NOT NULL,
                t.column(title)
                t.column(descr)
            }) */
        } catch let error as NSError {
            let str = "Unable to create 'trail' table: \(error.debugDescription)"
            throw myError(str)
            //return
        }
        
        // Add 'colour' to trail
        do {
            try dbQueue!.write { db in
                try db.execute(sql: "ALTER TABLE trail ADD COLUMN colour text")
            }
        } catch let error as NSError {
            let str = "Unable to add 'colour' column to 'trail' table: \(error.debugDescription)"
            MyUtils.Log(TAG, str)
        }

        /*
        let coord = Table("coord")
        let seqno = Expression<Int>("seqno")
        let trailid = Expression<Int>("trailid")
        let speed = Expression<Double>("speed")
        */

        do {
            try dbQueue!.write { db in
                try db.create(table: "coord", ifNotExists: true) { t in
                    t.autoIncrementedPrimaryKey("seqno")
                    t.column("trailid", .integer)
                    t.column("latitude", .double)
                    t.column("longitude", .double)
                    t.column("speed", .double)
                }
                try db.execute(sql: "CREATE INDEX IF NOT EXISTS index_coord_on_trailid  ON coord(trailid)")
            }
            /*
            try trailsDB.run(coord.create(ifNotExists: true) { t in
                t.column(seqno, primaryKey: .autoincrement) // "seqno" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL
                t.column(trailid)
                t.column(latitude)
                t.column(longitude)
                t.column(speed)
            })
            try trailsDB.run(coord.createIndex(trailid, ifNotExists: true))
            */
        } catch let error as NSError {
            let str = "Unable to create 'coord' table: \(error.debugDescription)"
            throw myError(str)
        }
    }
    // ***************************
    // ***************************
    func readTrails(trails: inout [trailGPS], idStart: Int, idFinish: Int) throws -> Int {
        
        // Read IDs between idStart and idFinish inclusive
        
        if (dbQueue == nil) {return -1}
            
        /*
        let trail = Table("trail")
        let id = Expression<Int>("id")
        let coord = Table("coord")
        let trailid = Expression<Int>("trailid")
        let seqno = Expression<Int>("seqno")
        let title = Expression<String>("title")
        let descr = Expression<String>("descr")
        let speed = Expression<Double>("speed")
        let latitude = Expression<Double>("latitude")
        let longitude = Expression<Double>("longitude")
        */
        
        // Read data - one SELECT statement
        var oldid: Int = 0
        var coords: Int = 0
        var trailGps: trailGPS!
        do {
            try dbQueue!.read { db in
                // Fetch database rows - always build SQL in DB Browser for Sqlite
                let rows = try Row.fetchCursor(db, sql: """
                    SELECT * FROM trail
                    INNER JOIN coord on trail.id = coord.trailid
                    WHERE id>=? AND id<=?
                    ORDER BY id, seqno
                """, arguments: [idStart, idFinish])
                
                while let row = try rows.next() {
                    
                    // If CSV has 'colour' column, then get colour as TrailColour
                    var color = TrailColour.MAGENTA
                    if let colr = row["colour"] {
                        color = TrailColour(rawValue: colr as! String) ?? .MAGENTA
                    }
                    
                    //print("id: \(user[id]), email: \(user[email]), name: \(user[name])")
                    if oldid == 0 || oldid != row["id"] {
                        if oldid != 0 {
                            // append complete trail to array
                            trails.append(trailGps)
                        }
                        // next trail ..
                        trailGps = trailGPS(trailid: row["id"])
                        trailGps.title = row["title"]
                        trailGps.descr = row["descr"]
                        trailGps.colour = color
                    }
                    
                    coords += 1
                    trailGps.add(coord: CLLocationCoordinate2D(
                        latitude: row["latitude"], longitude: row["longitude"]),
                        speed: row["speed"])
                    oldid = row["id"]
                }
            }
            
            // LAST trail read (unless database is empty) ..
            if oldid != 0 {trails.append(trailGps)}
            
        } catch let error as NSError {
            let str = "Unable to read trails from SQLite: \(error.debugDescription)"
            throw myError(str)
            //return
        }

        MyUtils.getSQLiteTableCount(dbQueue: dbQueue!, tablename: "trail")
        MyUtils.getSQLiteTableCount(dbQueue: dbQueue!, tablename: "coord")

        return coords
    }
    
    // ***************************

   

try dbQueue!.read { db in

Crashed: GRDB.DatabaseQueue
0  libsqlite3.dylib                  0x9a10c sqlite3_sourceid + 36940
1  libsqlite3.dylib                  0x52a7c sqlite3_column_type + 104