@capacitor-community/sqlite 5.2.3 → 5.2.4

package/ios/Plugin/CapacitorSQLite.swift

@@ -112,52 +112,50 @@ enum CapacitorSQLiteError: Error {
     // MARK: - IsSecretStored
 
     @objc public func isSecretStored()  throws -> NSNumber {
-        if isInit {
-            if isEncryption {
-                do {
-                    let isSecretExists: Bool = try UtilsSecret.isPassphrase(
-                        account: account)
-                    if isSecretExists {
-                        return 1
-                    } else {
-                        return 0
-                    }
-                } catch UtilsSecretError.prefixPassphrase(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                }
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+
+        guard isEncryption else {
+            throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+        }
+        do {
+            let isSecretExists: Bool = try UtilsSecret.isPassphrase(
+                account: account)
+            if isSecretExists {
+                return 1
             } else {
-                throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+                return 0
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+        } catch UtilsSecretError.prefixPassphrase(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
         }
     }
 
     // MARK: - SetEncryptionSecret
 
     @objc public func setEncryptionSecret(passphrase: String) throws {
-        if isInit {
-            if isEncryption {
-                do {
-                    // close all connections
-                    try closeAllConnections()
-                    // set encryption secret
-                    try UtilsSecret
-                        .setEncryptionSecret(prefix: prefixKeychain,
-                                             passphrase: passphrase,
-                                             databaseLocation: databaseLocation)
-                    return
-                } catch UtilsSecretError.setEncryptionSecret(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    throw CapacitorSQLiteError.failed(message: "\(error)")
-                }
-            } else {
-                throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+
+        guard isEncryption else {
+            throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+        }
+        do {
+            // close all connections
+            try closeAllConnections()
+            // set encryption secret
+            try UtilsSecret
+                .setEncryptionSecret(prefix: prefixKeychain,
+                                     passphrase: passphrase,
+                                     databaseLocation: databaseLocation)
+            return
+        } catch UtilsSecretError.setEncryptionSecret(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
     }
 
     // MARK: - ChangeEncryptionSecret
@@ -166,68 +164,59 @@ enum CapacitorSQLiteError: Error {
     // swiftlint:disable no_space_in_method_call
     @objc public func changeEncryptionSecret(call: CAPPluginCall, passphrase: String,
                                              oldPassphrase: String) throws {
-        if isInit {
-            if isEncryption {
-                self.call = call
-                let retHandler: ReturnHandler = ReturnHandler()
-                do {
-                    // close all connections
-                    try closeAllConnections()
-                    if isBiometricAuth {
-                        let dbLocation = databaseLocation
-                        let mPrefixKeychain = prefixKeychain
-                        bioIdAuth.authenticateUser { [weak self] message in
-                            if let message = message {
-                                self?.intBioMessage = message
-                                return
-                            } else {
-                                do {
-                                    try UtilsSecret.changeEncryptionSecret(
-                                        prefix: mPrefixKeychain,
-                                        passphrase: passphrase,
-                                        oldPassphrase: oldPassphrase,
-                                        databaseLocation: dbLocation)
-                                    retHandler.rResult(call: call)
-                                    return
-                                } catch UtilsSecretError.changeEncryptionSecret(let message) {
-                                    let msg = "ChangeEncryptionSecret: \(message)"
-                                    retHandler.rResult(call: call, message: msg)
-                                    return
-                                } catch let error {
-                                    retHandler.rResult(
-                                        call: call,
-                                        message: "ChangeEncryptionSecret: \(error.localizedDescription)")
-                                    return
-                                }
-                            }
-                        }
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+
+        guard isEncryption else {
+            throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+        }
+        self.call = call
+        let retHandler: ReturnHandler = ReturnHandler()
+        do {
+            // close all connections
+            try closeAllConnections()
+            if isBiometricAuth {
+                let dbLocation = databaseLocation
+                let mPrefixKeychain = prefixKeychain
+                bioIdAuth.authenticateUser { [weak self] message in
+                    if let message = message {
+                        self?.intBioMessage = message
                     } else {
-                        // set encryption secret
-                        try UtilsSecret
-                            .changeEncryptionSecret(prefix: prefixKeychain,
-                                                    passphrase: passphrase,
-                                                    oldPassphrase: oldPassphrase,
-                                                    databaseLocation: databaseLocation)
-                        retHandler.rResult(call: call)
-                        return
+                        do {
+                            try UtilsSecret.changeEncryptionSecret(
+                                prefix: mPrefixKeychain,
+                                passphrase: passphrase,
+                                oldPassphrase: oldPassphrase,
+                                databaseLocation: dbLocation)
+                            retHandler.rResult(call: call)
+                        } catch UtilsSecretError.changeEncryptionSecret(let message) {
+                            let msg = "ChangeEncryptionSecret: \(message)"
+                            retHandler.rResult(call: call, message: msg)
+                        } catch let error {
+                            retHandler.rResult(
+                                call: call,
+                                message: "ChangeEncryptionSecret: \(error.localizedDescription)")
+                        }
                     }
-                } catch UtilsSecretError.changeEncryptionSecret(let message) {
-                    let msg = "ChangeEncryptionSecret: \(message)"
-                    retHandler.rResult(call: call, message: msg)
-                    return
-                } catch let error {
-                    retHandler.rResult(
-                        call: call,
-                        message: "ChangeEncryptionSecret: \(error.localizedDescription)")
-                    return
                 }
             } else {
-                throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
-            }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+                // set encryption secret
+                try UtilsSecret
+                    .changeEncryptionSecret(prefix: prefixKeychain,
+                                            passphrase: passphrase,
+                                            oldPassphrase: oldPassphrase,
+                                            databaseLocation: databaseLocation)
+                retHandler.rResult(call: call)
+            }
+        } catch UtilsSecretError.changeEncryptionSecret(let message) {
+            let msg = "ChangeEncryptionSecret: \(message)"
+            retHandler.rResult(call: call, message: msg)
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "ChangeEncryptionSecret: \(error.localizedDescription)")
         }
-
     }
     // swiftlint:enable no_space_in_method_call
     // swiftlint:enable function_body_length
@@ -235,130 +224,123 @@ enum CapacitorSQLiteError: Error {
     // MARK: - ClearEncryptionSecret
 
     @objc public func clearEncryptionSecret() throws {
-        if isInit {
-            if isEncryption {
-                do {
-                    // close all connections
-                    try closeAllConnections()
-                    // set encryption secret
-                    try UtilsSecret
-                        .clearEncryptionSecret(prefix: prefixKeychain,
-                                               databaseLocation: databaseLocation)
-                    return
-                } catch UtilsSecretError.clearEncryptionSecret(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    throw CapacitorSQLiteError.failed(message: "\(error)")
-                }
-            } else {
-                throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        guard isEncryption else {
+            throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+        }
+        do {
+            // close all connections
+            try closeAllConnections()
+            // set encryption secret
+            try UtilsSecret
+                .clearEncryptionSecret(prefix: prefixKeychain,
+                                       databaseLocation: databaseLocation)
+            return
+        } catch UtilsSecretError.clearEncryptionSecret(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
     }
 
     // MARK: - CheckEncryptionSecret
 
     @objc public func checkEncryptionSecret(passphrase: String) throws ->  NSNumber {
-        if isInit {
-            if isEncryption {
-                do {
-                    // close all connections
-                    try closeAllConnections()
-                    // check encryption secret
-                    let res: NSNumber = try UtilsSecret
-                        .checkEncryptionSecret(prefix: prefixKeychain,
-                                               passphrase: passphrase)
-                    return res
-                } catch UtilsSecretError.checkEncryptionSecret(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    throw CapacitorSQLiteError.failed(message: "\(error)")
-                }
-            } else {
-                throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+
+        guard isEncryption else {
+            throw CapacitorSQLiteError.failed(message: "No Encryption set in capacitor.config")
+        }
+        do {
+            // close all connections
+            try closeAllConnections()
+            // check encryption secret
+            let res: NSNumber = try UtilsSecret
+                .checkEncryptionSecret(prefix: prefixKeychain,
+                                       passphrase: passphrase)
+            return res
+        } catch UtilsSecretError.checkEncryptionSecret(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
     }
 
     // MARK: - getNCDatabasePath
 
     @objc public func getNCDatabasePath(_ folderPath: String, dbName: String ) throws -> String {
-        if isInit {
-            do {
-                let databasePath: String = try UtilsNCDatabase
-                    .getNCDatabasePath(folderPath: folderPath,
-                                       database: dbName )
-                return databasePath
-            } catch let error {
-                throw CapacitorSQLiteError.failed(message: "\(error)")
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            let databasePath: String = try UtilsNCDatabase
+                .getNCDatabasePath(folderPath: folderPath,
+                                   database: dbName )
+            return databasePath
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
     }
 
     // MARK: - CreateNCConnection
 
     @objc public func createNCConnection(_ databasePath: String,
                                          version: Int) throws {
-        if isInit {
-
-            // check if the connection already exists
-            let connName: String = "RO_\(databasePath)"
-            let conn = dbDict[connName]
-            if conn != nil {
-                let msg = "Connection \(databasePath) already exists"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        // check if the connection already exists
+        let connName: String = "RO_\(databasePath)"
+        let conn = dbDict[connName]
+        if conn != nil {
+            let msg = "Connection \(databasePath) already exists"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
 
-            do {
-                let isFileExists: Bool = UtilsFile
-                    .isFileExist(filePath: databasePath)
+        do {
+            let isFileExists: Bool = UtilsFile
+                .isFileExist(filePath: databasePath)
 
-                if !isFileExists {
-                    throw CapacitorSQLiteError.failed(message: "database \(databasePath) does not exist")
-                }
-                let mDb: Database = try Database(
-                    databaseLocation: databaseLocation,
-                    databaseName: databasePath,
-                    encrypted: false, isEncryption: isEncryption, account: account,
-                    mode: "no-encryption", version: version, readonly: true,
-                    vUpgDict: [:])
-                dbDict[connName] = mDb
-                return
-            } catch let error {
-                throw CapacitorSQLiteError.failed(message: "\(error)")
+            if !isFileExists {
+                throw CapacitorSQLiteError.failed(message: "database \(databasePath) does not exist")
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let mDb: Database = try Database(
+                databaseLocation: databaseLocation,
+                databaseName: databasePath,
+                encrypted: false, isEncryption: isEncryption, account: account,
+                mode: "no-encryption", version: version, readonly: true,
+                vUpgDict: [:])
+            dbDict[connName] = mDb
+            return
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
         }
     }
 
     // MARK: - CloseNCConnection
 
     @objc public func closeNCConnection(_ dbName: String) throws {
-        if isInit {
-            let connName: String = "RO_\(dbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(dbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    try mDb.close()
-                } catch DatabaseError.close(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                }
-            }
-            dbDict.removeValue(forKey: connName)
-            return
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let connName: String = "RO_\(dbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(dbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                try mDb.close()
+            } catch DatabaseError.close(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            }
+        }
+        dbDict.removeValue(forKey: connName)
+        return
     }
 
     // MARK: - CreateConnection
@@ -370,287 +352,275 @@ enum CapacitorSQLiteError: Error {
                                        version: Int,
                                        vUpgDict: [Int: [String: Any]],
                                        readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            // check if the connection already exists
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            let conn = dbDict[connName]
-            if conn != nil {
-                let msg = "Connection \(mDbName) already exists"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if encrypted && !isEncryption {
-                let msg = "Database cannot be encrypted as 'No Encryption' set in capacitor.config"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                let mDb: Database = try Database(
-                    databaseLocation: databaseLocation,
-                    databaseName: "\(mDbName)SQLite.db",
-                    encrypted: encrypted, isEncryption: isEncryption, account: account,
-                    mode: mode, version: version, readonly: readonly,
-                    vUpgDict: vUpgDict)
-
-                dbDict[connName] = mDb
-                return
-            } catch let error {
-                throw CapacitorSQLiteError.failed(message: "\(error)")
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        // check if the connection already exists
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        let conn = dbDict[connName]
+        if conn != nil {
+            let msg = "Connection \(mDbName) already exists"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if encrypted && !isEncryption {
+            let msg = "Database cannot be encrypted as 'No Encryption' set in capacitor.config"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            let mDb: Database = try Database(
+                databaseLocation: databaseLocation,
+                databaseName: "\(mDbName)SQLite.db",
+                encrypted: encrypted, isEncryption: isEncryption, account: account,
+                mode: mode, version: version, readonly: readonly,
+                vUpgDict: vUpgDict)
+
+            dbDict[connName] = mDb
+            return
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
+        }
     }
     // swiftlint:enable function_parameter_count
 
     // MARK: - Open
 
     @objc public func open(_ dbName: String, readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                try mDb.open()
-                return
-            } catch DatabaseError.open(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            try mDb.open()
+            return
+        } catch DatabaseError.open(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        }
     }
 
     // MARK: - Close
 
     @objc public func close(_ dbName: String, readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                try mDb.close()
-                return
-            } catch DatabaseError.close(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            try mDb.close()
+            return
+        } catch DatabaseError.close(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        }
     }
-    
+
     // MARK: - BeginTransaction
 
     @objc public func beginTransaction(_ dbName: String) throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    let res = try mDb.beginTransaction()
-                    return ["changes": res]
-                } catch DatabaseError.beginTransaction(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                let res = try mDb.beginTransaction()
+                return ["changes": res]
+            } catch DatabaseError.beginTransaction(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
-    
+
     // MARK: - CommitTransaction
 
     @objc public func commitTransaction(_ dbName: String) throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    let res = try mDb.commitTransaction()
-                    return ["changes": res]
-                } catch DatabaseError.commitTransaction(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                let res = try mDb.commitTransaction()
+                return ["changes": res]
+            } catch DatabaseError.commitTransaction(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
-    
+
     // MARK: - RollbackTransaction
 
     @objc public func rollbackTransaction(_ dbName: String)
-                                                throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    let res = try mDb.rollbackTransaction()
-                    return ["changes": res]
-                } catch DatabaseError.rollbackTransaction(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+    throws -> [String: Any] {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                let res = try mDb.rollbackTransaction()
+                return ["changes": res]
+            } catch DatabaseError.rollbackTransaction(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - IsTransactionActive
 
     @objc public func isTransactionActive(_ dbName: String) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
 
-                do {
-                    let isAvail = try mDb.isAvailTrans()
-                    if isAvail {
-                        return 1
-                    } else {
-                        return 0
-                    }
-                } catch DatabaseError.isAvailTrans(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
+            do {
+                let isAvail = try mDb.isAvailTrans()
+                if isAvail {
+                    return 1
+                } else {
+                    return 0
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
-                throw CapacitorSQLiteError.failed(message: msg)
+            } catch DatabaseError.isAvailTrans(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - getUrl
 
     @objc public func getUrl(_ dbName: String, readonly: Bool) throws -> String {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            let res: String = mDb.getUrl()
-            return res
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        let res: String = mDb.getUrl()
+        return res
     }
 
     // MARK: - GetVersion
 
     @objc public func getVersion(_ dbName: String, readonly: Bool)
     throws ->  NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                let version: Int = try mDb.getVersion()
-                return NSNumber(value: version)
-
-            } catch DatabaseError.open(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            let version: Int = try mDb.getVersion()
+            return NSNumber(value: version)
+
+        } catch DatabaseError.open(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        }
     }
 
     // MARK: - GetFromHTTPRequest
 
     @objc public func getFromHTTPRequest(_ call: CAPPluginCall, url: String) throws {
-        if isInit {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        UtilsDownloadFromHTTP.download(databaseLocation: databaseLocation,
+                                       url: url) { ( result) in
+            switch result {
+            case .success(_):
+                self.retHandler.rResult(call: call)
+                return
+            case .failure(let error):
 
-            UtilsDownloadFromHTTP.download(databaseLocation: databaseLocation,
-                                           url: url) { ( result) in
-                switch result {
-                case .success(_):
-                    self.retHandler.rResult(call: call)
+                if error == .downloadFromHTTPFailed {
+                    let msg = "Download from HTTP failed"
+                    self.retHandler.rResult(call: call, message: msg)
                     return
-                case .failure(let error):
-
-                    if error == .downloadFromHTTPFailed {
-                        let msg = "Download from HTTP failed"
-                        self.retHandler.rResult(call: call, message: msg)
-                        return
-                    }
-
                 }
 
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+
         }
     }
 
     // MARK: - Close Connection
 
     @objc public func closeConnection(_ dbName: String, readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                return
-            }
-            if mDb.isDBOpen() {
-                do {
-                    try mDb.close()
-                } catch DatabaseError.close(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                }
-            }
-            dbDict.removeValue(forKey: connName)
-            return
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            return
+        }
+        if mDb.isDBOpen() {
+            do {
+                try mDb.close()
+            } catch DatabaseError.close(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            }
+        }
+        dbDict.removeValue(forKey: connName)
+        return
     }
 
     // MARK: - CheckConnectionsConsistency
@@ -658,149 +628,144 @@ enum CapacitorSQLiteError: Error {
     @objc public func checkConnectionsConsistency(_ dbNames: [String],
                                                   openModes: [String])
     throws ->  NSNumber {
-        if isInit {
-            var keys: [String] = Array(self.dbDict.keys)
-            var idx: Int = 0
-            var conns: [String] = []
-            for name in dbNames {
-                conns.append("\(openModes[idx])_\(name)")
-                idx += 1
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        var keys: [String] = Array(self.dbDict.keys)
+        var idx: Int = 0
+        var conns: [String] = []
+        for name in dbNames {
+            conns.append("\(openModes[idx])_\(name)")
+            idx += 1
+        }
+        do {
+            if conns.count == 0 {
+                try closeAllConnections()
+                return 0
             }
-            do {
-                if conns.count == 0 {
-                    try closeAllConnections()
-                    return 0
-                }
-                if keys.count < conns.count {
-                    // not solvable inconsistency
-                    try closeAllConnections()
-                    return 0
-                }
-                if keys.count > conns.count {
-                    for key in keys {
-                        if !conns.contains(key) {
-                            self.dbDict.removeValue(forKey: key)
-                        }
+            if keys.count < conns.count {
+                // not solvable inconsistency
+                try closeAllConnections()
+                return 0
+            }
+            if keys.count > conns.count {
+                for key in keys {
+                    if !conns.contains(key) {
+                        self.dbDict.removeValue(forKey: key)
                     }
                 }
-                keys = Array(self.dbDict.keys)
-                if keys.count == conns.count {
-                    let set1 = Set(keys)
-                    let set2 = Set(conns)
-                    let arr = Array(set1.symmetricDifference(set2))
-                    if arr.count == 0 {
-                        return 1
-                    } else {
-                        // not solvable inconsistency
-                        try closeAllConnections()
-                        return 0
-                    }
+            }
+            keys = Array(self.dbDict.keys)
+            if keys.count == conns.count {
+                let set1 = Set(keys)
+                let set2 = Set(conns)
+                let arr = Array(set1.symmetricDifference(set2))
+                if arr.count == 0 {
+                    return 1
                 } else {
+                    // not solvable inconsistency
                     try closeAllConnections()
                     return 0
                 }
-            } catch let error {
-                throw CapacitorSQLiteError.failed(message: "\(error)")
+            } else {
+                try closeAllConnections()
+                return 0
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+        } catch let error {
+            throw CapacitorSQLiteError.failed(message: "\(error)")
         }
     }
 
     // MARK: - IsDatabase
 
     @objc public func isDatabase(_ dbName: String) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let isFileExists: Bool = UtilsFile
-                .isFileExist(databaseLocation: databaseLocation,
-                             fileName: mDbName + "SQLite.db")
-            if isFileExists {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let isFileExists: Bool = UtilsFile
+            .isFileExist(databaseLocation: databaseLocation,
+                         fileName: mDbName + "SQLite.db")
+        if isFileExists {
+            return 1
+        } else {
+            return 0
+        }
     }
 
     // MARK: - IsDatabaseEncrypted
 
     @objc public func isDatabaseEncrypted(_ dbName: String) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let isFileExists: Bool = UtilsFile
-                .isFileExist(databaseLocation: databaseLocation,
-                             fileName: mDbName + "SQLite.db")
-            if isFileExists {
-                let state: State = UtilsSQLCipher
-                    .getDatabaseState(databaseLocation: databaseLocation,
-                                      databaseName: mDbName + "SQLite.db",
-                                      account: account)
-                if state.rawValue == "ENCRYPTEDGLOBALSECRET" || state.rawValue == "ENCRYPTEDSECRET" {
-                    return 1
-                }
-                if state.rawValue == "UNENCRYPTED" {
-                    return 0
-                }
-                throw CapacitorSQLiteError.failed(message: "Database unknown")
-            } else {
-                throw CapacitorSQLiteError.failed(message: "Database does not exist")
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let isFileExists: Bool = UtilsFile
+            .isFileExist(databaseLocation: databaseLocation,
+                         fileName: mDbName + "SQLite.db")
+        if isFileExists {
+            let state: State = UtilsSQLCipher
+                .getDatabaseState(databaseLocation: databaseLocation,
+                                  databaseName: mDbName + "SQLite.db",
+                                  account: account)
+            if state.rawValue == "ENCRYPTEDGLOBALSECRET" || state.rawValue == "ENCRYPTEDSECRET" {
+                return 1
             }
+            if state.rawValue == "UNENCRYPTED" {
+                return 0
+            }
+            throw CapacitorSQLiteError.failed(message: "Database unknown")
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            throw CapacitorSQLiteError.failed(message: "Database does not exist")
         }
     }
 
     // MARK: - IsNCDatabase
 
     @objc public func isNCDatabase(_ databasePath: String) throws -> NSNumber {
-        if isInit {
-            let isFileExists: Bool = UtilsFile
-                .isFileExist(filePath: databasePath)
-            if isFileExists {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let isFileExists: Bool = UtilsFile
+            .isFileExist(filePath: databasePath)
+        if isFileExists {
+            return 1
+        } else {
+            return 0
+        }
     }
 
     // MARK: - IsTableExists
 
     @objc public func isTableExists(_ dbName: String, tableName: String,
                                     readonly: Bool) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                let isExists: Bool = try
-                    UtilsJson.isTableExists(mDB: mDb,
-                                            tableName: tableName)
-                if isExists {
-                    return 1
-                } else {
-                    return 0
-                }
-            } catch UtilsJsonError.tableNotExists(let message) {
-                var msg: String = "IsTableExists:"
-                msg.append(" \(message)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            } catch let error {
-                var msg: String = "IsTableExists:"
-                msg.append(" \(error)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            let isExists: Bool = try
+                UtilsJson.isTableExists(mDB: mDb,
+                                        tableName: tableName)
+            if isExists {
+                return 1
+            } else {
+                return 0
+            }
+        } catch UtilsJsonError.tableNotExists(let message) {
+            var msg: String = "IsTableExists:"
+            msg.append(" \(message)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        } catch let error {
+            var msg: String = "IsTableExists:"
+            msg.append(" \(error)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     // MARK: - Execute
@@ -808,46 +773,45 @@ enum CapacitorSQLiteError: Error {
     @objc public func execute(_ dbName: String, statements: String,
                               transaction: Bool, readonly: Bool)
     throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    var stmts = statements
-                    // remove carriage returns
-                    let isReturn = stmts.indicesOf(string: "\n")
-                    if isReturn.count != 0 {
-                        let cmds = stmts.split(separator: "\n")
-                        var strcmds: [String] = []
-                        for cmd in cmds {
-                            strcmds.append(String(cmd
-                                                    .trimmingCharacters(in: .whitespacesAndNewlines)))
-                        }
-                        stmts = strcmds.joined(separator: "\n")
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                var stmts = statements
+                // remove carriage returns
+                let isReturn = stmts.indicesOf(string: "\n")
+                if isReturn.count != 0 {
+                    let cmds = stmts.split(separator: "\n")
+                    var strcmds: [String] = []
+                    for cmd in cmds {
+                        strcmds.append(String(cmd
+                                                .trimmingCharacters(in: .whitespacesAndNewlines)))
                     }
-                    let res = try mDb.executeSQL(sql: stmts,
-                                                 transaction: transaction)
-                    return ["changes": res]
-                } catch DatabaseError.executeSQL(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
+                    stmts = strcmds.joined(separator: "\n")
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+                let res = try mDb.executeSQL(sql: stmts,
+                                             transaction: transaction)
+                return ["changes": res]
+            } catch DatabaseError.executeSQL(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -856,34 +820,33 @@ enum CapacitorSQLiteError: Error {
     @objc func executeSet(_ dbName: String, set: [[String: Any]],
                           transaction: Bool, readonly: Bool, returnMode: String)
     throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    let res = try mDb.execSet(set: set, transaction: transaction,
-                                              returnMode: returnMode)
-                    return res
-                } catch DatabaseError.execSet(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                let res = try mDb.execSet(set: set, transaction: transaction,
+                                          returnMode: returnMode)
+                return res
+            } catch DatabaseError.execSet(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -895,81 +858,80 @@ enum CapacitorSQLiteError: Error {
     @objc func run(_ dbName: String, statement: String, values: [Any],
                    transaction: Bool, readonly: Bool, returnMode: String)
     throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if !mDb.isNCDB() && mDb.isDBOpen() {
-                do {
-                    var val: [Any] = []
-                    if values.count > 0 {
-                        for value in values {
-                            if let obj = value as? String {
-                                let str: String =
-                                    "\(String(describing: obj))"
-                                val.append(str)
-                            } else if let obj = value as? Int {
-                                val.append(obj)
-                            } else if let obj = value as? Float {
-                                val.append(obj)
-                            } else if let obj = value as? Double {
-                                val.append(obj)
-                            } else if value is NSNull {
-                                val.append(value)
-                            } else if let obj = value as? [String: Any] {
-                                if var keys = Array(obj.keys) as? [String] {
-                                    if #available(iOS 15.0, *) {
-                                        keys.sort(using: .localizedStandard)
-                                        var valuesArr: [UInt8] = []
-                                        for key in keys {
-                                            if let mVal = obj[key] {
-                                                if let iVal = mVal as? Int {
-                                                    valuesArr.append(UInt8(iVal))
-                                                } else {
-                                                    let msg: String = "Error in reading buffer"
-                                                    throw CapacitorSQLiteError.failed(message: msg)
-                                                }
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if !mDb.isNCDB() && mDb.isDBOpen() {
+            do {
+                var val: [Any] = []
+                if values.count > 0 {
+                    for value in values {
+                        if let obj = value as? String {
+                            let str: String =
+                                "\(String(describing: obj))"
+                            val.append(str)
+                        } else if let obj = value as? Int {
+                            val.append(obj)
+                        } else if let obj = value as? Float {
+                            val.append(obj)
+                        } else if let obj = value as? Double {
+                            val.append(obj)
+                        } else if value is NSNull {
+                            val.append(value)
+                        } else if let obj = value as? [String: Any] {
+                            if var keys = Array(obj.keys) as? [String] {
+                                if #available(iOS 15.0, *) {
+                                    keys.sort(using: .localizedStandard)
+                                    var valuesArr: [UInt8] = []
+                                    for key in keys {
+                                        if let mVal = obj[key] {
+                                            if let iVal = mVal as? Int {
+                                                valuesArr.append(UInt8(iVal))
                                             } else {
                                                 let msg: String = "Error in reading buffer"
                                                 throw CapacitorSQLiteError.failed(message: msg)
                                             }
+                                        } else {
+                                            let msg: String = "Error in reading buffer"
+                                            throw CapacitorSQLiteError.failed(message: msg)
                                         }
-                                        val.append(valuesArr)
-                                    } else {
-                                        let msg: String = "Error buffer sorted not implemented"
-                                        throw CapacitorSQLiteError.failed(message: msg)
-
                                     }
+                                    val.append(valuesArr)
+                                } else {
+                                    let msg: String = "Error buffer sorted not implemented"
+                                    throw CapacitorSQLiteError.failed(message: msg)
+
                                 }
-                            } else {
-                                let msg: String = "Not a SQL type"
-                                throw CapacitorSQLiteError.failed(message: msg)
                             }
+                        } else {
+                            let msg: String = "Not a SQL type"
+                            throw CapacitorSQLiteError.failed(message: msg)
                         }
                     }
-                    let res = try mDb.runSQL(sql: statement, values: val,
-                                             transaction: transaction,
-                                             returnMode: returnMode)
-                    return res
-                } catch DatabaseError.runSQL(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened or in read-only"
+                let res = try mDb.runSQL(sql: statement, values: val,
+                                         transaction: transaction,
+                                         returnMode: returnMode)
+                return res
+            } catch DatabaseError.runSQL(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened or in read-only"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
     // swiftlint:enable function_parameter_count
@@ -980,75 +942,72 @@ enum CapacitorSQLiteError: Error {
 
     @objc func query(_ dbName: String, statement: String,
                      values: [Any], readonly: Bool) throws -> [[String: Any]] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    let res: [[String: Any]] = try mDb
-                        .selectSQL(sql: statement, values: values)
-                    return res
-                } catch DatabaseError.selectSQL(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                let res: [[String: Any]] = try mDb
+                    .selectSQL(sql: statement, values: values)
+                return res
+            } catch DatabaseError.selectSQL(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - isDBExists
 
     @objc func isDBExists(_ dbName: String, readonly: Bool) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let _: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            let res: Bool = UtilsFile
-                .isFileExist(databaseLocation: databaseLocation,
-                             fileName: "\(mDbName)SQLite.db")
-            if res {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let _: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        let res: Bool = UtilsFile
+            .isFileExist(databaseLocation: databaseLocation,
+                         fileName: "\(mDbName)SQLite.db")
+        if res {
+            return 1
+        } else {
+            return 0
+        }
     }
 
     // MARK: - isDBOpen
 
     @objc func isDBOpen(_ dbName: String, readonly: Bool) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            let isOpen: Bool = mDb.isDBOpen()
-            if isOpen {
-                return 1
-            } else {
-                return 0
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        let isOpen: Bool = mDb.isDBOpen()
+        if isOpen {
+            return 1
+        } else {
+            return 0
+        }
     }
 
     // MARK: - deleteDatabase
@@ -1056,56 +1015,55 @@ enum CapacitorSQLiteError: Error {
     // swiftlint:disable function_body_length
     // swiftlint:disable cyclomatic_complexity
     @objc func deleteDatabase(_ dbName: String, readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            do {
-                if !mDb.isDBOpen() {
-                    // check the state of the DB
-                    let state: State = UtilsSQLCipher.getDatabaseState(databaseLocation: databaseLocation, databaseName: "\(mDbName)SQLite.db", account: account)
-                    if !isEncryption &&  (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
-                                            state.rawValue == "ENCRYPTEDSECRET") {
-                        var msg = "Cannot delete an Encrypted database with "
-                        msg += "No Encryption set in capacitor.config"
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    } else if state.rawValue == "UNENCRYPTED" {
-                        do {
-                            try UtilsSQLCipher.deleteDB(databaseLocation: databaseLocation,
-                                                        databaseName: "\(mDbName)SQLite.db")
-                            return
-                        } catch UtilsSQLCipherError.deleteDB(let message ) {
-                            throw CapacitorSQLiteError.failed(message: message)
-                        }
-
-                    } else {
-                        try mDb.open()
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        do {
+            if !mDb.isDBOpen() {
+                // check the state of the DB
+                let state: State = UtilsSQLCipher.getDatabaseState(databaseLocation: databaseLocation, databaseName: "\(mDbName)SQLite.db", account: account)
+                if !isEncryption &&  (state.rawValue == "ENCRYPTEDGLOBALSECRET" ||
+                                        state.rawValue == "ENCRYPTEDSECRET") {
+                    var msg = "Cannot delete an Encrypted database with "
+                    msg += "No Encryption set in capacitor.config"
+                    throw CapacitorSQLiteError.failed(message: msg)
+                } else if state.rawValue == "UNENCRYPTED" {
+                    do {
+                        try UtilsSQLCipher.deleteDB(databaseLocation: databaseLocation,
+                                                    databaseName: "\(mDbName)SQLite.db")
+                        return
+                    } catch UtilsSQLCipherError.deleteDB(let message ) {
+                        throw CapacitorSQLiteError.failed(message: message)
                     }
-                }
-                let res: Bool = try mDb.deleteDB(databaseName: "\(mDbName)SQLite.db")
-                if res {
-                    return
+
                 } else {
-                    let msg: String = "deleteDB return false"
-                    throw CapacitorSQLiteError.failed(message: msg)
+                    try mDb.open()
                 }
-            } catch DatabaseError.open(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch DatabaseError.deleteDB(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch let error {
-                let msg: String = "\(error)"
+            }
+            let res: Bool = try mDb.deleteDB(databaseName: "\(mDbName)SQLite.db")
+            if res {
+                return
+            } else {
+                let msg: String = "deleteDB return false"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+        } catch DatabaseError.open(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch DatabaseError.deleteDB(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
     // swiftlint:enable cyclomatic_complexity
@@ -1114,22 +1072,21 @@ enum CapacitorSQLiteError: Error {
     // MARK: - isJsonValid
 
     @objc func isJsonValid(_ parsingData: String) throws {
-        if isInit {
-            if let data = ("["+parsingData+"]").data(using: .utf8) {
-                do {
-                    _ = try JSONDecoder().decode([JsonSQLite].self,
-                                                 from: data)
-                    return
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg: String = "Stringify Json Object not Valid"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        if let data = ("["+parsingData+"]").data(using: .utf8) {
+            do {
+                _ = try JSONDecoder().decode([JsonSQLite].self,
+                                             from: data)
+                return
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg: String = "Stringify Json Object not Valid"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -1139,145 +1096,144 @@ enum CapacitorSQLiteError: Error {
     // swiftlint:disable cyclomatic_complexity
     @objc func importFromJson(_ parsingData: String)
     throws -> [String: Int] {
-        if isInit {
-            var mDb: Database
-            var importData: ImportData
-            // check if json object is encrypted
-            if parsingData.contains("expData") {
-                guard let data = ("["+parsingData+"]")
-                        .data(using: .utf8) else {
-                    let msg: String = "Stringify Encrypted Json Object " +
-                        "not Valid"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-                var encryptJson: [EncryptJson]
-                do {
-                    encryptJson = try JSONDecoder()
-                        .decode([EncryptJson].self, from: data)
-                    let dict: [String: Any] = try
-                        UtilsJson.decryptBase64ToDictionary(
-                            encryptJson[0].expData,
-                            forAccount: account)
-                    importData = ImportData(jsonDict: dict)
-                } catch let error {
-                    var msg: String = "Encrypted Json Object not Valid "
-                    msg.append("\(error)")
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-
-            } else {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        var mDb: Database
+        var importData: ImportData
+        // check if json object is encrypted
+        if parsingData.contains("expData") {
+            guard let data = ("["+parsingData+"]")
+                    .data(using: .utf8) else {
+                let msg: String = "Stringify Encrypted Json Object " +
+                    "not Valid"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            var encryptJson: [EncryptJson]
+            do {
+                encryptJson = try JSONDecoder()
+                    .decode([EncryptJson].self, from: data)
+                let dict: [String: Any] = try
+                    UtilsJson.decryptBase64ToDictionary(
+                        encryptJson[0].expData,
+                        forAccount: account)
+                importData = ImportData(jsonDict: dict)
+            } catch let error {
+                var msg: String = "Encrypted Json Object not Valid "
+                msg.append("\(error)")
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
 
-                guard let data = ("["+parsingData+"]")
-                        .data(using: .utf8) else {
-                    let msg: String = "Stringify Json Object not Valid"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-                var jsonSQLite: [JsonSQLite]
-                do {
-                    jsonSQLite = try JSONDecoder()
-                        .decode([JsonSQLite].self, from: data)
-                    importData = ImportData(jsonSQLite: jsonSQLite[0])
-                    jsonSQLite = []
-                } catch let error {
-                    var msg: String = "Stringify Json Object not Valid "
-                    msg.append("\(error)")
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
+        } else {
 
+            guard let data = ("["+parsingData+"]")
+                    .data(using: .utf8) else {
+                let msg: String = "Stringify Json Object not Valid"
+                throw CapacitorSQLiteError.failed(message: msg)
             }
-            let encrypted: Bool = importData.encrypted
-            let overwrite: Bool = importData.overwrite ?
-                importData.overwrite : false
-            let mode: String = importData.mode
-            let inMode: String = encrypted ? "secret"
-                : "no-encryption"
-            let version: Int = importData.version
-            var dbName: String = CapacitorSQLite.getDatabaseName(
-                dbName: importData.database
-            )
-            dbName.append("SQLite.db")
-            // open the database
+            var jsonSQLite: [JsonSQLite]
             do {
-                mDb = try Database(
-                    databaseLocation: databaseLocation, databaseName: dbName,
-                    encrypted: encrypted, isEncryption: isEncryption,
-                    account: account,
-                    mode: inMode, version: version, readonly: false,
-                    vUpgDict: [:])
-                if overwrite && mode == "full" {
-                    let isExists = UtilsFile
-                        .isFileExist(databaseLocation: databaseLocation,
-                                     fileName: dbName)
-                    if isExists {
-                        _ = try UtilsFile
-                            .deleteFile(fileName: dbName,
-                                        databaseLocation: databaseLocation)
-                    }
-                }
-                try mDb.open()
-            } catch UtilsFileError.deleteFileFailed {
-                let message = "Delete Database failed"
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch DatabaseError.open(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
+                jsonSQLite = try JSONDecoder()
+                    .decode([JsonSQLite].self, from: data)
+                importData = ImportData(jsonSQLite: jsonSQLite[0])
+                jsonSQLite = []
             } catch let error {
-                let msg: String = "\(error)"
+                var msg: String = "Stringify Json Object not Valid "
+                msg.append("\(error)")
                 throw CapacitorSQLiteError.failed(message: msg)
             }
-            // check if the database as some tables
-            do {
-                let tableList: [String] = try mDb.getTableNames()
-                if mode == "full" && tableList.count > 0 {
-                    let curVersion = try mDb.getVersion()
-                    if version < curVersion {
-                        var msg: String = "ImportFromJson: Cannot import a "
-                        msg += "version lower than \(curVersion)"
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    }
-                    if curVersion == version {
-                        var res: [String: Int] = [:]
-                        res["changes"] = 0
-                        return res
-                    }
+
+        }
+        let encrypted: Bool = importData.encrypted
+        let overwrite: Bool = importData.overwrite ?
+            importData.overwrite : false
+        let mode: String = importData.mode
+        let inMode: String = encrypted ? "secret"
+            : "no-encryption"
+        let version: Int = importData.version
+        var dbName: String = CapacitorSQLite.getDatabaseName(
+            dbName: importData.database
+        )
+        dbName.append("SQLite.db")
+        // open the database
+        do {
+            mDb = try Database(
+                databaseLocation: databaseLocation, databaseName: dbName,
+                encrypted: encrypted, isEncryption: isEncryption,
+                account: account,
+                mode: inMode, version: version, readonly: false,
+                vUpgDict: [:])
+            if overwrite && mode == "full" {
+                let isExists = UtilsFile
+                    .isFileExist(databaseLocation: databaseLocation,
+                                 fileName: dbName)
+                if isExists {
+                    _ = try UtilsFile
+                        .deleteFile(fileName: dbName,
+                                    databaseLocation: databaseLocation)
                 }
+            }
+            try mDb.open()
+        } catch UtilsFileError.deleteFileFailed {
+            let message = "Delete Database failed"
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch DatabaseError.open(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        // check if the database as some tables
+        do {
+            let tableList: [String] = try mDb.getTableNames()
+            if mode == "full" && tableList.count > 0 {
+                let curVersion = try mDb.getVersion()
+                if version < curVersion {
+                    var msg: String = "ImportFromJson: Cannot import a "
+                    msg += "version lower than \(curVersion)"
+                    throw CapacitorSQLiteError.failed(message: msg)
+                }
+                if curVersion == version {
+                    var res: [String: Int] = [:]
+                    res["changes"] = 0
+                    return res
+                }
+            }
 
-            } catch DatabaseError.getTableNames(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch let error {
-                let msg: String = "\(error)"
+        } catch DatabaseError.getTableNames(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        // import from Json Object
+        do {
+            let res: [String: Int] = try mDb
+                .importFromJson(importData: importData)
+            try mDb.close()
+            if let result = res["changes"] {
+                if result < 0 {
+                    let msg: String = "changes < 0"
+                    throw CapacitorSQLiteError
+                    .failed(message: msg)
+                } else {
+                    return res
+                }
+            } else {
+                let msg: String = "changes not found"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
-            // import from Json Object
+        } catch DatabaseError.importFromJson(let message) {
+            var msg = message
             do {
-                let res: [String: Int] = try mDb
-                    .importFromJson(importData: importData)
                 try mDb.close()
-                if let result = res["changes"] {
-                    if result < 0 {
-                        let msg: String = "changes < 0"
-                        throw CapacitorSQLiteError
-                        .failed(message: msg)
-                    } else {
-                        return res
-                    }
-                } else {
-                    let msg: String = "changes not found"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } catch DatabaseError.importFromJson(let message) {
-                var msg = message
-                do {
-                    try mDb.close()
-                    throw CapacitorSQLiteError.failed(message: msg)
-                } catch DatabaseError.close(let message) {
-                    msg.append(" \(message)")
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
+                throw CapacitorSQLiteError.failed(message: msg)
             } catch DatabaseError.close(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
+                msg.append(" \(message)")
+                throw CapacitorSQLiteError.failed(message: msg)
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+        } catch DatabaseError.close(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
         }
     }
     // swiftlint:enable cyclomatic_complexity
@@ -1287,111 +1243,108 @@ enum CapacitorSQLiteError: Error {
 
     @objc func exportToJson(_ dbName: String, expMode: String, readonly: Bool, encrypted: Bool)
     throws -> [String: Any] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
 
-                do {
-                    let res: [String: Any] = try
-                        mDb.exportToJson(
-                            expMode: expMode,
-                            isEncrypted: encrypted)
-                    if res.count == 0 {
-                        var msg: String = "return Object is empty "
-                        msg.append("No data to synchronize")
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    } else if res.count == 1 && res.contains(where: { $0.key == "expData" }) {
-                        return res
-                    } else if res.count == 5 || res.count == 6 ||
-                                res.count == 7 {
-                        return res
-                    } else {
-                        var msg: String = "return Object is not a "
-                        msg.append("JsonSQLite  Object")
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    }
-                } catch DatabaseError.exportToJson(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
+            do {
+                let res: [String: Any] = try
+                    mDb.exportToJson(
+                        expMode: expMode,
+                        isEncrypted: encrypted)
+                if res.count == 0 {
+                    var msg: String = "return Object is empty "
+                    msg.append("No data to synchronize")
+                    throw CapacitorSQLiteError.failed(message: msg)
+                } else if res.count == 1 && res.contains(where: { $0.key == "expData" }) {
+                    return res
+                } else if res.count == 5 || res.count == 6 ||
+                            res.count == 7 {
+                    return res
+                } else {
+                    var msg: String = "return Object is not a "
+                    msg.append("JsonSQLite  Object")
                     throw CapacitorSQLiteError.failed(message: msg)
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+            } catch DatabaseError.exportToJson(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - deleteExportedRows
 
     @objc func deleteExportedRows(_ dbName: String, readonly: Bool) throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    try mDb.deleteExportedRows()
-                } catch DatabaseError.deleteExportedRows(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                try mDb.deleteExportedRows()
+            } catch DatabaseError.deleteExportedRows(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - createSyncTable
 
     @objc func createSyncTable(_ dbName: String, readonly: Bool) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    let res: Int = try mDb.createSyncTable()
-                    return res as NSNumber
-                } catch DatabaseError.createSyncTable(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                let res: Int = try mDb.createSyncTable()
+                return res as NSNumber
+            } catch DatabaseError.createSyncTable(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -1399,74 +1352,72 @@ enum CapacitorSQLiteError: Error {
 
     @objc func setSyncDate(_ dbName: String, syncDate: String, readonly: Bool)
     throws {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if readonly {
-                let msg = "not allowed in read-only mode"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if readonly {
+            let msg = "not allowed in read-only mode"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
 
-                do {
-                    let res: Bool = try mDb
-                        .setSyncDate(syncDate: syncDate)
-                    if res {
-                        return
-                    } else {
-                        let msg: String = "return false"
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    }
-                } catch DatabaseError.createSyncDate(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
+            do {
+                let res: Bool = try mDb
+                    .setSyncDate(syncDate: syncDate)
+                if res {
+                    return
+                } else {
+                    let msg: String = "return false"
                     throw CapacitorSQLiteError.failed(message: msg)
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+            } catch DatabaseError.createSyncDate(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - getSyncDate
 
     @objc func getSyncDate(_ dbName: String, readonly: Bool) throws -> NSNumber {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    let res: Int64 = try mDb.getSyncDate()
-                    if res > 0 {
-                        return res as NSNumber
-                    } else {
-                        let msg: String = "return no sync date"
-                        throw CapacitorSQLiteError.failed(message: msg)
-                    }
-                } catch DatabaseError.getSyncDate(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                let res: Int64 = try mDb.getSyncDate()
+                if res > 0 {
+                    return res as NSNumber
+                } else {
+                    let msg: String = "return no sync date"
                     throw CapacitorSQLiteError.failed(message: msg)
                 }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+            } catch DatabaseError.getSyncDate(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -1475,87 +1426,85 @@ enum CapacitorSQLiteError: Error {
     @objc func addUpgradeStatement(_ dbName: String,
                                    upgrade: [[String: Any]])
     throws -> [Int: [String: Any]] {
-        if isInit {
-            var upgDict: [String: Any] = [:]
-            var upgVersionDict: [Int: [String: Any]] = [:]
-            for dict in upgrade {
-                let keys = dict.keys
-                if !(keys.contains("toVersion")) || !(keys.contains("statements")) {
-                    var msg: String = "upgrade must have keys in "
-                    msg.append("{toVersion,statements}")
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-                for (key, value) in dict {
-                    upgDict[key] = value
-                }
-                guard let toVersion = upgDict["toVersion"] as? Int else {
-                    let msg: String = "toVersion key must be an Int"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-                upgVersionDict[toVersion] =  upgDict
-            }
-            return upgVersionDict
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        var upgDict: [String: Any] = [:]
+        var upgVersionDict: [Int: [String: Any]] = [:]
+        for dict in upgrade {
+            let keys = dict.keys
+            if !(keys.contains("toVersion")) || !(keys.contains("statements")) {
+                var msg: String = "upgrade must have keys in "
+                msg.append("{toVersion,statements}")
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            for (key, value) in dict {
+                upgDict[key] = value
+            }
+            guard let toVersion = upgDict["toVersion"] as? Int else {
+                let msg: String = "toVersion key must be an Int"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+            upgVersionDict[toVersion] =  upgDict
+        }
+        return upgVersionDict
     }
 
     // MARK: - copyFromAssets
 
     @objc func copyFromAssets(overwrite: Bool) throws {
-        if isInit {
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
 
-            // check if the assets/database folder exists
-            do {
-                let assetsDbURL: URL = try
-                    UtilsFile.getAssetsDatabasesPath()
-                let aPath: String = assetsDbURL.path
-                let bRes: Bool = UtilsFile.isDirExist(dirPath: aPath)
-                if bRes {
-                    // get the database files from assets
-                    let dbList: [String] = try UtilsFile
-                        .getFileList(path: aPath, ext: ".db")
-                    // loop through the database files
-                    for mDb in dbList {
-                        // for each check if the suffix SQLite.db is there
-                        // or add it
-                        let toDb: String = UtilsFile
-                            .setPathSuffix(sDb: mDb)
-                        // for each copy the file to the Application
-                        // database folder
-                        _ = try UtilsFile
-                            .copyFromAssetToDatabase(databaseLocation: databaseLocation,
-                                                     fromDb: mDb,
-                                                     toDb: toDb, overwrite: overwrite)
-                    }
-                    // get the zip files
-                    let zipList: [String] = try UtilsFile
-                        .getFileList(path: aPath, ext: ".zip")
-                    // loop through the database files
-                    for zip in zipList {
-                        // for each zip uncompress the file to the Application
-                        // database folder
-                        _ = try UtilsFile.unzipToDatabase(
-                            fromURL: assetsDbURL,
-                            databaseLocation: databaseLocation,
-                            zip: zip,
-                            overwrite: overwrite)
-                    }
-                    return
-                } else {
-                    let msg: String = "assets database path does not exist"
-                    throw CapacitorSQLiteError.failed(message: msg)
+        // check if the assets/database folder exists
+        do {
+            let assetsDbURL: URL = try
+                UtilsFile.getAssetsDatabasesPath()
+            let aPath: String = assetsDbURL.path
+            let bRes: Bool = UtilsFile.isDirExist(dirPath: aPath)
+            if bRes {
+                // get the database files from assets
+                let dbList: [String] = try UtilsFile
+                    .getFileList(path: aPath, ext: ".db")
+                // loop through the database files
+                for mDb in dbList {
+                    // for each check if the suffix SQLite.db is there
+                    // or add it
+                    let toDb: String = UtilsFile
+                        .setPathSuffix(sDb: mDb)
+                    // for each copy the file to the Application
+                    // database folder
+                    _ = try UtilsFile
+                        .copyFromAssetToDatabase(databaseLocation: databaseLocation,
+                                                 fromDb: mDb,
+                                                 toDb: toDb, overwrite: overwrite)
                 }
-            } catch UtilsFileError.copyFromAssetToDatabaseFailed(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch UtilsFileError.unzipToDatabaseFailed(let message) {
-                throw CapacitorSQLiteError.failed(message: message)
-            } catch let error {
-                let msg: String = "\(error)"
+                // get the zip files
+                let zipList: [String] = try UtilsFile
+                    .getFileList(path: aPath, ext: ".zip")
+                // loop through the database files
+                for zip in zipList {
+                    // for each zip uncompress the file to the Application
+                    // database folder
+                    _ = try UtilsFile.unzipToDatabase(
+                        fromURL: assetsDbURL,
+                        databaseLocation: databaseLocation,
+                        zip: zip,
+                        overwrite: overwrite)
+                }
+                return
+            } else {
+                let msg: String = "assets database path does not exist"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
-        } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+        } catch UtilsFileError.copyFromAssetToDatabaseFailed(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch UtilsFileError.unzipToDatabaseFailed(let message) {
+            throw CapacitorSQLiteError.failed(message: message)
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
@@ -1563,143 +1512,137 @@ enum CapacitorSQLiteError: Error {
 
     @objc func getTableList(_ dbName: String, readonly: Bool)
     throws -> [String] {
-        if isInit {
-            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
-            let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
-            guard let mDb: Database = dbDict[connName] else {
-                let msg = "Connection to \(mDbName) not available"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-            if mDb.isDBOpen() {
-                do {
-                    let res: [String] = try mDb.getTableNames()
-                    return res
-                } catch DatabaseError.getTableNames(let message) {
-                    throw CapacitorSQLiteError.failed(message: message)
-                } catch let error {
-                    let msg: String = "\(error)"
-                    throw CapacitorSQLiteError.failed(message: msg)
-                }
-            } else {
-                let msg = "Database \(mDbName) not opened"
+        guard isInit else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+        let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+        let connName: String = readonly ? "RO_\(mDbName)" : "RW_\(mDbName)"
+        guard let mDb: Database = dbDict[connName] else {
+            let msg = "Connection to \(mDbName) not available"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
+        if mDb.isDBOpen() {
+            do {
+                let res: [String] = try mDb.getTableNames()
+                return res
+            } catch DatabaseError.getTableNames(let message) {
+                throw CapacitorSQLiteError.failed(message: message)
+            } catch let error {
+                let msg: String = "\(error)"
                 throw CapacitorSQLiteError.failed(message: msg)
             }
         } else {
-            throw CapacitorSQLiteError.failed(message: initMessage)
+            let msg = "Database \(mDbName) not opened"
+            throw CapacitorSQLiteError.failed(message: msg)
         }
     }
 
     // MARK: - getDatabaseList
 
     @objc func getDatabaseList() throws -> [String] {
-        if isInit {
-            do {
-                let aPath: String = try (UtilsFile.getFolderURL(folderPath: databaseLocation)).path
-                // get the database files
-                let dbList: [String] = try UtilsFile.getFileList(path: aPath, ext: ".db")
-                return dbList
-
-            } catch let error {
-                let msg: String = "\(error)"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            let aPath: String = try (UtilsFile.getFolderURL(folderPath: databaseLocation)).path
+            // get the database files
+            let dbList: [String] = try UtilsFile.getFileList(path: aPath, ext: ".db")
+            return dbList
+
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     // MARK: - getMigratableDbList
 
     @objc func getMigratableDbList(_ folderPath: String) throws -> [String] {
-        if isInit {
-            do {
-                let dbList: [String] = try UtilsMigrate
-                    .getMigratableList(folderPath: folderPath)
-                return dbList
-
-            } catch UtilsMigrateError.getMigratableList(let message) {
-                var msg: String = "getMigratableList:"
-                msg.append(" \(message)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            } catch let error {
-                let msg: String = "\(error)"
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            let dbList: [String] = try UtilsMigrate
+                .getMigratableList(folderPath: folderPath)
+            return dbList
+
+        } catch UtilsMigrateError.getMigratableList(let message) {
+            var msg: String = "getMigratableList:"
+            msg.append(" \(message)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        } catch let error {
+            let msg: String = "\(error)"
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     // MARK: - addSQLiteSuffix
 
     @objc func addSQLiteSuffix(_ folderPath: String, dbList: [String]) throws {
-        if isInit {
-            do {
-                try UtilsMigrate.addSQLiteSuffix(databaseLocation: databaseLocation,
-                                                 folderPath: folderPath,
-                                                 dbList: dbList)
-                return
-            } catch UtilsMigrateError.addSQLiteSuffix(let message) {
-                var msg: String = "addSQLiteSuffix:"
-                msg.append(" \(message)")
-                throw CapacitorSQLiteError.failed(message: msg)
-
-            } catch let error {
-                var msg: String = "addSQLiteSuffix:"
-                msg.append(" \(error)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            try UtilsMigrate.addSQLiteSuffix(databaseLocation: databaseLocation,
+                                             folderPath: folderPath,
+                                             dbList: dbList)
+            return
+        } catch UtilsMigrateError.addSQLiteSuffix(let message) {
+            var msg: String = "addSQLiteSuffix:"
+            msg.append(" \(message)")
+            throw CapacitorSQLiteError.failed(message: msg)
+
+        } catch let error {
+            var msg: String = "addSQLiteSuffix:"
+            msg.append(" \(error)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     // MARK: - deleteOldDatabases
 
     @objc func deleteOldDatabases(_ folderPath: String, dbList: [String]) throws {
-        if isInit {
-            do {
-                try UtilsMigrate
-                    .deleteOldDatabases(folderPath: folderPath, dbList: dbList)
-                return
-            } catch UtilsMigrateError.deleteOldDatabases(let message) {
-                var msg: String = "deleteOldDatabases:"
-                msg.append(" \(message)")
-                throw CapacitorSQLiteError.failed(message: msg)
-
-            } catch let error {
-                var msg: String = "deleteOldDatabases:"
-                msg.append(" \(error)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            try UtilsMigrate
+                .deleteOldDatabases(folderPath: folderPath, dbList: dbList)
+            return
+        } catch UtilsMigrateError.deleteOldDatabases(let message) {
+            var msg: String = "deleteOldDatabases:"
+            msg.append(" \(message)")
+            throw CapacitorSQLiteError.failed(message: msg)
+
+        } catch let error {
+            var msg: String = "deleteOldDatabases:"
+            msg.append(" \(error)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     // MARK: - moveDatabasesAndAddSuffix
 
     @objc func moveDatabasesAndAddSuffix(_ folderPath: String, dbList: [String]) throws {
-        if isInit {
-            do {
-                try UtilsMigrate
-                    .moveDatabasesAndAddSuffix(databaseLocation: databaseLocation,
-                                               folderPath: folderPath,
-                                               dbList: dbList)
-                return
-            } catch UtilsMigrateError.moveDatabasesAndAddSuffix(let message) {
-                var msg: String = "moveDatabasesAndAddSuffix:"
-                msg.append(" \(message)")
-                throw CapacitorSQLiteError.failed(message: msg)
-
-            } catch let error {
-                var msg: String = "moveDatabasesAndAddSuffix:"
-                msg.append(" \(error)")
-                throw CapacitorSQLiteError.failed(message: msg)
-            }
-        } else {
+        guard isInit else {
             throw CapacitorSQLiteError.failed(message: initMessage)
         }
+        do {
+            try UtilsMigrate
+                .moveDatabasesAndAddSuffix(databaseLocation: databaseLocation,
+                                           folderPath: folderPath,
+                                           dbList: dbList)
+            return
+        } catch UtilsMigrateError.moveDatabasesAndAddSuffix(let message) {
+            var msg: String = "moveDatabasesAndAddSuffix:"
+            msg.append(" \(message)")
+            throw CapacitorSQLiteError.failed(message: msg)
+
+        } catch let error {
+            var msg: String = "moveDatabasesAndAddSuffix:"
+            msg.append(" \(error)")
+            throw CapacitorSQLiteError.failed(message: msg)
+        }
     }
 
     class func getDatabaseName(dbName: String) -> String {