@capacitor-community/sqlite 3.4.2-5 → 3.4.3-2

package/ios/Plugin/CapacitorSQLite.swift

@@ -959,7 +959,13 @@ enum CapacitorSQLiteError: Error {
                 do {
                     let res: [String: Any] = try
                         mDb.exportToJson(expMode: expMode)
-                    if res.count == 5 || res.count == 6 || res.count == 7 {
+                    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 == 5 || res.count == 6 ||
+                                res.count == 7 {
                         return res
                     } else {
                         var msg: String = "return Object is not a "
@@ -981,6 +987,33 @@ enum CapacitorSQLiteError: Error {
         }
     }
 
+    // MARK: - deleteExportedRows
+
+    @objc func deleteExportedRows(_ dbName: String) throws {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            guard let mDb: Database = dbDict[mDbName] else {
+                let msg = "Connection to \(mDbName) not available"
+                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"
+                throw CapacitorSQLiteError.failed(message: msg)
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+
     // MARK: - createSyncTable
 
     @objc func createSyncTable(_ dbName: String) throws -> NSNumber {

package/ios/Plugin/CapacitorSQLitePlugin.m

@@ -24,6 +24,7 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(importFromJson, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(isJsonValid, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(exportToJson, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(deleteExportedRows, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(createSyncTable, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(setSyncDate, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getSyncDate, CAPPluginReturnPromise);

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -937,6 +937,31 @@ public class CapacitorSQLitePlugin: CAPPlugin {
 
     }
 
+    // MARK: - DeleteExportedRows
+
+    @objc func deleteExportedRows(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"]
+                as? String else {
+            let msg = "DeleteExportedRows: Must provide a database name"
+            retHandler.rResult(call: call, message: msg)
+            return
+        }
+        do {
+            try implementation?.deleteExportedRows(dbName)
+            retHandler.rResult(call: call)
+            return
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "exportToJson: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            let msg = "exportToJson: \(error)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        }
+
+    }
+
     // MARK: - CreateSyncTable
 
     @objc func createSyncTable(_ call: CAPPluginCall) {

package/ios/Plugin/Database.swift

@@ -24,6 +24,7 @@ enum DatabaseError: Error {
     case exportToJson(message: String)
     case importFromJson(message: String)
     case getTableNames(message: String)
+    case deleteExportedRows(message: String)
 }
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -360,7 +361,8 @@ class Database {
         // Execute the query
         do {
             lastId = try UtilsSQLCipher
-                .prepareSQL(mDB: self, sql: sql, values: values)
+                .prepareSQL(mDB: self, sql: sql, values: values,
+                            fromJson: false)
         } catch UtilsSQLCipherError.prepareSQL(let message) {
             if transaction {
                 do {
@@ -551,17 +553,35 @@ class Database {
         var retObj: [String: Any] = [:]
 
         do {
+            let date = Date()
+            let syncTime: Int = Int(date.timeIntervalSince1970)
+            // Set the last exported date
+            try ExportToJson.setLastExportDate(mDB: self, sTime: syncTime)
+            // Launch the export process
             let data: [String: Any] = [
                 "dbName": dbName, "encrypted": self.encrypted,
                 "expMode": expMode, "version": dbVersion]
             retObj = try ExportToJson
                 .createExportObject(mDB: self, data: data)
+        } catch ExportToJsonError.setLastExportDate(let message) {
+            throw DatabaseError.exportToJson(message: message)
         } catch ExportToJsonError.createExportObject(let message) {
             throw DatabaseError.exportToJson(message: message)
         }
         return retObj
     }
 
+    // MARK: - DeleteExportedRows()
+
+    func deleteExportedRows() throws {
+
+        do {
+            try ExportToJson.delExportedRows(mDB: self)
+        } catch ExportToJsonError.delExportedRows(let message) {
+            throw DatabaseError.exportToJson(message: message)
+        }
+    }
+
     // MARK: - ImportFromJson
 
     func importFromJson(jsonSQLite: JsonSQLite)
@@ -570,6 +590,10 @@ class Database {
 
         // Create the Database Schema
         do {
+            // PRAGMA foreign_keys = OFF;
+            try UtilsSQLCipher
+                .setForeignKeyConstraintsEnabled(mDB: self,
+                                                 toggle: false)
             if jsonSQLite.tables.count > 0 {
                 changes = try ImportFromJson
                     .createDatabaseSchema(mDB: self,
@@ -587,6 +611,10 @@ class Database {
                         .createViews(mDB: self, views: mViews)
                 }
             }
+            // PRAGMA foreign_keys = ON;
+            try UtilsSQLCipher
+                .setForeignKeyConstraintsEnabled(mDB: self,
+                                                 toggle: true)
 
             return ["changes": changes]
         } catch ImportFromJsonError.createDatabaseSchema(let message) {

package/ios/Plugin/Extensions/String.swift

@@ -27,4 +27,12 @@ extension String {
         let stopIndex = self.index(self.startIndex, offsetBy: toIdx)
         return self[startIndex..<stopIndex]
     }
+    public func deletingPrefix(_ prefix: String) -> String {
+        guard self.hasPrefix(prefix) else { return self }
+        return String(self.dropFirst(prefix.count))
+    }
+    public func trimmingLeadingAndTrailingSpaces(using characterSet: CharacterSet = .whitespacesAndNewlines) -> String {
+        return trimmingCharacters(in: characterSet)
+    }
+
 }

package/ios/Plugin/ImportExportJson/ExportToJson.swift

@@ -27,10 +27,21 @@ enum ExportToJsonError: Error {
     case createRowValues(message: String)
     case modEmbeddedParentheses(message: String)
     case getViews(message: String)
-}
+    case setLastExportDate(message: String)
+    case getLastExportDate(message: String)
+    case delExportedRows(message: String)
 
+}
+var REALAFFINITY: [String] = ["REAL", "DOUBLE", "DOUBLE PRECISION", "FLOAT"]
+var INTEGERAFFINITY: [String] = ["INTEGER", "INT", "TINYINT", "SMALLINT",
+                                 "MEDIUMINT", "BIGINT", "UNSIGNED BIG INT",
+                                 "INT2", "INT8"]
+var TEXTAFFINITY: [String] = ["TEXT", "CHARACTER", "VARCHAR", "VARYING CHARACTER",
+                              "NCHAR", "NATIVE CHARACTER", "NVARCHAR", "CLOB"]
+var BLOBAFFINITY: [String] = ["BLOB"]
+var NUMERICAFFINITY: [String] = ["NUMERIC", "DECIMAL", "BOOLEAN", "DATE",
+                                 "DATETIME"]
 class ExportToJson {
-
     // MARK: - JsonNotifications - NotifyExportProgressEvent
 
     class func notifyExportProgressEvent(msg: String) {
@@ -40,6 +51,124 @@ class ExportToJson {
                                         userInfo: vId)
     }
 
+    // MARK: - ExportToJson - GetLastExportDate
+
+    class func getLastExportDate(mDB: Database) throws -> Int64 {
+        var ret: Int64 = -1
+        let query: String = "SELECT sync_date FROM sync_table WHERE id = 2;"
+        do {
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: mDB, tableName: "sync_table")
+            if isExists {
+                var resSyncDate =  try UtilsSQLCipher.querySQL(
+                    mDB: mDB, sql: query, values: [])
+                if resSyncDate.count > 1 {
+                    resSyncDate.removeFirst()
+                    guard let res: Int64 = resSyncDate[0]["sync_date"] as?
+                            Int64 else {
+                        throw ExportToJsonError.getLastExportDate(
+                            message: "Error get sync date failed")
+                    }
+                    if res > 0 {ret = res}
+                }
+            } else {
+                let msg = "No sync_table available"
+                throw ExportToJsonError.getLastExportDate(message: msg)
+            }
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw ExportToJsonError.getLastExportDate(message: message)
+        } catch UtilsSQLCipherError.querySQL(let message) {
+            throw ExportToJsonError.getLastExportDate(
+                message: "Error get last export date failed : \(message)")
+        }
+        return ret
+
+    }
+
+    // MARK: - ExportToJson - SetLastExportDate
+
+    class func setLastExportDate(mDB: Database, sTime: Int) throws {
+        do {
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: mDB, tableName: "sync_table")
+            if !isExists {
+                let msg = "No sync_table available"
+                throw ExportToJsonError.setLastExportDate(message: msg)
+            }
+            var stmt: String = ""
+            let res = try getLastExportDate(mDB: mDB)
+            if res > 0 {
+                stmt = "UPDATE sync_table SET sync_date = \(sTime) " +
+                    "WHERE id = 2;"
+            } else {
+                stmt = "INSERT INTO sync_table (sync_date) VALUES (\(sTime));"
+            }
+            let lastId: Int64 = try UtilsSQLCipher.prepareSQL(
+                mDB: mDB, sql: stmt, values: [], fromJson: false)
+            if lastId < 0 {
+                throw ExportToJsonError.setLastExportDate(
+                    message: "lastId < 0")
+            }
+            return
+        } catch UtilsSQLCipherError.prepareSQL(let message) {              throw ExportToJsonError.setLastExportDate(message: message)
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw ExportToJsonError.setLastExportDate(message: message)
+        } catch ExportToJsonError.getLastExportDate(let message) {
+            throw ExportToJsonError.setLastExportDate(message: message)
+        }
+
+    }
+
+    // MARK: - ExportToJson - DelExportedRows
+
+    class func delExportedRows(mDB: Database) throws {
+        do {
+            // check if synchronization table exists
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: mDB, tableName: "sync_table")
+            if !isExists {
+                let msg = "No sync_table available"
+                throw ExportToJsonError.delExportedRows(message: msg)
+            }
+            // get the last export date
+            let lastExportDate = try getLastExportDate(mDB: mDB)
+            if lastExportDate < 0 {
+                let msg = "No last exported date available"
+                throw ExportToJsonError.delExportedRows(message: msg)
+            }
+
+            // get the table' name list
+            let tableList: [String] = try mDB.getTableNames()
+            if tableList.count == 0 {
+                let msg = "No table's names returned"
+                throw ExportToJsonError.delExportedRows(message: msg)
+            }
+            // Loop through the tables
+            for table in tableList {
+                var lastId: Int64 = -1
+                // define the delete statement
+                let delStmt = "DELETE FROM \(table) WHERE sql_deleted = 1 " +
+                    "AND last_modified < \(lastExportDate);"
+                lastId = try UtilsSQLCipher.prepareSQL(mDB: mDB, sql: delStmt,
+                                                       values: [],
+                                                       fromJson: true)
+                if lastId < 0 {
+                    let msg = "DelExportedRows: lastId < 0"
+                    throw ExportToJsonError.delExportedRows(message: msg)
+                }
+            }
+            return
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw ExportToJsonError.delExportedRows(message: message)
+        } catch ExportToJsonError.getLastExportDate(let message) {
+            throw ExportToJsonError.delExportedRows(message: message)
+        } catch DatabaseError.getTableNames(let message) {
+            throw ExportToJsonError.delExportedRows(message: message)
+        } catch UtilsSQLCipherError.prepareSQL(let message) {
+            throw ExportToJsonError.delExportedRows(message: message)
+        }
+    }
+
     // MARK: - ExportToJson - CreateExportObject
 
     // swiftlint:disable function_body_length
@@ -427,17 +556,17 @@ class ExportToJson {
                                           table: table)
                     guard let isSch: Bool = result["isSchema"] as? Bool
                     else {
-                        throw ExportToJsonError.getTablesFull(
+                        throw ExportToJsonError.getTablesPartial(
                             message: "Error did not find isSchema")
                     }
                     guard let isIdxes: Bool = result["isIndexes"] as?
                             Bool else {
-                        throw ExportToJsonError.getTablesFull(
+                        throw ExportToJsonError.getTablesPartial(
                             message: "Error did not find isIndexes")
                     }
                     guard let retTable: [String: Any] = result["table"]
                             as? [String: Any] else {
-                        throw ExportToJsonError.getTablesFull(
+                        throw ExportToJsonError.getTablesPartial(
                             message: "Error did not find table")
                     }
                     isSchema = isSch
@@ -452,18 +581,18 @@ class ExportToJson {
                 let query: String = modTables[tableName] == "Create"
                     ? "SELECT * FROM \(tableName);"
                     : "SELECT * FROM \(tableName) WHERE last_modified" +
-                    " > \(syncDate);"
+                    " >= \(syncDate);"
                 result = try ExportToJson
                     .getValues(mDB: mDB, stmt: query,
                                table: table)
                 guard let isValues: Bool = result["isValues"] as? Bool
                 else {
-                    throw ExportToJsonError.getTablesFull(
+                    throw ExportToJsonError.getTablesPartial(
                         message: "Error did not find isValues")
                 }
                 guard let retTable1: [String: Any] = result["table"]
                         as? [String: Any] else {
-                    throw ExportToJsonError.getTablesFull(
+                    throw ExportToJsonError.getTablesPartial(
                         message: "Error did not find table")
                 }
                 table = retTable1
@@ -471,15 +600,13 @@ class ExportToJson {
                 var tableKeys: [String] = []
                 tableKeys.append(contentsOf: table.keys)
 
-                if tableKeys.count <= 1 ||
-                    (!isSchema && !isIndexes && !isValues) {
-                    throw ExportToJsonError.getTablesPartial(
-                        message: "Error table \(tableName) is not a jsonTable")
+                if tableKeys.count >= 1 &&
+                    (isSchema || isIndexes || isValues) {
+                    tables.append(table)
+                    msg = "Partial: Table \(tableName) data export completed " +
+                        "\(iTable)/\(resTables.count) ..."
+                    notifyExportProgressEvent(msg: msg)
                 }
-                tables.append(table)
-                msg = "Partial: Table \(tableName) data export completed " +
-                    "\(iTable)/\(resTables.count) ..."
-                notifyExportProgressEvent(msg: msg)
 
             }
         } catch ExportToJsonError.getSchemaIndexes(let message) {
@@ -528,19 +655,28 @@ class ExportToJson {
 
     class func getSyncDate(mDB: Database) throws -> Int64 {
         var ret: Int64 = -1
-        let query: String = "SELECT sync_date FROM sync_table;"
+        let query: String = "SELECT sync_date FROM sync_table WHERE id = 1;"
         do {
-            var resSyncDate =  try UtilsSQLCipher.querySQL(
-                mDB: mDB, sql: query, values: [])
-            if resSyncDate.count > 1 {
-                resSyncDate.removeFirst()
-                guard let res: Int64 = resSyncDate[0]["sync_date"] as?
-                        Int64 else {
-                    throw ExportToJsonError.getSyncDate(
-                        message: "Error get sync date failed")
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: mDB, tableName: "sync_table")
+            if isExists {
+                var resSyncDate =  try UtilsSQLCipher.querySQL(
+                    mDB: mDB, sql: query, values: [])
+                if resSyncDate.count > 1 {
+                    resSyncDate.removeFirst()
+                    guard let res: Int64 = resSyncDate[0]["sync_date"] as?
+                            Int64 else {
+                        throw ExportToJsonError.getSyncDate(
+                            message: "Error get sync date failed")
+                    }
+                    if res > 0 {ret = res}
                 }
-                if res > 0 {ret = res}
+            } else {
+                throw ExportToJsonError.getSyncDate(
+                    message: "Error no sync_table available")
             }
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw ExportToJsonError.getSyncDate(message: message)
         } catch UtilsSQLCipherError.querySQL(let message) {
             throw ExportToJsonError.getSyncDate(
                 message: "Error get sync date failed : \(message)")
@@ -588,7 +724,7 @@ class ExportToJson {
                             .getTablesModified(message: msg)
                         }
                         query = "SELECT count(*) AS count FROM \(tableName) "
-                        query.append("WHERE last_modified > ")
+                        query.append("WHERE last_modified >= ")
                         query.append("\(syncDate);")
                         resQuery =  try UtilsSQLCipher.querySQL(
                             mDB: mDB, sql: query, values: [])
@@ -996,14 +1132,19 @@ class ExportToJson {
 
     // MARK: - ExportToJson - CreateRowValues
 
+    // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
     class func createRowValues(values: [[String: Any]], pos: Int,
                                names: [String],
                                types: [String] ) throws -> [Any] {
         var row: [Any] = []
         for jpos in 0..<names.count {
-
-            //            if types[jpos] == "INTEGER" {
-            if values[pos][names[jpos]] is String {
+            if values[pos][names[jpos]] is String  && (TEXTAFFINITY
+                                                        .contains(types[jpos].components(separatedBy: "(")[0]
+                                                                    .uppercased())
+                                                        || BLOBAFFINITY.contains(types[jpos].uppercased())
+                                                        || NUMERICAFFINITY.contains(types[jpos].uppercased())
+            ) {
                 guard let val = values[pos][names[jpos]] as? String
                 else {
                     throw ExportToJsonError.createValues(
@@ -1017,14 +1158,29 @@ class ExportToJson {
                         message: "Error value must be NSNull")
                 }
                 row.append(val)
-            } else if values[pos][names[jpos]] is Int64 {
+            } else if values[pos][names[jpos]] is Int64 && (
+                        INTEGERAFFINITY.contains(types[jpos].uppercased()) ||
+                            NUMERICAFFINITY.contains(types[jpos].uppercased())) {
                 guard let val = values[pos][names[jpos]] as? Int64
                 else {
                     throw ExportToJsonError.createValues(
                         message: "Error value must be Int64")
                 }
                 row.append(val)
-            } else if values[pos][names[jpos]] is Double {
+            } else if values[pos][names[jpos]] is Int64 && (
+                        REALAFFINITY.contains(types[jpos].uppercased())  ||
+                            NUMERICAFFINITY.contains(types[jpos]
+                                                        .components(separatedBy: "(")[0].uppercased())) {
+                guard let val = values[pos][names[jpos]] as? Int64
+                else {
+                    throw ExportToJsonError.createValues(
+                        message: "Error value must be double")
+                }
+                row.append(Double(val))
+            } else if values[pos][names[jpos]] is Double && (
+                        REALAFFINITY.contains(types[jpos].uppercased()) ||
+                            NUMERICAFFINITY.contains(types[jpos]
+                                                        .components(separatedBy: "(")[0].uppercased())) {
                 guard let val = values[pos][names[jpos]] as? Double
                 else {
                     throw ExportToJsonError.createValues(
@@ -1040,6 +1196,8 @@ class ExportToJson {
         }
         return row
     }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
 
 }
 // swiftlint:enable type_body_length

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -46,15 +46,9 @@ class ImportFromJson {
             try UtilsSQLCipher.setVersion(mDB: mDB,
                                           version: version)
             if jsonSQLite.mode == "full" {
-                try UtilsSQLCipher
-                    .setForeignKeyConstraintsEnabled(mDB: mDB,
-                                                     toggle: false)
                 // Drop All Tables, Indexes and Triggers
                 try _ = UtilsDrop.dropAll(mDB: mDB)
             }
-            try UtilsSQLCipher
-                .setForeignKeyConstraintsEnabled(mDB: mDB,
-                                                 toggle: true)
             // create database schema
             changes = try ImportFromJson
                 .createSchema(mDB: mDB,
@@ -236,7 +230,7 @@ class ImportFromJson {
             stmt.append(" AFTER UPDATE ON ")
             stmt.append(tableName)
             stmt.append(" FOR EACH ROW ")
-            stmt.append("WHEN NEW.last_modified <= OLD.last_modified ")
+            stmt.append("WHEN NEW.last_modified < OLD.last_modified ")
             stmt.append("BEGIN UPDATE ")
             stmt.append(tableName)
             stmt.append(" SET last_modified = (strftime('%s','now')) ")
@@ -409,6 +403,8 @@ class ImportFromJson {
             // Check row validity
             let row: [UncertainValue<String, Int, Double>] =
                 mValues[jpos]
+            var isRun: Bool = true
+
             /* Remove types checking for allowing RDBMS Types
              do {
              try UtilsJson.checkRowValidity(
@@ -427,21 +423,31 @@ class ImportFromJson {
                     .createRowStatement(mDB: mDB, data: data,
                                         row: row,
                                         jsonNamesTypes: jsonNamesTypes)
-                let rowValues = UtilsJson.getValuesFromRow(
+                var rowValues = UtilsJson.getValuesFromRow(
                     rowValues: row)
-                let lastId: Int64 = try UtilsSQLCipher.prepareSQL(
-                    mDB: mDB, sql: stmt, values: rowValues)
-                if lastId < 0 {
-                    throw ImportFromJsonError.createTableData(
-                        message: "lastId < 0")
+                isRun = try UtilsJson.checkUpdate(mDB: mDB, stmt: stmt,
+                                                  values: rowValues,
+                                                  tableName: tableName,
+                                                  names: jsonNamesTypes.names,
+                                                  types: jsonNamesTypes.types)
+
+                if isRun {
+                    if stmt.prefix(6) == "DELETE" {
+                        rowValues = []
+                    }
+                    let lastId: Int64 = try UtilsSQLCipher.prepareSQL(
+                        mDB: mDB, sql: stmt, values: rowValues, fromJson: true)
+                    if lastId < 0 {
+                        throw ImportFromJsonError.createTableData(
+                            message: "lastId < 0")
+                    }
                 }
-            } catch ImportFromJsonError.createRowStatement(
-                        let message) {
-                throw ImportFromJsonError.createTableData(
-                    message: message)
+            } catch UtilsJsonError.checkUpdate(let message) {
+                throw ImportFromJsonError.createTableData(message: message)
+            } catch ImportFromJsonError.createRowStatement(let message) {
+                throw ImportFromJsonError.createTableData(message: message)
             } catch UtilsSQLCipherError.prepareSQL(let message) {
-                throw ImportFromJsonError.createTableData(
-                    message: message)
+                throw ImportFromJsonError.createTableData(message: message)
             }
         }
         return
@@ -451,6 +457,7 @@ class ImportFromJson {
     // MARK: - ImportFromJson - createRowStatement
 
     // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
     class func createRowStatement(
         mDB: Database,
         data: [String: Any],
@@ -499,31 +506,59 @@ class ImportFromJson {
             stmt = "INSERT INTO \(tableName) (\(nameString)) VALUES "
             stmt.append("(\(questionMarkString));")
         } else {
-            // Update
-            let setString: String = UtilsJson.setNameForUpdate(
-                names: jsonNamesTypes.names)
-            if setString.count == 0 {
-                var message: String = "importFromJson: Table "
-                message.append("\(tableName) values row ")
-                message.append("\(pos) not set to String")
-                throw ImportFromJsonError.createRowStatement(
-                    message: message)
+            var isUpdate: Bool = true
+            let idxDelete: Int = jsonNamesTypes
+                .names.firstIndex(where: {$0 == "sql_deleted"}) ?? -1
+            if idxDelete >= 0 {
+                if let delValue = row[idxDelete].value as? Int {
+                    if delValue == 1 {
+                        isUpdate = false
+                        stmt = "DELETE FROM \(tableName) WHERE "
+                        if let rwValue = row[0].value as? String {
+                            stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
+                        } else if let rwValue = row[0].value as? Int {
+                            stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
+                        } else {
+                            var msg: String = "importFromJson: Table "
+                            msg.append("\(tableName) values row[0]does not exist")
+                            throw ImportFromJsonError.createRowStatement(
+                                message: message)
+                        }
+                    }
+                }
             }
+            if isUpdate {
+                // Update
+                let setString: String = UtilsJson.setNameForUpdate(
+                    names: jsonNamesTypes.names)
+                if setString.count == 0 {
+                    var message: String = "importFromJson: Table "
+                    message.append("\(tableName) values row ")
+                    message.append("\(pos) not set to String")
+                    throw ImportFromJsonError.createRowStatement(
+                        message: message)
+                }
 
-            stmt = "UPDATE \(tableName)  SET \(setString) WHERE "
-            if let rwValue = row[0].value as? String {
-                stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
-            } else if let rwValue = row[0].value as? Int {
-                stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
-            } else {
-                var msg: String = "importFromJson: Table "
-                msg.append("\(tableName) values row[0]does not exist")
-                throw ImportFromJsonError.createRowStatement(
-                    message: message)
+                stmt = "UPDATE \(tableName)  SET \(setString) WHERE "
+                if let rwValue = row[0].value as? String {
+                    stmt += "\(jsonNamesTypes.names[0]) = '\(rwValue)';"
+                } else if let rwValue = row[0].value as? Int {
+                    stmt += "\(jsonNamesTypes.names[0]) = \(rwValue);"
+                } else {
+                    var msg: String = "importFromJson: Table "
+                    msg.append("\(tableName) values row[0]does not exist")
+                    throw ImportFromJsonError.createRowStatement(
+                        message: message)
+                }
             }
         }
         return stmt
     }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
+
+    // MARK: - ImportFromJson - createViews
+
     // swiftlint:disable function_body_length
     class func createViews(mDB: Database, views: [JsonView]) throws -> Int {
         var changes: Int = 0