@capacitor-community/sqlite 5.0.5 → 5.0.7-1

package/ios/Plugin/ImportExportJson/ImportData.swift

@@ -0,0 +1,434 @@
+//
+//  ImportData.swift
+//  CapacitorCommunitySqlite
+//
+//  Created by  Quéau Jean Pierre on 23/07/2023.
+//
+
+import Foundation
+
+// swiftlint:disable file_length
+public class ImportData {
+    var jsonSQLite: [JsonSQLite]
+    var jsonDict: [String: Any]
+
+    init(jsonSQLite: JsonSQLite) {
+        self.jsonSQLite = [jsonSQLite]
+        self.jsonDict = [:]
+    }
+    init(jsonDict: [String: Any]) {
+        self.jsonSQLite = []
+        self.jsonDict = jsonDict
+    }
+
+    var database: String {
+        var mDatabase = ""
+        mDatabase = jsonSQLite.count > 0 ? jsonSQLite[0].database : ""
+        if !jsonDict.isEmpty {
+            if let mDBName = jsonDict["database"] as? String {
+                mDatabase = mDBName
+            }
+        }
+        return mDatabase
+    }
+    var mode: String {
+        var mMode = ""
+        mMode = jsonSQLite.count > 0 ? jsonSQLite[0].mode : ""
+        if !jsonDict.isEmpty {
+            if let nMode = jsonDict["mode"] as? String {
+                mMode = nMode
+            }
+        }
+        return mMode
+    }
+    var encrypted: Bool {
+        var mEnc = false
+        mEnc = jsonSQLite.count > 0 ? jsonSQLite[0].encrypted : false
+        if !jsonDict.isEmpty {
+            if let nEnc = jsonDict["encrypted"] as? Bool {
+                mEnc = nEnc
+            }
+        }
+        return mEnc
+    }
+    var overwrite: Bool {
+        var mOve = false
+        if jsonSQLite.count > 0 {
+            if let nOve = jsonSQLite[0].overwrite {
+                mOve = nOve
+            }
+        }
+
+        if !jsonDict.isEmpty {
+            if let nOve = jsonDict["overwrite"] as? Bool {
+                mOve = nOve
+            }
+        }
+        return mOve
+    }
+    var version: Int {
+        var mVer = 1
+        mVer = jsonSQLite.count > 0 ? jsonSQLite[0].version : 1
+        if !jsonDict.isEmpty {
+            if let nVer = jsonDict["version"] as? Int {
+                mVer = nVer
+            }
+        }
+        return mVer
+    }
+    var tables: [ImportTable] {
+        var fTab: [ImportTable] = []
+        if jsonSQLite.count > 0 {
+            let mTables = jsonSQLite[0].tables
+            for table in mTables {
+                let mTab: ImportTable = ImportTable(jsonTable: [table])
+                fTab.append(mTab)
+            }
+        }
+        if !jsonDict.isEmpty {
+            if let mTables = jsonDict["tables"] as? [[String: Any]] {
+                for table in mTables {
+                    let mTab: ImportTable = ImportTable(tableDict: table)
+                    fTab.append(mTab)
+                }
+            }
+        }
+        return fTab
+    }
+    var views: [ImportView]? {
+        var fView: [ImportView] = []
+        if jsonSQLite.count > 0 {
+            if let mViews = jsonSQLite[0].views {
+                for view in mViews {
+                    let mVw: ImportView = ImportView(jsonView: [view])
+                    fView.append(mVw)
+                }
+            }
+        }
+        if !jsonDict.isEmpty {
+            if let mViews = jsonDict["views"] as? [[String: Any]] {
+                for view in mViews {
+                    let mVw: ImportView = ImportView(viewDict: view)
+                    fView.append(mVw)
+                }
+            }
+        }
+        return fView
+    }
+}
+public class ImportTable {
+    var jsonTable: [JsonTable]
+    var tableDict: [String: Any]
+
+    init(jsonTable: [JsonTable]) {
+        self.jsonTable = jsonTable
+        self.tableDict = [:]
+    }
+    init(tableDict: [String: Any]) {
+        self.jsonTable = []
+        self.tableDict = tableDict
+    }
+
+    var name: String {
+        var mName = ""
+        mName = jsonTable.count > 0 ? jsonTable[0].name : ""
+        if !tableDict.isEmpty {
+            if let nName = tableDict["name"] as? String {
+                mName = nName
+            }
+        }
+        return mName
+    }
+
+    var schema: [ImportColumn]? {
+        var mSchema: [ImportColumn] = []
+        if jsonTable.count > 0 {
+            if let nSchema = jsonTable[0].schema {
+                for schm in nSchema {
+                    let nSchm: ImportColumn = ImportColumn(jsonColumn: [schm])
+                    mSchema.append(nSchm)
+                }
+            }
+
+        }
+        if !tableDict.isEmpty {
+            if let nSchema = tableDict["schema"] as? [[String: Any]] {
+                for schm in nSchema {
+                    let nSchm: ImportColumn =
+                        ImportColumn(columnDict: schm)
+                    mSchema.append(nSchm)
+                }
+            }
+        }
+        return mSchema
+    }
+    var indexes: [ImportIndex]? {
+        var mIndexes: [ImportIndex] = []
+        if jsonTable.count > 0 {
+            if let nIndexes = jsonTable[0].indexes {
+                for nIdx in nIndexes {
+                    let nIndex: ImportIndex = ImportIndex(jsonIndex: [nIdx])
+                    mIndexes.append(nIndex)
+                }
+            }
+
+        }
+        if !tableDict.isEmpty {
+            if let nIndexes = tableDict["indexes"] as? [[String: Any]] {
+                for nIdx in nIndexes {
+                    let nIndex: ImportIndex = ImportIndex(indexDict: nIdx)
+                    mIndexes.append(nIndex)
+                }
+            }
+        }
+        return mIndexes
+    }
+    var triggers: [ImportTrigger]? {
+        var mTrigs: [ImportTrigger] = []
+        if jsonTable.count > 0 {
+            if let nTrigs = jsonTable[0].triggers {
+                for mTrig in nTrigs {
+                    let nTrig: ImportTrigger = ImportTrigger(jsonTrigger: [mTrig])
+                    mTrigs.append(nTrig)
+                }
+            }
+
+        }
+        if !tableDict.isEmpty {
+            if let nTrigs = tableDict["triggers"] as? [[String: Any]] {
+                for mTrig in nTrigs {
+                    let nTrig: ImportTrigger = ImportTrigger(triggerDict: mTrig)
+                    mTrigs.append(nTrig)
+                }
+            }
+        }
+        return mTrigs
+
+    }
+
+    var values: [[Any]]? {
+        var mValues: [[Any]] = []
+        if jsonTable.count > 0 {
+            if let nValues = jsonTable[0].values {
+                for row in nValues {
+                    let nrow = UtilsJson.getValuesFromRow(rowValues: row)
+                    mValues.append(nrow)
+                }
+            }
+        }
+        if !tableDict.isEmpty {
+            if let nValues = tableDict["values"] as? [[Any]] {
+                mValues = nValues
+            }
+        }
+        return mValues
+    }
+
+}
+public class ImportColumn {
+    var jsonColumn: [JsonColumn]
+    var columnDict: [String: Any]
+
+    init(jsonColumn: [JsonColumn]) {
+        self.jsonColumn = jsonColumn
+        self.columnDict = [:]
+    }
+    init(columnDict: [String: Any]) {
+        self.jsonColumn = []
+        self.columnDict = columnDict
+    }
+    var column: String? {
+        var mCol = ""
+        if jsonColumn.count > 0 {
+            if let nCol = jsonColumn[0].column {
+                mCol = nCol
+            }
+        }
+        if !columnDict.isEmpty {
+            if let nCol = columnDict["column"] as? String {
+                mCol = nCol
+            }
+        }
+        return mCol
+    }
+    var value: String {
+        var mVal = ""
+        mVal = jsonColumn.count > 0 ? jsonColumn[0].value : ""
+        if !columnDict.isEmpty {
+            if let nVal = columnDict["value"] as? String {
+                mVal = nVal
+            }
+        }
+        return mVal
+    }
+    var foreignkey: String? {
+        var mFK = ""
+        if jsonColumn.count > 0 {
+            if let nFK = jsonColumn[0].foreignkey {
+                mFK = nFK
+            }
+        }
+        if !columnDict.isEmpty {
+            if let nFK = columnDict["foreignkey"] as? String {
+                mFK = nFK
+            }
+        }
+        return mFK
+    }
+    var constraint: String? {
+        var mCon = ""
+        if jsonColumn.count > 0 {
+            if let nCon = jsonColumn[0].constraint {
+                mCon = nCon
+            }
+        }
+        if !columnDict.isEmpty {
+            if let nCon = columnDict["constraint"] as? String {
+                mCon = nCon
+            }
+        }
+        return mCon
+    }
+}
+public class ImportIndex {
+    var jsonIndex: [JsonIndex]
+    var indexDict: [String: Any]
+
+    init(jsonIndex: [JsonIndex]) {
+        self.jsonIndex = jsonIndex
+        self.indexDict = [:]
+    }
+    init(indexDict: [String: Any]) {
+        self.jsonIndex = []
+        self.indexDict = indexDict
+    }
+    var mode: String? {
+        var mMode = ""
+        if jsonIndex.count > 0 {
+            if let nMode = jsonIndex[0].mode {
+                mMode = nMode
+            }
+        }
+        if !indexDict.isEmpty {
+            if let nMode = indexDict["mode"] as? String {
+                mMode = nMode
+            }
+        }
+        return mMode
+    }
+    var value: String {
+        var mVal = ""
+        mVal = jsonIndex.count > 0 ? jsonIndex[0].value : ""
+        if !indexDict.isEmpty {
+            if let nVal = indexDict["value"] as? String {
+                mVal = nVal
+            }
+        }
+        return mVal
+    }
+    var name: String {
+        var mName = ""
+        mName = jsonIndex.count > 0 ? jsonIndex[0].name : ""
+        if !indexDict.isEmpty {
+            if let nName = indexDict["name"] as? String {
+                mName = nName
+            }
+        }
+        return mName
+    }
+}
+public class ImportTrigger {
+    var jsonTrigger: [JsonTrigger]
+    var triggerDict: [String: Any]
+
+    init(jsonTrigger: [JsonTrigger]) {
+        self.jsonTrigger = jsonTrigger
+        self.triggerDict = [:]
+    }
+    init(triggerDict: [String: Any]) {
+        self.jsonTrigger = []
+        self.triggerDict = triggerDict
+    }
+    var name: String {
+        var mName = ""
+        mName = jsonTrigger.count > 0 ? jsonTrigger[0].name : ""
+        if !triggerDict.isEmpty {
+            if let nName = triggerDict["name"] as? String {
+                mName = nName
+            }
+        }
+        return mName
+    }
+    var timeevent: String {
+        var mTime = ""
+        mTime = jsonTrigger.count > 0 ? jsonTrigger[0].timeevent : ""
+        if !triggerDict.isEmpty {
+            if let nTime = triggerDict["timeevent"] as? String {
+                mTime = nTime
+            }
+        }
+        return mTime
+    }
+    var logic: String {
+        var mLog = ""
+        mLog = jsonTrigger.count > 0 ? jsonTrigger[0].logic : ""
+        if !triggerDict.isEmpty {
+            if let nLog = triggerDict["logic"] as? String {
+                mLog = nLog
+            }
+        }
+        return mLog
+    }
+    var condition: String? {
+        var mCon = ""
+        if jsonTrigger.count > 0 {
+            if let nCon = jsonTrigger[0].condition {
+                mCon = nCon
+            }
+        }
+        if !triggerDict.isEmpty {
+            if let nCon = triggerDict["condition"] as? String {
+                mCon = nCon
+            }
+        }
+        return mCon
+    }
+
+}
+
+public class ImportView {
+    var jsonView: [JsonView]
+    var viewDict: [String: Any]
+
+    init(jsonView: [JsonView]) {
+        self.jsonView = jsonView
+        self.viewDict = [:]
+    }
+    init(viewDict: [String: Any]) {
+        self.jsonView = []
+        self.viewDict = viewDict
+    }
+
+    var name: String {
+        var mName = ""
+        mName = jsonView.count > 0 ? jsonView[0].name : ""
+        if !viewDict.isEmpty {
+            if let nName = viewDict["name"] as? String {
+                mName = nName
+            }
+        }
+        return mName
+    }
+    var value: String {
+        var mValue = ""
+        mValue = jsonView.count > 0 ? jsonView[0].value : ""
+        if !viewDict.isEmpty {
+            if let nView = viewDict["value"] as? String {
+                mValue = nView
+            }
+        }
+        return mValue
+    }
+
+}
+// swiftlint:enable file_length

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -34,25 +34,24 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateDatabaseSchema
 
