@capacitor-community/sqlite 3.4.3-1 → 3.4.3

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

@@ -18,6 +18,7 @@ import com.getcapacitor.JSObject;
 import com.getcapacitor.community.database.sqlite.SQLite.GlobalSQLite;
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.ExportToJson;
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.ImportFromJson;
+import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.JsonIndex;
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.JsonSQLite;
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.UtilsJson;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsSQLCipher;
@@ -34,6 +35,7 @@ import net.sqlcipher.Cursor;
 import net.sqlcipher.database.SQLiteDatabase;
 import net.sqlcipher.database.SQLiteException;
 import org.json.JSONArray;
+import org.json.JSONException;
 import org.json.JSONObject;
 
 public class Database {
@@ -116,6 +118,7 @@ public class Database {
 
     /**
      * isOpen Method
+     *
      * @return database status
      */
     public Boolean isOpen() {
@@ -124,6 +127,7 @@ public class Database {
 
     /**
      * isNCDB Method
+     *
      * @return non-conformed database status
      */
     public Boolean isNCDB() {
@@ -132,6 +136,7 @@ public class Database {
 
     /**
      * GetUrl method
+     *
      * @return database url
      */
     public String getUrl() {
@@ -141,6 +146,7 @@ public class Database {
 
     /**
      * Open method
+     *
      * @return open status
      */
     public void open() throws Exception {
@@ -257,6 +263,7 @@ public class Database {
 
     /**
      * Close Method
+     *
      * @return close status
      */
 
@@ -293,6 +300,7 @@ public class Database {
 
     /**
      * IsDBExists Method
+     *
      * @return the existence of the database on folder
      */
     public boolean isDBExists() {
@@ -306,6 +314,7 @@ public class Database {
     /**
      * Execute Method
      * Execute an Array of SQL Statements
+     *
      * @param statements Array of Strings
      * @return
      */
@@ -319,7 +328,13 @@ public class Database {
                 if (transaction) _db.beginTransaction();
                 for (String cmd : statements) {
                     if (!cmd.endsWith(";")) cmd += ";";
-                    _db.execSQL(cmd);
+                    String nCmd = cmd;
+                    String trimCmd = nCmd.trim().substring(0, 11).toUpperCase();
+                    if (trimCmd.equals("DELETE FROM") && nCmd.toLowerCase().contains("WHERE".toLowerCase())) {
+                        String whereStmt = nCmd.trim();
+                        nCmd = deleteSQL(this, whereStmt, new ArrayList<Object>());
+                    }
+                    _db.execSQL(nCmd);
                 }
                 changes = _uSqlite.dbChanges(_db) - initChanges;
                 if (changes != -1) {
@@ -340,6 +355,7 @@ public class Database {
     /**
      * ExecuteSet Method
      * Execute a Set of SQL Statements
+     *
      * @param set JSArray of statements
      * @return
      */
@@ -368,11 +384,11 @@ public class Database {
                             for (int k = 0; k < valsJson.length(); k++) {
                                 vals.add(valsJson.get(k));
                             }
-                            lastId = prepareSQL(statement, vals);
+                            lastId = prepareSQL(statement, vals, false);
                             if (lastId == -1) break;
                         }
                     } else {
-                        lastId = prepareSQL(statement, values);
+                        lastId = prepareSQL(statement, values, false);
                     }
                     if (lastId == -1) break;
                 }
@@ -399,6 +415,7 @@ public class Database {
     /**
      * InTransaction Method
      * Check if a transaction is still running
+     *
      * @return
      */
     public boolean inTransaction() {
@@ -407,8 +424,9 @@ public class Database {
 
     /**
      * RunSQL Method
+     *
      * @param statement a raw SQL statement
-     * @param values Array of Strings to bind to the statement
+     * @param values    Array of Strings to bind to the statement
      * @return
      */
     public JSObject runSQL(String statement, ArrayList<Object> values, Boolean... others) throws Exception {
@@ -420,7 +438,7 @@ public class Database {
             if (_db != null && _db.isOpen() && statement.length() > 0) {
                 Integer initChanges = _uSqlite.dbChanges(_db);
                 if (transaction) _db.beginTransaction();
-                lastId = prepareSQL(statement, values);
+                lastId = prepareSQL(statement, values, false);
                 if (lastId != -1 && transaction) _db.setTransactionSuccessful();
                 changes = _uSqlite.dbChanges(_db) - initChanges;
                 retObj.put("changes", changes);
@@ -438,15 +456,20 @@ public class Database {
 
     /**
      * PrepareSQL Method
+     *
      * @param statement
      * @param values
      * @return
      */
-    public long prepareSQL(String statement, ArrayList<Object> values) throws Exception {
+    public long prepareSQL(String statement, ArrayList<Object> values, Boolean fromJson) throws Exception {
         String stmtType = statement.replaceAll("\n", "").trim().substring(0, 6).toUpperCase();
         SupportSQLiteStatement stmt = null;
+        String sqlStmt = statement;
         try {
-            stmt = _db.compileStatement(statement);
+            if (!fromJson && stmtType.equals("DELETE")) {
+                sqlStmt = deleteSQL(this, statement, values);
+            }
+            stmt = _db.compileStatement(sqlStmt);
             if (values != null && values.size() > 0) {
                 Object[] valObj = new Object[values.size()];
                 for (int i = 0; i < values.size(); i++) {
@@ -481,9 +504,160 @@ public class Database {
         }
     }
 
+    /**
+     * DeleteSQL method
+     *
+     * @param mDB
+     * @param statement
+     * @param values
+     * @return
+     * @throws Exception
+     */
+    public String deleteSQL(Database mDB, String statement, ArrayList<Object> values) throws Exception {
+        String sqlStmt = statement;
+        try {
+            Boolean isLast = _uJson.isLastModified(mDB);
+            if (isLast) {
+                // Replace DELETE by UPDATE and set sql_deleted to 1
+                Integer wIdx = statement.toUpperCase().indexOf("WHERE");
+                String preStmt = statement.substring(0, wIdx - 1);
+                String clauseStmt = statement.substring(wIdx, statement.length());
+                String tableName = preStmt.substring(("DELETE FROM").length()).trim();
+                sqlStmt = "UPDATE " + tableName + " SET sql_deleted = 1 " + clauseStmt;
+                // Find REFERENCES if any and update the sql_deleted column
+                findReferencesAndUpdate(mDB, tableName, clauseStmt, values);
+            }
+            return sqlStmt;
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * FindReferencesAndUpdate method
+     *
+     * @param mDB
+     * @param tableName
+     * @param whereStmt
+     * @param values
+     * @throws Exception
+     */
+    public void findReferencesAndUpdate(Database mDB, String tableName, String whereStmt, ArrayList<Object> values) throws Exception {
+        try {
+            JSArray references = getReferences(mDB, tableName);
+            for (int j = 0; j < references.length(); j++) {
+                // get the tableName of the reference
+                String refTable = getReferenceTableName(references.getJSONObject(j).getString("sql"));
+                if (refTable.length() <= 0) {
+                    continue;
+                }
+                // get the columnName
+                String colName = getReferenceColumnName(references.getJSONObject(j).getString("sql"));
+                if (refTable.length() <= 0) {
+                    continue;
+                }
+                // update the where clause
+                String uWhereStmt = updateWhere(whereStmt, colName);
+
+                if (uWhereStmt.length() <= 0) {
+                    continue;
+                }
+                //update sql_deleted for this reference
+                String stmt = "UPDATE " + refTable + " SET sql_deleted = 1 " + uWhereStmt;
+                long lastId = prepareSQL(stmt, values, false);
+                if (lastId == -1) {
+                    String msg = "UPDATE sql_deleted failed for references " + "table: " + refTable + ";";
+                    throw new Exception(msg);
+                }
+            }
+            return;
+        } catch (JSONException e) {
+            throw new Exception(e.getMessage());
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * GetReferenceTableName method
+     *
+     * @param refValue
+     * @return
+     */
+    public String getReferenceTableName(String refValue) {
+        String tableName = "";
+        if (refValue.length() > 0 && refValue.substring(0, 12).equalsIgnoreCase("CREATE TABLE")) {
+            Integer oPar = refValue.indexOf("(");
+            tableName = refValue.substring(13, oPar).trim();
+        }
+
+        return tableName;
+    }
+
+    /**
+     * GetReferenceColumnName method
+     *
+     * @param refValue
+     * @return
+     */
+    public String getReferenceColumnName(String refValue) {
+        String colName = "";
+        if (refValue.length() > 0) {
+            Integer index = refValue.toLowerCase().indexOf("FOREIGN KEY".toLowerCase());
+            String stmt = refValue.substring(index + 12);
+            Integer oPar = stmt.indexOf("(");
+            Integer cPar = stmt.indexOf(")");
+            colName = stmt.substring(oPar + 1, cPar).trim();
+        }
+        return colName;
+    }
+
+    /**
+     * UpdateWhere method
+     *
+     * @param whStmt
+     * @param colName
+     * @return
+     */
+    public String updateWhere(String whStmt, String colName) {
+        String whereStmt = "";
+        if (whStmt.length() > 0) {
+            Integer index = whStmt.toLowerCase().indexOf("WHERE".toLowerCase());
+            String stmt = whStmt.substring(index + 6);
+            Integer fEqual = stmt.indexOf("=");
+            String whereColName = stmt.substring(0, fEqual).trim();
+            whereStmt = whStmt.replaceFirst(whereColName, colName);
+        }
+        return whereStmt;
+    }
+
+    /**
+     * GetReferences method
+     *
+     * @param mDB
+     * @param tableName
+     * @return
+     * @throws Exception
+     */
+    public JSArray getReferences(Database mDB, String tableName) throws Exception {
+        String sqlStmt =
+            "SELECT sql FROM sqlite_master " +
+            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "sql LIKE('%" +
+            tableName +
+            "%') AND sql LIKE('%ON DELETE%');";
+        try {
+            JSArray references = mDB.selectSQL(sqlStmt, new ArrayList<Object>());
+            return references;
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
     /**
      * SelectSQL Method
      * Query a raw sql statement with or without binding values
+     *
      * @param statement
      * @param values
      * @return
@@ -534,6 +708,7 @@ public class Database {
     /**
      * GetTableNames Method
      * Returned a JSArray of table's name
+     *
      * @return
      * @throws Exception
      */
@@ -553,6 +728,7 @@ public class Database {
     /**
      * DeleteDB Method
      * Delete the database file
+     *
      * @param dbName
      * @return
      */
@@ -584,6 +760,7 @@ public class Database {
     /**
      * CreateSyncTable Method
      * create the synchronization table
+     *
      * @return
      */
     public JSObject createSyncTable() throws Exception {
@@ -618,6 +795,7 @@ public class Database {
     /**
      * SetSyncDate Method
      * Set the synchronization date
+     *
      * @param syncDate
      * @return
      */
@@ -643,6 +821,13 @@ public class Database {
         }
     }
 
+    /**
+     * GetSyncDate method
+     * get the synchronization date
+     *
+     * @return
+     * @throws Exception
+     */
     public Long getSyncDate() throws Exception {
         long syncDate = 0;
         try {
@@ -659,6 +844,7 @@ public class Database {
 
     /**
      * Import from Json object
+     *
      * @param jsonSQL
      * @return
      */
@@ -666,6 +852,9 @@ public class Database {
         JSObject retObj = new JSObject();
         int changes = Integer.valueOf(0);
         try {
+            // set Foreign Keys OFF
+            _db.setForeignKeyConstraintsEnabled(false);
+
             if (jsonSQL.getTables().size() > 0) {
                 // create the database schema
                 changes = fromJson.createDatabaseSchema(this, jsonSQL);
@@ -676,6 +865,9 @@ public class Database {
             if (jsonSQL.getViews().size() > 0) {
                 changes += fromJson.createViews(this, jsonSQL.getViews());
             }
+            // set Foreign Keys ON
+            _db.setForeignKeyConstraintsEnabled(true);
+
             retObj.put("changes", changes);
             return retObj;
         } catch (Exception e) {
@@ -685,6 +877,7 @@ public class Database {
 
     /**
      * Export to JSON Object
+     *
      * @param mode
      * @return
      */
@@ -696,6 +889,11 @@ public class Database {
         inJson.setEncrypted(_encrypted);
         inJson.setMode(mode);
         try {
+            // set the last export date
+            Date date = new Date();
+            long syncTime = date.getTime() / 1000L;
+            toJson.setLastExportDate(this, syncTime);
+            // launch the export process
             JsonSQLite retJson = toJson.createExportObject(this, inJson);
             //        retJson.print();
             ArrayList<String> keys = retJson.getKeys();
@@ -717,4 +915,19 @@ public class Database {
             throw new Exception(e.getMessage());
         } finally {}
     }
+
+    /**
+     * Delete exported rows
+     *
+     * @throws Exception
+     */
+    public void deleteExportedRows() throws Exception {
+        try {
+            toJson.delExportedRows(this);
+            return;
+        } catch (Exception e) {
+            Log.e(TAG, "Error: exportToJson " + e.getMessage());
+            throw new Exception(e.getMessage());
+        }
+    }
 }

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

@@ -4,8 +4,10 @@ import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.community.database.sqlite.NotificationCenter;
 import com.getcapacitor.community.database.sqlite.SQLite.Database;
+import com.getcapacitor.community.database.sqlite.SQLite.UtilsDrop;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsSQLite;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -17,6 +19,7 @@ public class ExportToJson {
     private static final String TAG = ImportFromJson.class.getName();
     private UtilsJson uJson = new UtilsJson();
     private UtilsSQLite uSqlite = new UtilsSQLite();
+    private UtilsDrop _uDrop = new UtilsDrop();
 
     /**
      * Notify progress export event
@@ -32,6 +35,96 @@ public class ExportToJson {
         NotificationCenter.defaultCenter().postNotification("exportJsonProgress", info);
     }
 
+    /**
+     * GetLastExportDate method
+     * get the last export date
+     *
+     * @return
+     * @throws Exception
+     */
+    public Long getLastExportDate(Database mDb) throws Exception {
+        long lastExportDate = -1;
+        String stmt = "SELECT sync_date FROM sync_table WHERE id = 2;";
+        JSArray retQuery = new JSArray();
+
+        try {
+            boolean isSyncTable = uJson.isTableExists(mDb, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("GetSyncDate: No sync_table available");
+            }
+            retQuery = mDb.selectSQL(stmt, new ArrayList<Object>());
+            List<JSObject> lQuery = retQuery.toList();
+            if (lQuery.size() == 1) {
+                long syncDate = lQuery.get(0).getLong("sync_date");
+                if (syncDate > 0) lastExportDate = syncDate;
+            }
+        } catch (Exception e) {
+            throw new Exception("GetSyncDate: " + e.getMessage());
+        } finally {
+            return lastExportDate;
+        }
+    }
+
+    public void setLastExportDate(Database mDb, Long sTime) throws Exception {
+        try {
+            boolean isSyncTable = uJson.isTableExists(mDb, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("SetLastExportDate: No sync_table available");
+            }
+            String stmt = "";
+            Long lastExportDate = getLastExportDate(mDb);
+            if (lastExportDate > 0) {
+                stmt = "UPDATE sync_table SET sync_date = " + sTime + " WHERE id = 2;";
+            } else {
+                stmt = "INSERT INTO sync_table (sync_date) VALUES (" + sTime + ");";
+            }
+            long lastId = mDb.prepareSQL(stmt, new ArrayList<>(), false);
+            if (lastId < 0) {
+                throw new Exception("SetLastExportDate: lastId < 0");
+            }
+            return;
+        } catch (Exception e) {
+            throw new Exception("SetLastExportDate: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Delete Exported Rows
+     * @throws Exception
+     */
+    public void delExportedRows(Database mDb) throws Exception {
+        try {
+            // check if 'sync_table' exists
+            boolean isSyncTable = uJson.isTableExists(mDb, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("DelExportedRows: No sync_table available");
+            }
+            // get the last export date
+            long lastExportDate = getLastExportDate(mDb);
+            if (lastExportDate < 0) {
+                throw new Exception("DelExportedRows: No last exported date available");
+            }
+            // get the table' name list
+            List<String> tables = _uDrop.getTablesNames(mDb);
+            if (tables.size() == 0) {
+                throw new Exception("DelExportedRows: No table's names returned");
+            }
+            // Loop through the tables
+            for (String table : tables) {
+                long lastId = -1;
+                // define the delete statement
+                String delStmt = "DELETE FROM " + table + " WHERE sql_deleted = 1 " + "AND last_modified < " + lastExportDate + ";";
+                lastId = mDb.prepareSQL(delStmt, new ArrayList<>(), true);
+                if (lastId < 0) {
+                    throw new Exception("SetLastExportDate: lastId < 0");
+                }
+            }
+            return;
+        } catch (Exception e) {
+            throw new Exception("DelExportedRows: " + e.getMessage());
+        }
+    }
+
     /**
      * Create Export Json Object from Database (Schema, Data)
      * @param db
@@ -467,7 +560,7 @@ public class ExportToJson {
                 if (modTables.getString(tableName).equals("Create")) {
                     query = "SELECT * FROM " + tableName + ";";
                 } else {
-                    query = "SELECT * FROM " + tableName + " WHERE last_modified > " + syncDate + ";";
+                    query = "SELECT * FROM " + tableName + " WHERE last_modified >= " + syncDate + ";";
                 }
                 ArrayList<ArrayList<Object>> values = uJson.getValues(mDb, query, tableName);
 
@@ -544,9 +637,13 @@ public class ExportToJson {
      */
     public Long getSyncDate(Database mDb) throws Exception {
         long ret = -1;
-        String stmt = "SELECT sync_date FROM sync_table;";
+        String stmt = "SELECT sync_date FROM sync_table WHERE id = 1;";
         JSArray retQuery = new JSArray();
         try {
+            boolean isSyncTable = uJson.isTableExists(mDb, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("No sync_table available");
+            }
             retQuery = mDb.selectSQL(stmt, new ArrayList<Object>());
             List<JSObject> lQuery = retQuery.toList();
             if (lQuery.size() == 1) {
@@ -586,7 +683,7 @@ public class ExportToJson {
                 if (lQuery.size() != 1) break;
                 long totalCount = lQuery.get(0).getLong("count");
                 // get total count of modified since last sync
-                stmt = "SELECT count(*) AS count FROM " + tableName + " WHERE last_modified > " + syncDate + ";";
+                stmt = "SELECT count(*) AS count FROM " + tableName + " WHERE last_modified >= " + syncDate + ";";
                 retQuery = mDb.selectSQL(stmt, new ArrayList<Object>());
                 lQuery = retQuery.toList();
                 if (lQuery.size() != 1) break;

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

@@ -48,15 +48,6 @@ public class ImportFromJson {
         db.getDb().setVersion(version);
 
         if (jsonSQL.getMode().equals("full")) {
-            // Set Foreign Key OFF
-            try {
-                db.getDb().setForeignKeyConstraintsEnabled(false);
-            } catch (IllegalStateException e) {
-                String msg = "CreateDatabaseSchema: ";
-                msg += "setForeignKeyConstraintsEnabled failed ";
-                msg += e.getMessage();
-                throw new Exception(msg);
-            }
             try {
                 _uDrop.dropAll(db);
             } catch (Exception e) {
@@ -64,15 +55,6 @@ public class ImportFromJson {
                 throw new Exception(msg);
             }
         }
-        // Set Foreign Key ON
-        try {
-            db.getDb().setForeignKeyConstraintsEnabled(true);
-        } catch (IllegalStateException e) {
-            String msg = "CreateDatabaseSchema: ";
-            msg += "setForeignKeyConstraintsEnabled failed ";
-            msg += e.getMessage();
-            throw new Exception(msg);
-        }
         try {
             changes = createSchema(db, jsonSQL);
             notifyImportProgressEvent("Schema creation completed changes: " + changes);
@@ -406,7 +388,10 @@ public class ImportFromJson {
                 isRun = checkUpdate(mDb, stmt, row, tableName, tColNames, tColTypes);
                 if (isRun) {
                     // load the values
-                    long lastId = mDb.prepareSQL(stmt, row);
+                    if (stmt.substring(0, 6).toUpperCase().equals("DELETE")) {
+                        row = new ArrayList<>();
+                    }
+                    long lastId = mDb.prepareSQL(stmt, row, true);
                     if (lastId < 0) {
                         throw new Exception("CreateTableData: lastId < 0");
                     }
@@ -549,23 +534,41 @@ public class ImportFromJson {
                     .append(");")
                     .toString();
         } else {
-            // Update
-            String setString = _uJson.setNameForUpdate(tColNames);
-            if (setString.length() == 0) {
-                throw new Exception(msg + j + "setString is empty");
+            Boolean isUpdate = true;
+            Integer idxDelete = tColNames.indexOf("sql_deleted");
+            if (idxDelete >= 0) {
+                if (row.get(idxDelete).equals(1)) {
+                    // Delete
+                    isUpdate = false;
+                    stmt =
+                        new StringBuilder("DELETE FROM ")
+                            .append(tableName)
+                            .append(" WHERE ")
+                            .append(tColNames.get(0))
+                            .append(" = ")
+                            .append(row.get(0))
+                            .toString();
+                }
             }
-            Object key = tColNames.get(0);
-            StringBuilder sbQuery = new StringBuilder("UPDATE ")
-                .append(tableName)
-                .append(" SET ")
-                .append(setString)
-                .append(" WHERE ")
-                .append(tColNames.get(0))
-                .append(" = ");
+            if (isUpdate) {
+                // Update
+                String setString = _uJson.setNameForUpdate(tColNames);
+                if (setString.length() == 0) {
+                    throw new Exception(msg + j + "setString is empty");
+                }
+                Object key = tColNames.get(0);
+                StringBuilder sbQuery = new StringBuilder("UPDATE ")
+                    .append(tableName)
+                    .append(" SET ")
+                    .append(setString)
+                    .append(" WHERE ")
+                    .append(tColNames.get(0))
+                    .append(" = ");
 
-            if (key instanceof Integer) sbQuery.append(row.get(0)).append(";");
-            if (key instanceof String) sbQuery.append("'").append(row.get(0)).append("';");
-            stmt = sbQuery.toString();
+                if (key instanceof Integer) sbQuery.append(row.get(0)).append(";");
+                if (key instanceof String) sbQuery.append("'").append(row.get(0)).append("';");
+                stmt = sbQuery.toString();
+            }
         }
         return stmt;
     }