@capacitor-community/sqlite 3.2.0 → 3.2.2

package/ios/Plugin/ImportExportJson/ExportToJson.swift

@@ -26,6 +26,7 @@ enum ExportToJsonError: Error {
     case getSyncDate(message: String)
     case createRowValues(message: String)
     case modEmbeddedParentheses(message: String)
+    case getViews(message: String)
 }
 
 class ExportToJson {
@@ -64,14 +65,26 @@ class ExportToJson {
             throw ExportToJsonError.createExportObject(
                 message: message + "version")
         }
-
+        var views: [[String: String]] = []
         var tables: [[String: Any]] = []
-
-        // get the table's name
-        var query: String = "SELECT name,sql FROM sqlite_master WHERE "
-        query.append("type = 'table' AND name NOT LIKE 'sqlite_%' ")
-        query.append("AND name NOT LIKE 'sync_table';")
         do {
+            // Get the views
+            // get the view's name
+            var stmtV: String = "SELECT name,sql FROM sqlite_master WHERE "
+            stmtV.append("type = 'view' AND name NOT LIKE 'sqlite_%';")
+            let resViews =  try UtilsSQLCipher.querySQL(
+                mDB: mDB, sql: stmtV, values: [])
+            if resViews.count > 0 {
+                views = try ExportToJson
+                    .getViews(mDB: mDB,
+                              resViews: resViews)
+            }
+            // Get the tables
+
+            // get the table's name
+            var query: String = "SELECT name,sql FROM sqlite_master WHERE "
+            query.append("type = 'table' AND name NOT LIKE 'sqlite_%' ")
+            query.append("AND name NOT LIKE 'sync_table';")
             let resTables =  try UtilsSQLCipher.querySQL(
                 mDB: mDB, sql: query, values: [])
             if resTables.count > 0 {
@@ -92,6 +105,9 @@ class ExportToJson {
         } catch UtilsSQLCipherError.querySQL(let message) {
             throw ExportToJsonError.createExportObject(
                 message: "Error get table's names failed : \(message)")
+        } catch ExportToJsonError.getViews(let message) {
+            throw ExportToJsonError.createExportObject(
+                message: "Error get views failed : \(message)")
         } catch ExportToJsonError.getTablesFull(let message) {
             throw ExportToJsonError.createExportObject(
                 message: "Error get tables 'Full' failed : \(message)")
@@ -106,6 +122,9 @@ class ExportToJson {
             retObj["encrypted"] = encrypted
             retObj["mode"] = expMode
             retObj["tables"] = tables
+            if views.count > 0 {
+                retObj["views"] = views
+            }
         }
 
         return retObj
@@ -217,6 +236,32 @@ class ExportToJson {
         }
     }
 
+    // MARK: - ExportToJson - GetViews
+
+    class func getViews(mDB: Database,
+                        resViews: [[String: Any]])
+    throws -> [[String: String]] {
+        var views: [[String: String]] = []
+        var iView: Int = 0
+        for rView in resViews {
+            iView += 1
+            guard let viewName: String = rView["name"] as? String
+            else {
+                throw ExportToJsonError.getViews(
+                    message: "Error did not find view name")
+            }
+            guard let sqlStmt: String = rView["sql"] as? String else {
+                throw ExportToJsonError.getViews(
+                    message: "Error did not find sql statement")
+            }
+            var view: [String: String] = [:]
+            view["name"] = viewName
+            view["value"] = sqlStmt.components(separatedBy: "AS ")[1]
+            views.append(view)
+        }
+        return views
+    }
+
     // MARK: - ExportToJson - GetTablesFull
 
     // swiftlint:disable cyclomatic_complexity

package/ios/Plugin/ImportExportJson/ImportFromJson.swift

@@ -18,6 +18,8 @@ enum ImportFromJsonError: Error {
     case createSchemaStatement(message: String)
     case createTableData(message: String)
     case createRowStatement(message: String)
+    case createView(message: String)
+    case createViews(message: String)
 }
 class ImportFromJson {
 
@@ -512,6 +514,79 @@ class ImportFromJson {
         }
         return stmt
     }
+    // swiftlint:disable function_body_length
+    class func createViews(mDB: Database, views: [JsonView]) throws -> Int {
+        var changes: Int = 0
+        var initChanges: Int = -1
+        var isView: Bool = false
+        var msg: String = ""
+
+        do {
+            initChanges = UtilsSQLCipher.dbChanges(mDB: mDB.mDb)
+            // Start a transaction
+            try UtilsSQLCipher.beginTransaction(mDB: mDB)
+        } catch UtilsSQLCipherError.beginTransaction(let message) {
+            throw ImportFromJsonError.createDatabaseData(message: message)
+        }
+        for view in views {
+            if view.name.count > 0 && view.value.count > 0 {
+                do {
+                    try ImportFromJson.createView(
+                        mDB: mDB,
+                        view: view)
+                    isView = true
+                } catch ImportFromJsonError
+                            .createView(let message) {
+                    msg = message
+                }
+            } else {
+                msg = "no name and value"
+                break
+            }
+        }
+        if isView {
+            // commit
+            do {
+                // Commit the transaction
+                try UtilsSQLCipher.commitTransaction(mDB: mDB)
+                changes = UtilsSQLCipher
+                    .dbChanges(mDB: mDB.mDb) - initChanges
+            } catch UtilsSQLCipherError.commitTransaction(
+                        let message) {
+                throw ImportFromJsonError.createDatabaseData(
+                    message: message)
+            }
+        } else {
+            if msg.count > 0 {
+                // rollback
+                do {
+                    // Rollback the transaction
+                    try UtilsSQLCipher
+                        .rollbackTransaction(mDB: mDB)
+                    throw ImportFromJsonError
+                    .createViews(message: msg)
+                } catch UtilsSQLCipherError
+                            .rollbackTransaction(let message) {
+                    msg.append(" rollback: \(message)")
+                    throw ImportFromJsonError
+                    .createViews(message: msg)
+                }
+            } else {
+                changes = 0
+            }
+        }
+        return changes
+
+    }
+    class func createView(mDB: Database, view: JsonView) throws {
+        let stmt = "CREATE VIEW IF NOT EXISTS \(view.name) AS \(view.value);"
+        do {
+            try UtilsSQLCipher.execute(mDB: mDB, sql: stmt)
+        } catch UtilsSQLCipherError.execute(let message) {
+            throw ImportFromJsonError
+            .createView(message: message)
+        }
+    }
 }
 // swiftlint:enable type_body_length
 // swiftlint:enable file_length

package/ios/Plugin/ImportExportJson/JsonSQLite.swift

@@ -13,6 +13,7 @@ public struct JsonSQLite: Codable {
     let encrypted: Bool
     let mode: String
     let tables: [JsonTable]
+    var views: [JsonView]?
 
     public func show() {
         print("databaseName: \(database) ")
@@ -23,6 +24,12 @@ public struct JsonSQLite: Codable {
         for table in tables {
             table.show()
         }
+        if let mViews = views {
+            print("Number of Views: \(mViews.count) ")
+            for view in mViews {
+                view.show()
+            }
+        }
     }
 }
 
@@ -137,6 +144,15 @@ public struct UncertainValue<T: Codable, U: Codable, V: Codable>: Codable {
         }
     }
 }
+public struct JsonView: Codable {
+    let name: String
+    let value: String
+
+    public func show() {
+        print("name: \(name) ")
+        print("value: \(value) ")
+    }
+}
 
 public struct JsonNamesTypes {
     var names: [String]

package/ios/Plugin/ReturnHandler.swift

@@ -63,7 +63,7 @@ class ReturnHandler {
             call.reject(intMessage)
             return
         } else {
-            call.resolve(["version": ret])
+            call.resolve(["version": ret as Any])
             return
         }
     }

package/ios/Plugin/Utils/UtilsDrop.swift

@@ -11,9 +11,11 @@ import SQLCipher
 
 enum UtilsDropError: Error {
     case getTablesNamesFailed(message: String)
+    case getViewsNamesFailed(message: String)
     case getIndexesNamesFailed(message: String)
     case getTriggersNamesFailed(message: String)
     case dropTablesFailed(message: String)
+    case dropViewsFailed(message: String)
     case dropIndexesFailed(message: String)
     case dropTriggersFailed(message: String)
     case dropAllFailed(message: String)
@@ -71,6 +73,54 @@ class UtilsDrop {
         }
     }
 
+    // MARK: - getViewsNames
+
+    class func getViewsNames(mDB: Database) throws -> [String] {
+        var names: [String] = []
+        var query: String = "SELECT name FROM sqlite_master WHERE "
+        query.append("type='view' AND name NOT LIKE 'sqlite_%' ")
+        query.append("ORDER BY rootpage DESC;")
+        do {
+            let resQuery = try mDB.selectSQL(sql: query, values: [])
+            if resQuery.count > 0 {
+                for ipos in 0..<resQuery.count {
+                    if let mName = resQuery[ipos]["name"] as? String {
+                        names.append("\(mName)")
+                    }
+                }
+            }
+            return names
+        } catch DatabaseError.selectSQL(let message) {
+            throw UtilsDropError.getViewsNamesFailed(message: message)
+        }
+    }
+
+    // MARK: - dropViews
+
+    class func dropViews(mDB: Database)
+    throws -> Int {
+        var changes: Int = 0
+        do {
+            let views: [String] = try getViewsNames(mDB: mDB)
+            var statements: [String] = []
+            for view in views {
+                var stmt: String = "DROP VIEW IF EXISTS "
+                stmt.append(view)
+                stmt.append(";")
+                statements.append(stmt)
+            }
+            if statements.count > 0 {
+                let joined = statements.joined(separator: "\n")
+                changes = try mDB.executeSQL(sql: joined)
+            }
+            return changes
+        } catch UtilsDropError.getViewsNamesFailed(let message) {
+            throw UtilsDropError.dropViewsFailed(message: message)
+        } catch DatabaseError.executeSQL(let message) {
+            throw UtilsDropError.dropViewsFailed(message: message)
+        }
+    }
+
     // MARK: - getIndexesNames
 
     class func getIndexesNames(mDB: Database) throws -> [String] {
@@ -172,13 +222,11 @@ class UtilsDrop {
 
         do {
             var retChanges: Int = try self.dropTables(mDB: mDB)
-            print("after dropTables retChanges: \(retChanges)")
             retChanges = try self.dropIndexes(mDB: mDB)
             changes += retChanges
-            print("after dropIndexes retChanges: \(retChanges)")
             retChanges = try self.dropTriggers(mDB: mDB)
-            print("after dropTriggers retChanges: \(retChanges)")
             changes += retChanges
+            retChanges = try self.dropViews(mDB: mDB)
             if changes >= 0 {
                 _ = try UtilsSQLCipher.prepareSQL(mDB: mDB,
                                                   sql: "VACUUM;", values: [])
@@ -192,6 +240,8 @@ class UtilsDrop {
             throw UtilsDropError.dropAllFailed(message: message)
         } catch UtilsDropError.dropTriggersFailed(let message) {
             throw UtilsDropError.dropAllFailed(message: message)
+        } catch UtilsDropError.dropViewsFailed(let message) {
+            throw UtilsDropError.dropAllFailed(message: message)
         } catch UtilsSQLCipherError.prepareSQL(let message) {
             throw UtilsDropError.dropAllFailed(message: message)
         }

package/ios/Plugin/Utils/UtilsJson.swift

@@ -9,14 +9,17 @@ import Foundation
 
 enum UtilsJsonError: Error {
     case tableNotExists(message: String)
+    case viewNotExists(message: String)
     case getTableColumnNamesTypes(message: String)
     case isIdExists(message: String)
     case checkRowValidity(message: String)
     case validateSchema(message: String)
     case validateIndexes(message: String)
     case validateTriggers(message: String)
+    case validateViews(message: String)
 }
 
+// swiftlint:disable type_body_length
 class UtilsJson {
 
     // MARK: - ImportFromJson - IsTableExists
@@ -43,6 +46,30 @@ class UtilsJson {
         return ret
     }
 
+    // MARK: - ImportFromJson - IsViewExists
+
+    class func isViewExists(mDB: Database, viewName: String)
+    throws -> Bool {
+        var msg: String = "Error isViewExists: "
+        if !mDB.isDBOpen() {
+            msg.append("Database not opened")
+            throw UtilsJsonError.viewNotExists(message: msg)
+        }
+        var ret: Bool = false
+        var query = "SELECT name FROM sqlite_master WHERE type='view'"
+        query.append(" AND name='")
+        query.append(viewName)
+        query.append("';")
+        do {
+            let resQuery: [Any] = try UtilsSQLCipher
+                .querySQL(mDB: mDB, sql: query, values: [])
+            if resQuery.count > 0 {ret = true}
+        } catch UtilsSQLCipherError.querySQL(let message) {
+            throw UtilsJsonError.viewNotExists(message: message)
+        }
+        return ret
+    }
+
     // MARK: - ImportFromJson - GetTableColumnNamesTypes
 
     class func getTableColumnNamesTypes(mDB: Database,
@@ -278,4 +305,30 @@ class UtilsJson {
         return isTriggers
     }
 
+    // MARK: - ExportToJson - validateIndexes
+
+    class func validateViews(views: [[String: String]])
+    throws -> Bool {
+
+        var isViews = false
+        do {
+            let eViews = try JSONEncoder().encode(views)
+            guard let eViewsString: String =
+                    String(data: eViews, encoding: .utf8) else {
+                var message: String = "Error in converting "
+                message.append("eViews to String")
+                throw UtilsJsonError.validateViews(
+                    message: message)
+            }
+            if eViewsString.count > 0 {
+                isViews = true
+            }
+        } catch {
+            throw UtilsJsonError.validateViews(
+                message: "Error in encoding views")
+        }
+        return isViews
+    }
+
 }
+// swiftlint:enable type_body_length

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -629,7 +629,7 @@ class UtilsSQLCipher {
                     throw UtilsSQLCipherError.executeSet(
                         message: "No values given")
                 }
-                let isArray = UtilsSQLCipher.parse(mVar: values[0])
+                let isArray = values.count > 0 ? UtilsSQLCipher.parse(mVar: values[0]) : false
                 if isArray {
                     if let arrValues = values as? [[Any]] {
                         for vals in arrValues {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -54,10 +54,10 @@
     "prepublishOnly": "npm run build && npm run build-electron && npm run docgen"
   },
   "devDependencies": {
-    "@capacitor/android": "^3.2.0",
-    "@capacitor/core": "3.2.0",
+    "@capacitor/android": "^3.2.2",
+    "@capacitor/core": "3.2.2",
     "@capacitor/docgen": "^0.0.17",
-    "@capacitor/ios": "^3.2.0",
+    "@capacitor/ios": "^3.2.2",
     "@ionic/eslint-config": "^0.3.0",
     "@ionic/prettier-config": "^1.0.1",
     "@ionic/swiftlint-config": "^1.1.2",
@@ -73,7 +73,7 @@
     "typescript": "~4.0.5"
   },
   "peerDependencies": {
-    "@capacitor/core": "^3.2.0"
+    "@capacitor/core": "^3.2.2"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",