-    class func createDatabaseSchema(mDB: Database,
-                                    jsonSQLite: JsonSQLite)
+    class func createDatabaseSchema(mDB: Database, tables: [ImportTable],
+                                    mode: String, version: Int)
     throws -> Int {
         let msg = "importFromJson: "
         var changes: Int = -1
-        let version: Int = jsonSQLite.version
 
         do {
             // Set PRAGMAS
             try UtilsSQLCipher.setVersion(mDB: mDB,
                                           version: version)
-            if jsonSQLite.mode == "full" {
+            if mode == "full" {
                 // Drop All Tables, Indexes and Triggers
                 try _ = UtilsDrop.dropAll(mDB: mDB)
             }
             // create database schema
             changes = try ImportFromJson
                 .createSchema(mDB: mDB,
-                              jsonSQLite: jsonSQLite)
+                              tables: tables, mode: mode)
             let msg = "Schema creation completed changes: \(changes)"
             notifyImportProgressEvent(msg: msg)
             return changes
@@ -76,8 +75,8 @@ class ImportFromJson {
     // MARK: - ImportFromJson - createSchema
 
     // swiftlint:disable function_body_length
-    class func createSchema(mDB: Database,
-                            jsonSQLite: JsonSQLite) throws -> Int {
+    class func createSchema(mDB: Database, tables: [ImportTable],
+                            mode: String) throws -> Int {
         var changes: Int = 0
         var initChanges: Int = 0
         do {
@@ -88,7 +87,7 @@ class ImportFromJson {
         }
         // Create a Schema Statements
         let statements = ImportFromJson
-            .createSchemaStatement(jsonSQLite: jsonSQLite )
+            .createSchemaStatement(tables: tables, mode: mode )
         if statements.count > 0 {
             let joined = statements.joined(separator: "\n")
             let mStmt: String = joined.replacingOccurrences(of: "\'", with: "'")
@@ -132,7 +131,7 @@ class ImportFromJson {
                 .createSchema(message: message)
             }
         } else {
-            if jsonSQLite.mode == "partial" {
+            if mode == "partial" {
                 changes = 0
                 // Commit the transaction
                 try UtilsSQLCipher.commitTransaction(mDB: mDB)
@@ -144,16 +143,15 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - createSchemaStatement
 
-    class func createSchemaStatement(jsonSQLite: JsonSQLite)
-    -> [String] {
+    class func createSchemaStatement(tables: [ImportTable],
+                                     mode: String) -> [String] {
         // Create the Database Schema
         var statements: [String] = []
         // Loop through Tables
-        for ipos in 0..<jsonSQLite.tables.count {
-            let mode: String = jsonSQLite.mode
-            let tableName: String = jsonSQLite.tables[ipos].name
-            if let mSchema: [JsonColumn] =
-                jsonSQLite.tables[ipos].schema {
+        for ipos in 0..<tables.count {
+            let mode: String = mode
+            let tableName: String = tables[ipos].name
+            if let mSchema: [ImportColumn] = tables[ipos].schema {
                 if mSchema.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableSchema(
@@ -162,8 +160,7 @@ class ImportFromJson {
                     statements.append(contentsOf: stmt)
                 }
             }
-            if let mIndexes: [JsonIndex] =
-                jsonSQLite.tables[ipos].indexes {
+            if let mIndexes: [ImportIndex] = tables[ipos].indexes {
                 if mIndexes.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableIndexes(
@@ -171,8 +168,7 @@ class ImportFromJson {
                     statements.append(contentsOf: stmt)
                 }
             }
-            if let mTriggers: [JsonTrigger] =
-                jsonSQLite.tables[ipos].triggers {
+            if let mTriggers: [ImportTrigger] = tables[ipos].triggers {
                 if mTriggers.count > 0 {
                     let stmt: [String] =
                         ImportFromJson.createTableTriggers(
@@ -188,7 +184,7 @@ class ImportFromJson {
 
     // swiftlint:disable function_body_length
     // swiftlint:disable cyclomatic_complexity
-    class func createTableSchema(mSchema: [JsonColumn],
+    class func createTableSchema(mSchema: [ImportColumn],
                                  tableName: String, mode: String)
     -> [String] {
         var statements: [String] = []
@@ -251,7 +247,7 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateTableIndexes
 
-    class func createTableIndexes(mIndexes: [JsonIndex],
+    class func createTableIndexes(mIndexes: [ImportIndex],
                                   tableName: String) -> [String] {
         var statements: [String] = []
         for jpos in 0..<mIndexes.count {
@@ -279,7 +275,7 @@ class ImportFromJson {
 
     // MARK: - ImportFromJson - CreateTableTriggers
 
-    class func createTableTriggers(mTriggers: [JsonTrigger],
+    class func createTableTriggers(mTriggers: [ImportTrigger],
                                    tableName: String) -> [String] {
         var statements: [String] = []
 
@@ -308,8 +304,8 @@ class ImportFromJson {
 
     // swiftlint:disable function_body_length
     class func createDatabaseData(mDB: Database,
-                                  jsonSQLite: JsonSQLite)
-    throws -> Int {
+                                  tables: [ImportTable],
+                                  mode: String) throws -> Int {
         var changes: Int = -1
         var initChanges: Int = -1
         var isValue: Bool = false
@@ -322,19 +318,19 @@ class ImportFromJson {
             throw ImportFromJsonError.createDatabaseData(message: message)
         }
         // Loop on tables to create Data
-        for ipos in 0..<jsonSQLite.tables.count {
-            if let mValues = jsonSQLite.tables[ipos].values {
+        for ipos in 0..<tables.count {
+            if let mValues = tables[ipos].values {
                 if mValues.count > 0 {
                     isValue = true
                     do {
-                        let tableName = jsonSQLite.tables[ipos].name
+                        let tableName = tables[ipos].name
                         try ImportFromJson.createTableData(
                             mDB: mDB,
-                            mode: jsonSQLite.mode,
+                            mode: mode,
                             mValues: mValues,
                             tableName: tableName)
                         let msg = "Table \(tableName) data creation completed " +
-                            "\(ipos + 1)/\(jsonSQLite.tables.count) ..."
+                            "\(ipos + 1)/\(tables.count) ..."
                         notifyImportProgressEvent(msg: msg)
 
                     } catch ImportFromJsonError
@@ -382,7 +378,7 @@ class ImportFromJson {
     // swiftlint:disable function_body_length
     class func createTableData(
         mDB: Database, mode: String,
-        mValues: [[UncertainValue<String, Int, Double>]],
+        mValues: [[Any]],
         tableName: String) throws {
         var lastId: Int64 = -1
         // Check if table exists
@@ -410,8 +406,7 @@ class ImportFromJson {
         }
         for jpos in 0..<mValues.count {
             // Check row validity
-            let row: [UncertainValue<String, Int, Double>] =
-                mValues[jpos]
+            var rowValues = mValues[jpos]
             var isRun: Bool = true
 
             /* Remove types checking for allowing RDBMS Types
@@ -430,10 +425,9 @@ class ImportFromJson {
                                            "tableName": tableName]
                 let stmt: String = try ImportFromJson
                     .createRowStatement(mDB: mDB, data: data,
-                                        row: row,
+                                        row: rowValues,
                                         jsonNamesTypes: jsonNamesTypes)
-                var rowValues = UtilsJson.getValuesFromRow(
-                    rowValues: row)
+
                 isRun = try UtilsJson.checkUpdate(mDB: mDB, stmt: stmt,
                                                   values: rowValues,
                                                   tableName: tableName,
@@ -471,7 +465,7 @@ class ImportFromJson {
     class func createRowStatement(
         mDB: Database,
         data: [String: Any],
-        row: [UncertainValue<String, Int, Double>],
+        row: [Any],
         jsonNamesTypes: JsonNamesTypes) throws -> String {
         var stmt: String = ""
         var retisIdExists: Bool = false
@@ -489,19 +483,11 @@ class ImportFromJson {
                 message: message + " tableName")
         }
         do {
-            if let rwValue: Any = row[0].value {
-                retisIdExists = try UtilsJson.isIdExist(
-                    mDB: mDB, tableName: tableName,
-                    firstColumnName: jsonNamesTypes.names[0],
-                    key: rwValue)
-            } else {
-                var message: String = "createRowStatement: Table "
-                message.append("\(tableName) values row[0] does not ")
-                message.append("exist")
-                throw ImportFromJsonError.createRowStatement(
-                    message: message)
-            }
-
+            let rwValue = row[0]
+            retisIdExists = try UtilsJson.isIdExist(
+                mDB: mDB, tableName: tableName,
+                firstColumnName: jsonNamesTypes.names[0],
+                key: rwValue)
         } catch UtilsJsonError.isIdExists(let message) {
             throw ImportFromJsonError.createRowStatement(
                 message: message)
@@ -520,13 +506,13 @@ class ImportFromJson {
             let idxDelete: Int = jsonNamesTypes
                 .names.firstIndex(where: {$0 == "sql_deleted"}) ?? -1
             if idxDelete >= 0 {
-                if let delValue = row[idxDelete].value as? Int {
+                if let delValue = row[idxDelete] as? Int {
                     if delValue == 1 {
                         isUpdate = false
                         stmt = "DELETE FROM \(tableName) WHERE "
-                        if let rwValue = row[0].value as? String {
+                        if let rwValue = row[0] as? String {
                             stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
-                        } else if let rwValue = row[0].value as? Int {
+                        } else if let rwValue = row[0] as? Int {
                             stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
                         } else {
                             var msg: String = "importFromJson: Table "
@@ -550,9 +536,9 @@ class ImportFromJson {
                 }
 
                 stmt = "UPDATE \(tableName)  SET \(setString) WHERE "
-                if let rwValue = row[0].value as? String {
+                if let rwValue = row[0] as? String {
                     stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
-                } else if let rwValue = row[0].value as? Int {
+                } else if let rwValue = row[0] as? Int {
                     stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
                 } else {
                     var msg: String = "importFromJson: Table "
@@ -570,7 +556,7 @@ class ImportFromJson {
     // MARK: - ImportFromJson - createViews
 
     // swiftlint:disable function_body_length
-    class func createViews(mDB: Database, views: [JsonView]) throws -> Int {
+    class func createViews(mDB: Database, views: [ImportView]) throws -> Int {
         var changes: Int = 0
         var initChanges: Int = -1
         var isView: Bool = false
@@ -633,7 +619,7 @@ class ImportFromJson {
         return changes
 
     }
-    class func createView(mDB: Database, view: JsonView) throws {
+    class func createView(mDB: Database, view: ImportView) throws {
         let stmt = "CREATE VIEW IF NOT EXISTS \(view.name) AS \(view.value);"
         do {
             try UtilsSQLCipher.execute(mDB: mDB, sql: stmt)