@capacitor-community/sqlite 3.3.2 → 3.3.3-1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 3.3.3-1 (2021-12-18)
+
+### Added Features
+
+ - Open in Read-Only Mode databases without SQLite suffix 
+ - getNCDatabasePath, createNCConnection, closeNCConnection, isNCDatabase
+ - add NonConformedDatabase.md documentation
+
+### Bug Fixes
+
+ - fix mode "UNIQUE" not case sensitive in importToJson index issue#203
+ - fix support non-conformed database in read-only mode issue#201
+
+
 ## 3.3.2 (2021-12-13)
 
 ### Chore

package/README.md

@@ -212,6 +212,10 @@ No configuration required for this plugin
 | changeEncryptionSecret      | ✅      | ✅  | ❌        | ❌  |
 | initWebStore                | ❌      | ❌  | ❌        | ✅  |
 | saveToStore                 | ❌      | ❌  | ❌        | ✅  |
+| getNCDatabasePath           | ✅      | ✅  | ❌        | ❌  |
+| createNCConnection          | ✅      | ✅  | ❌        | ❌  |
+| closeNCConnection           | ✅      | ✅  | ❌        | ❌  |
+| isNCDatabase                | ✅      | ✅  | ❌        | ❌  |
 
 ## Supported SQLite Types
 
@@ -237,6 +241,8 @@ No configuration required for this plugin
 
 - [Web_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md)
 
+- [Non_Conformed_Databases_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/NonConformedDatabases.md)
+
 ### Framework's Usage 
 
 - [Ionic/Angular_Usage_Documentation](https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md)

package/android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLite.java

@@ -14,6 +14,7 @@ import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.JsonSQ
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.UtilsJson;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsFile;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsMigrate;
+import com.getcapacitor.community.database.sqlite.SQLite.UtilsNCDatabase;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsSQLite;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsSecret;
 import java.io.File;
@@ -39,6 +40,7 @@ public class CapacitorSQLite {
     private UtilsFile uFile = new UtilsFile();
     private UtilsJson uJson = new UtilsJson();
     private UtilsMigrate uMigrate = new UtilsMigrate();
+    private UtilsNCDatabase uNCDatabase = new UtilsNCDatabase();
     private UtilsSecret uSecret;
     private SharedPreferences sharedPreferences;
 
@@ -116,6 +118,15 @@ public class CapacitorSQLite {
         }
     }
 
