@capacitor-community/sqlite 3.4.1-1 → 3.4.1-2

package/ios/Plugin/Database.swift

@@ -453,18 +453,27 @@ class Database {
             let isExists: Bool = try UtilsJson.isTableExists(
                 mDB: self, tableName: "sync_table")
             if !isExists {
-                let date = Date()
-                let syncTime: Int = Int(date.timeIntervalSince1970)
-                var stmt: String = "CREATE TABLE IF NOT EXISTS "
-                stmt.append("sync_table (")
-                stmt.append("id INTEGER PRIMARY KEY NOT NULL,")
-                stmt.append("sync_date INTEGER);")
-                stmt.append("INSERT INTO sync_table (sync_date) ")
-                stmt.append("VALUES ('\(syncTime)');")
-                retObj = try executeSQL(sql: stmt)
+                // check if there are tables with last_modified column
+                let isLastModified: Bool = try UtilsJson.isLastModified(mDB: self)
+                if isLastModified {
+                    let date = Date()
+                    let syncTime: Int = Int(date.timeIntervalSince1970)
+                    var stmt: String = "CREATE TABLE IF NOT EXISTS "
+                    stmt.append("sync_table (")
+                    stmt.append("id INTEGER PRIMARY KEY NOT NULL,")
+                    stmt.append("sync_date INTEGER);")
+                    stmt.append("INSERT INTO sync_table (sync_date) ")
+                    stmt.append("VALUES ('\(syncTime)');")
+                    retObj = try executeSQL(sql: stmt)
+                } else {
+                    let msg = "No last_modified column in tables"
+                    throw DatabaseError.createSyncTable(message: msg)
+                }
             } else {
                 retObj = 0
             }
+        } catch UtilsJsonError.isLastModified(let message) {
+            throw DatabaseError.createSyncTable(message: message)
         } catch UtilsJsonError.tableNotExists(let message) {
             throw DatabaseError.createSyncTable(message: message)
         } catch DatabaseError.executeSQL(let message) {
@@ -478,6 +487,11 @@ class Database {
     func setSyncDate(syncDate: String ) throws -> Bool {
         var retBool: Bool = false
         do {
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: self, tableName: "sync_table")
+            if !isExists {
+                throw DatabaseError.createSyncDate(message: "No sync_table available")
+            }
             let dateFormatter = DateFormatter()
             dateFormatter.locale = Locale(identifier: "en_US_POSIX")
             dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
@@ -494,6 +508,8 @@ class Database {
             } else {
                 throw DatabaseError.createSyncDate(message: "wrong syncDate")
             }
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw DatabaseError.createSyncDate(message: message)
         } catch DatabaseError.runSQL(let message) {
             throw DatabaseError.createSyncDate(message: message)
         }
@@ -505,7 +521,14 @@ class Database {
     func getSyncDate( ) throws -> Int64 {
         var syncDate: Int64 = 0
         do {
+            let isExists: Bool = try UtilsJson.isTableExists(
+                mDB: self, tableName: "sync_table")
+            if !isExists {
+                throw DatabaseError.getSyncDate(message: "No sync_table available")
+            }
             syncDate = try ExportToJson.getSyncDate(mDB: self)
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw DatabaseError.getSyncDate(message: message)
         } catch ExportToJsonError.getSyncDate(let message) {
             throw DatabaseError.getSyncDate(message: message)
         }

package/ios/Plugin/ImportExportJson/ExportToJson.swift

@@ -88,6 +88,12 @@ class ExportToJson {
             let resTables =  try UtilsSQLCipher.querySQL(
                 mDB: mDB, sql: query, values: [])
             if resTables.count > 0 {
+                let isExists: Bool = try UtilsJson.isTableExists(
+                    mDB: mDB, tableName: "sync_table")
+                if !isExists && expMode == "partial" {
+                    throw ExportToJsonError.createExportObject(message: "No sync_table available")
+                }
+
                 switch expMode {
                 case "partial" :
                     tables = try ExportToJson
@@ -102,6 +108,8 @@ class ExportToJson {
                         message: "expMode \(expMode) not defined")
                 }
             }
+        } catch UtilsJsonError.tableNotExists(let message) {
+            throw ExportToJsonError.createExportObject(message: message)
         } catch UtilsSQLCipherError.querySQL(let message) {
             throw ExportToJsonError.createExportObject(
                 message: "Error get table's names failed : \(message)")

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -194,12 +194,16 @@ class ImportFromJson {
     -> [String] {
         var statements: [String] = []
         var stmt: String
+        var isLastModified: Bool = false
         stmt = "CREATE TABLE IF NOT EXISTS "
         stmt.append(tableName)
         stmt.append(" (")
         for jpos in 0..<mSchema.count {
             if let jSchColumn = mSchema[jpos].column {
                 if jSchColumn.count > 0 {
+                    if jSchColumn == "last_modified" {
+                        isLastModified = true
+                    }
                     stmt.append(jSchColumn)
                 }
             }
@@ -221,20 +225,22 @@ class ImportFromJson {
         }
         stmt.append(");")
         statements.append(stmt)
-        // create trigger last_modified associated with the table
-        let triggerName: String = tableName + "_trigger_last_modified"
-        stmt = "CREATE TRIGGER IF NOT EXISTS "
-        stmt.append(triggerName)
-        stmt.append(" AFTER UPDATE ON ")
-        stmt.append(tableName)
-        stmt.append(" FOR EACH ROW ")
-        stmt.append("WHEN NEW.last_modified <= OLD.last_modified ")
-        stmt.append("BEGIN UPDATE ")
-        stmt.append(tableName)
-        stmt.append(" SET last_modified = (strftime('%s','now')) ")
-        stmt.append("WHERE id=OLD.id; ")
-        stmt.append("END;")
-        statements.append(stmt)
+        if isLastModified {
+            // create trigger last_modified associated with the table
+            let triggerName: String = tableName + "_trigger_last_modified"
+            stmt = "CREATE TRIGGER IF NOT EXISTS "
+            stmt.append(triggerName)
+            stmt.append(" AFTER UPDATE ON ")
+            stmt.append(tableName)
+            stmt.append(" FOR EACH ROW ")
+            stmt.append("WHEN NEW.last_modified <= OLD.last_modified ")
+            stmt.append("BEGIN UPDATE ")
+            stmt.append(tableName)
+            stmt.append(" SET last_modified = (strftime('%s','now')) ")
+            stmt.append("WHERE id=OLD.id; ")
+            stmt.append("END;")
+            statements.append(stmt)
+        }
         return statements
     }
 

package/ios/Plugin/Utils/UtilsJson.swift

@@ -17,6 +17,7 @@ enum UtilsJsonError: Error {
     case validateIndexes(message: String)
     case validateTriggers(message: String)
     case validateViews(message: String)
+    case isLastModified(message: String)
 }
 
 // swiftlint:disable type_body_length
@@ -46,6 +47,33 @@ class UtilsJson {
         return ret
     }
 
+    // MARK: - ImportFromJson - IsLastModified
+
+    class func isLastModified(mDB: Database) throws -> Bool {
+        var msg: String = "Error LastModified: "
+        if !mDB.isDBOpen() {
+            msg.append("Database not opened")
+            throw UtilsJsonError.isLastModified(message: msg)
+        }
+        var ret: Bool = false
+        do {
+            let tableList: [String] = try UtilsDrop.getTablesNames(mDB: mDB)
+            for table in tableList {
+                let namesTypes: JsonNamesTypes = try getTableColumnNamesTypes(mDB: mDB,
+                                                                              tableName: table)
+                if namesTypes.names.contains("last_modified") {
+                    ret = true
+                    break
+                }
+            }
+        } catch UtilsJsonError.getTableColumnNamesTypes(let message) {
+            throw UtilsJsonError.isLastModified(message: message)
+        } catch UtilsDropError.getTablesNamesFailed(let message) {
+            throw UtilsJsonError.isLastModified(message: message)
+        }
+        return ret
+    }
+
     // MARK: - ImportFromJson - IsViewExists
 
     class func isViewExists(mDB: Database, viewName: String)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "3.4.1-1",
+  "version": "3.4.1-2",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -91,5 +91,8 @@
     "electron": {
       "src": "electron"
     }
+  },
+  "dependencies": {
+    "jeep-sqlite": "^1.3.7"
   }
 }