+    public String getNCDatabasePath(String folderPath, String database) throws Exception {
+        try {
+            String databasePath = uNCDatabase.getNCDatabasePath(context, folderPath, database);
+            return databasePath;
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
     /**
      * CreateConnection
      * @param dbName
@@ -148,6 +159,38 @@ public class CapacitorSQLite {
         }
     }
 
+    /**
+     * CreateConnection
+     * @param dbPath
+     * @param version
+     * @throws Exception
+     */
+    public void createNCConnection(String dbPath, int version) throws Exception {
+        // check if connection already exists
+        Database conn = dbDict.get(dbPath);
+        if (conn != null) {
+            String msg = "Connection " + dbPath + " already exists";
+            throw new Exception(msg);
+        }
+        try {
+            Boolean isDBPathExists = uFile.isPathExists(dbPath);
+            if (!isDBPathExists) {
+                String msg = "Database " + dbPath + " does not exist";
+                throw new Exception(msg);
+            }
+            Database db = new Database(context, dbPath, false, "no-encryption", version, new Hashtable<>(), sharedPreferences);
+            if (db != null) {
+                dbDict.put(dbPath, db);
+                return;
+            } else {
+                String msg = "db is null";
+                throw new Exception(msg);
+            }
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
     /**
      * Open
      * @param dbName
@@ -222,6 +265,29 @@ public class CapacitorSQLite {
         }
     }
 
+    /**
+     * CloseNCConnection
+     * @param dbPath
+     * @throws Exception
+     */
+    public void closeNCConnection(String dbPath) throws Exception {
+        Database db = dbDict.get(dbPath);
+        if (db != null) {
+            if (db.isOpen()) {
+                try {
+                    close(dbPath);
+                } catch (Exception e) {
+                    throw new Exception(e.getMessage());
+                }
+            }
+            dbDict.remove(dbPath);
+            return;
+        } else {
+            String msg = "No available connection for database " + dbPath;
+            throw new Exception(msg);
+        }
+    }
+
     /**
      * CloseConnection
      * @param dbName
@@ -301,6 +367,16 @@ public class CapacitorSQLite {
         return uFile.isFileExists(context, dbName + "SQLite.db");
     }
 
+    /**
+     * IsNCDatabase
+     * @param dbPath
+     * @return Boolean
+     * @throws Exception
+     */
+    public Boolean isNCDatabase(String dbPath) {
+        return uFile.isPathExists(dbPath);
+    }
+
     /**
      * IsTableExists
      * @param dbName
@@ -398,7 +474,7 @@ public class CapacitorSQLite {
         dbName = getDatabaseName(dbName);
         Database db = dbDict.get(dbName);
         if (db != null) {
-            if (db.isOpen()) {
+            if (!db.isNCDB() && db.isOpen()) {
                 // convert string in string[]
                 String[] sqlCmdArray = uSqlite.getStatementsArray(statements);
                 try {
@@ -428,7 +504,7 @@ public class CapacitorSQLite {
         dbName = getDatabaseName(dbName);
         Database db = dbDict.get(dbName);
         if (db != null) {
-            if (db.isOpen()) {
+            if (!db.isNCDB() && db.isOpen()) {
                 try {
                     JSObject res = db.executeSet(set, transaction);
                     return res;
@@ -458,7 +534,7 @@ public class CapacitorSQLite {
         dbName = getDatabaseName(dbName);
         Database db = dbDict.get(dbName);
         if (db != null) {
-            if (db.isOpen()) {
+            if (!db.isNCDB() && db.isOpen()) {
                 if (values.length() > 0) {
                     try {
                         ArrayList<Object> arrValues = uSqlite.objectJSArrayToArrayList(values);
@@ -737,11 +813,11 @@ public class CapacitorSQLite {
 
     private String getDatabaseName(String dbName) {
         String retName = dbName;
-
-        if (retName.endsWith(".db")) {
-            retName = retName.substring(0, retName.length() - 3);
+        if (!retName.contains("/")) {
+            if (retName.endsWith(".db")) {
+                retName = retName.substring(0, retName.length() - 3);
+            }
         }
-
         return retName;
     }
 

package/android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLitePlugin.java

@@ -132,6 +132,60 @@ public class CapacitorSQLitePlugin extends Plugin {
         }
     }
 
+    @PluginMethod
+    public void getNCDatabasePath(PluginCall call) {
+        String folderPath = null;
+        String dbName = null;
+        if (!call.getData().has("path")) {
+            String msg = "getNCDatabasePath: Must provide a folder path";
+            rHandler.retPath(call, null, msg);
+            return;
+        }
+        folderPath = call.getString("path");
+        if (!call.getData().has("database")) {
+            String msg = "getNCDatabasePath: Must provide a database name";
+            rHandler.retPath(call, null, msg);
+            return;
+        }
+        dbName = call.getString("database");
+        try {
+            String databasePath = implementation.getNCDatabasePath(folderPath, dbName);
+            rHandler.retPath(call, databasePath, null);
+            return;
+        } catch (Exception e) {
+            String msg = "getNCDatabasePath: " + e.getMessage();
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+    }
+
+    /**
+     * CreateNCConnection Method
+     * Create a non-conformed connection to a database
+     * @param call
+     */
+    @PluginMethod
+    public void createNCConnection(PluginCall call) {
+        String dbPath = null;
+        int dbVersion = Integer.valueOf(-1);
+        if (!call.getData().has("databasePath")) {
+            String msg = "CreateNCConnection: Must provide a database path";
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+        dbPath = call.getString("databasePath");
+        dbVersion = call.getInt("version", 1);
+        try {
+            implementation.createNCConnection(dbPath, dbVersion);
+            rHandler.retResult(call, null, null);
+            return;
+        } catch (Exception e) {
+            String msg = "CreateNCConnection: " + e.getMessage();
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+    }
+
     /**
      * CreateConnection Method
      * Create a connection to a database
@@ -141,8 +195,6 @@ public class CapacitorSQLitePlugin extends Plugin {
     public void createConnection(PluginCall call) {
         String dbName = null;
         int dbVersion = Integer.valueOf(-1);
-        String secret = null;
-        String newsecret = null;
         String inMode = null;
         JSObject ret = new JSObject();
         if (!call.getData().has("database")) {
@@ -166,7 +218,6 @@ public class CapacitorSQLitePlugin extends Plugin {
             }
         } else {
             inMode = "no-encryption";
-            secret = "";
         }
         Dictionary<Integer, JSONObject> upgDict = versionUpgrades.get(dbName);
         try {
@@ -252,6 +303,30 @@ public class CapacitorSQLitePlugin extends Plugin {
         }
     }
 
+    /**
+     * CloseNCConnection Method
+     * Close a non-conformed database connection
+     * @param call
+     */
+    @PluginMethod
+    public void closeNCConnection(PluginCall call) {
+        if (!call.getData().has("databasePath")) {
+            String msg = "CloseNCConnection: Must provide a database path";
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+        String dbPath = call.getString("databasePath");
+        try {
+            implementation.closeNCConnection(dbPath);
+            rHandler.retResult(call, null, null);
+            return;
+        } catch (Exception e) {
+            String msg = "CloseNCConnection: " + e.getMessage();
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+    }
+
     /**
      * CloseConnection Method
      * Close the connection to a database
@@ -323,6 +398,29 @@ public class CapacitorSQLitePlugin extends Plugin {
         }
     }
 
+    /**
+     * IsDatabase Method
+     * Check if the database file exists
+     * @param call
+     */
+    @PluginMethod
+    public void isNCDatabase(PluginCall call) {
+        if (!call.getData().has("databasePath")) {
+            rHandler.retResult(call, null, "Must provide a database path");
+            return;
+        }
+        String dbPath = call.getString("databasePath");
+        try {
+            Boolean res = implementation.isNCDatabase(dbPath);
+            rHandler.retResult(call, res, null);
+            return;
+        } catch (Exception e) {
+            String msg = "isNCDatabase: " + e.getMessage();
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+    }
+
     /**
      * IsTableExists Method
      * Check if a table exists in a database

package/android/src/main/java/com/getcapacitor/community/database/sqlite/RetHandler.java

@@ -140,4 +140,28 @@ public class RetHandler {
             return;
         }
     }
+
+    /**
+     * RetPath Method
+     * Create and return the capSQLiteResult object
+     * @param call
+     * @param res
+     * @param message
+     */
+    public void retPath(PluginCall call, String res, String message) {
+        JSObject ret = new JSObject();
+        if (message != null) {
+            ret.put("message", message);
+            Log.v(TAG, "*** ERROR " + message);
+            call.reject(message);
+            return;
+        }
+        if (res != null) {
+            ret.put("path", res);
+            call.resolve(ret);
+            return;
+        } else {
+            call.resolve();
+        }
+    }
 }

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/Database.java

@@ -58,6 +58,7 @@ public class Database {
     private Dictionary<Integer, JSONObject> _vUpgObject = new Hashtable<>();
     private ImportFromJson fromJson = new ImportFromJson();
     private ExportToJson toJson = new ExportToJson();
+    private Boolean ncDB = false;
 
     public Database(
         Context context,
@@ -75,7 +76,12 @@ public class Database {
         this._version = version;
         this._vUpgObject = vUpgObject;
         this._sharedPreferences = sharedPreferences;
-        this._file = this._context.getDatabasePath(dbName);
+        if (dbName.contains("/") && dbName.endsWith("SQLite.db")) {
+            this.ncDB = true;
+            this._file = new File(dbName);
+        } else {
+            this._file = this._context.getDatabasePath(dbName);
+        }
         this._globVar = new GlobalSQLite();
         this._uSqlite = new UtilsSQLite();
         this._uCipher = new UtilsSQLCipher();
@@ -104,12 +110,20 @@ public class Database {
 
     /**
      * isOpen Method
-     * @return database open status
+     * @return database status
      */
     public Boolean isOpen() {
         return _isOpen;
     }
 
+    /**
+     * isNCDB Method
+     * @return non-conformed database status
+     */
+    public Boolean isNCDB() {
+        return ncDB;
+    }
+
     /**
      * Open method
      * @return open status
@@ -128,7 +142,11 @@ public class Database {
             }
         }
         try {
-            _db = SQLiteDatabase.openOrCreateDatabase(_file, password, null);
+            if (!isNCDB()) {
+                _db = SQLiteDatabase.openOrCreateDatabase(_file, password, null);
+            } else {
+                _db = SQLiteDatabase.openDatabase(String.valueOf(_file), "", null, SQLiteDatabase.OPEN_READONLY);
+            }
             if (_db != null) {
                 if (_db.isOpen()) {
                     // set the Foreign Key Pragma ON
@@ -141,60 +159,62 @@ public class Database {
                         _db = null;
                         throw new Exception(msg);
                     }
-                    try {
-                        curVersion = _db.getVersion();
-                        if (curVersion == 0) {
-                            _db.setVersion(1);
+                    if (!isNCDB()) {
+                        try {
                             curVersion = _db.getVersion();
+                            if (curVersion == 0) {
+                                _db.setVersion(1);
+                                curVersion = _db.getVersion();
+                            }
+                        } catch (IllegalStateException e) {
+                            String msg = "Failed in get/setVersion " + e.getMessage();
+                            Log.v(TAG, msg);
+                            close();
+                            _db = null;
+                            throw new Exception(msg);
+                        } catch (SQLiteException e) {
+                            String msg = "Failed in setVersion " + e.getMessage();
+                            Log.v(TAG, msg);
+                            close();
+                            _db = null;
+                            throw new Exception(msg);
                         }
-                    } catch (IllegalStateException e) {
-                        String msg = "Failed in get/setVersion " + e.getMessage();
-                        Log.v(TAG, msg);
-                        close();
-                        _db = null;
-                        throw new Exception(msg);
-                    } catch (SQLiteException e) {
-                        String msg = "Failed in setVersion " + e.getMessage();
-                        Log.v(TAG, msg);
-                        close();
-                        _db = null;
-                        throw new Exception(msg);
-                    }
-                    if (_version > curVersion) {
-                        if (_vUpgObject.size() > 0) {
-                            try {
-                                _uUpg.onUpgrade(this, _context, _dbName, _vUpgObject, curVersion, _version);
-                                boolean ret = _uFile.deleteBackupDB(_context, _dbName);
-                                if (!ret) {
-                                    String msg = "Failed in deleteBackupDB backup-\" + _dbName";
+                        if (_version > curVersion) {
+                            if (_vUpgObject.size() > 0) {
+                                try {
+                                    _uUpg.onUpgrade(this, _context, _dbName, _vUpgObject, curVersion, _version);
+                                    boolean ret = _uFile.deleteBackupDB(_context, _dbName);
+                                    if (!ret) {
+                                        String msg = "Failed in deleteBackupDB backup-\" + _dbName";
+                                        Log.v(TAG, msg);
+                                        close();
+                                        _db = null;
+                                        throw new Exception(msg);
+                                    }
+                                } catch (Exception e) {
+                                    // restore DB
+                                    boolean ret = _uFile.restoreDatabase(_context, _dbName);
+                                    String msg = e.getMessage();
+                                    if (!ret) msg += "Failed in restoreDatabase " + _dbName;
                                     Log.v(TAG, msg);
                                     close();
                                     _db = null;
                                     throw new Exception(msg);
                                 }
-                            } catch (Exception e) {
-                                // restore DB
-                                boolean ret = _uFile.restoreDatabase(_context, _dbName);
-                                String msg = e.getMessage();
-                                if (!ret) msg += "Failed in restoreDatabase " + _dbName;
-                                Log.v(TAG, msg);
-                                close();
-                                _db = null;
-                                throw new Exception(msg);
-                            }
-                        } else {
-                            try {
-                                _db.setVersion(_version);
-                            } catch (Exception e) {
-                                String msg = e.getMessage() + "Failed in setting version " + _version;
-                                close();
-                                _db = null;
-                                throw new Exception(msg);
+                            } else {
+                                try {
+                                    _db.setVersion(_version);
+                                } catch (Exception e) {
+                                    String msg = e.getMessage() + "Failed in setting version " + _version;
+                                    close();
+                                    _db = null;
+                                    throw new Exception(msg);
+                                }
                             }
                         }
+                        _isOpen = true;
+                        return;
                     }
-                    _isOpen = true;
-                    return;
                 } else {
                     _isOpen = false;
                     _db = null;

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/ImportExportJson/JsonIndex.java

@@ -6,6 +6,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import org.json.JSONException;
 import org.json.JSONObject;
 
@@ -40,8 +41,8 @@ public class JsonIndex {
     }
 
     public void setMode(String newMode) {
-        if (newMode.equals("UNIQUE")) {
-            this.mode = newMode;
+        if (newMode.equalsIgnoreCase("UNIQUE")) {
+            this.mode = newMode.toUpperCase();
         }
     }
 
@@ -49,7 +50,7 @@ public class JsonIndex {
         ArrayList<String> retArray = new ArrayList<String>();
         if (getName().length() > 0) retArray.add("name");
         if (getValue().length() > 0) retArray.add("value");
-        if (getMode().length() > 0 && getMode().equals("UNIQUE")) retArray.add("mode");
+        if (getMode().length() > 0 && getMode().equalsIgnoreCase("UNIQUE")) retArray.add("mode");
         return retArray;
     }
 
@@ -76,7 +77,7 @@ public class JsonIndex {
                     }
                 }
                 if (key.equals("mode")) {
-                    if (!(objValue instanceof String) || !(objValue.equals("UNIQUE"))) {
+                    if (!(objValue instanceof String) || !(((String) objValue).equalsIgnoreCase("UNIQUE"))) {
                         return false;
                     } else {
                         mode = (String) objValue;

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/UtilsFile.java

@@ -24,6 +24,15 @@ public class UtilsFile {
         return file.exists();
     }
 
+    public Boolean isPathExists(String filePath) {
+        File file = new File(filePath);
+        if (file.exists()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
     public String[] getListOfFiles(Context context) {
         String[] files = context.databaseList();
         List<String> dbs = new ArrayList<>();

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/UtilsNCDatabase.java

@@ -0,0 +1,26 @@
+package com.getcapacitor.community.database.sqlite.SQLite;
+
+import android.content.Context;
+import java.io.File;
+
+public class UtilsNCDatabase {
+
+    private static final String TAG = UtilsNCDatabase.class.getName();
+    private UtilsMigrate uMigrate = new UtilsMigrate();
+
+    public String getNCDatabasePath(Context context, String folderPath, String database) throws Exception {
+        String pathDB = new File(context.getFilesDir().getParentFile(), "databases").getAbsolutePath();
+        File dirDB = new File(pathDB);
+        if (!dirDB.isDirectory()) {
+            dirDB.mkdir();
+        }
+        String pathFiles = uMigrate.getFolder(context, folderPath);
+        // check if the path exists
+        File dir = new File(pathFiles);
+        if (!dir.exists()) {
+            throw new Exception("Folder " + dir + " does not exist");
+        }
+        String databasePath = pathFiles.concat("/").concat(database);
+        return databasePath;
+    }
+}