@capacitor-community/sqlite 3.5.2-dev2 → 3.5.2

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

@@ -26,6 +26,8 @@ import com.getcapacitor.community.database.sqlite.SQLite.UtilsSQLite;
 import java.io.File;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Dictionary;
 import java.util.Hashtable;
@@ -545,27 +547,59 @@ public class Database {
      */
     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++) {
+            ArrayList<String> references = getReferences(mDB, tableName);
+            if (references.size() == 0) {
+                return;
+            }
+            String tableNameWithRefs = references.get(references.size() - 1);
+            references.remove(references.size() - 1);
+            for (String refe : references) {
                 // get the tableName of the reference
-                String refTable = getReferenceTableName(references.getJSONObject(j).getString("sql"));
+                String refTable = getReferenceTableName(refe);
                 if (refTable.length() <= 0) {
                     continue;
                 }
-                // get the columnName
-                String colName = getReferenceColumnName(references.getJSONObject(j).getString("sql"));
-                if (refTable.length() <= 0) {
+                // get the withRefsNames
+                String[] withRefsNames = getWithRefsColumnName(refe);
+                if (withRefsNames.length <= 0) {
+                    continue;
+                }
+                // get the columnNames
+                String[] colNames = getReferencedColumnName(refe);
+                if (colNames.length <= 0) {
                     continue;
                 }
                 // update the where clause
-                String uWhereStmt = updateWhere(whereStmt, colName);
+                String uWhereStmt = updateWhere(whereStmt, withRefsNames, colNames);
 
                 if (uWhereStmt.length() <= 0) {
                     continue;
                 }
+                String updTableName = tableNameWithRefs;
+                String[] updColNames = colNames;
+                if (tableNameWithRefs.equals(tableName)) {
+                    updTableName = refTable;
+                    updColNames = withRefsNames;
+                }
                 //update sql_deleted for this reference
-                String stmt = "UPDATE " + refTable + " SET sql_deleted = 1 " + uWhereStmt;
-                long lastId = prepareSQL(stmt, values, false);
+                String stmt = "UPDATE " + updTableName + " SET sql_deleted = 1 " + uWhereStmt;
+                ArrayList<Object> selValues = new ArrayList<Object>();
+                if (values != null && values.size() > 0) {
+                    String[] arrVal = whereStmt.split("\\?");
+                    if (arrVal[arrVal.length - 1].equals(";")) {
+                        Arrays.copyOf(arrVal, arrVal.length - 1);
+                    }
+                    for (int j = 0; j < arrVal.length; j++) {
+                        for (String updVal : updColNames) {
+                            int idxVal = arrVal[j].indexOf(updVal);
+                            if (idxVal > -1) {
+                                selValues.add(values.get(j));
+                            }
+                        }
+                    }
+                }
+
+                long lastId = prepareSQL(stmt, selValues, false);
                 if (lastId == -1) {
                     String msg = "UPDATE sql_deleted failed for references " + "table: " + refTable + ";";
                     throw new Exception(msg);
@@ -587,47 +621,104 @@ public class Database {
      */
     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();
-        }
+        if (refValue.length() > 0) {
+            String[] arr = refValue.split("(?i)REFERENCES", -1);
+            if (arr.length == 2) {
+                int oPar = arr[1].indexOf("(");
 
+                tableName = arr[1].substring(0, oPar).trim();
+            }
+        }
         return tableName;
     }
 
     /**
-     * GetReferenceColumnName method
+     * GetWithRefsColumnName
+     *
+     * @param refValue
+     * @return
+     */
+    public String[] getWithRefsColumnName(String refValue) {
+        String[] colNames = new String[0];
+        if (refValue.length() > 0) {
+            String[] arr = refValue.split("(?i)REFERENCES", -1);
+            if (arr.length == 2) {
+                int oPar = arr[0].indexOf("(");
+                int cPar = arr[0].indexOf(")");
+                String colStr = arr[0].substring(oPar + 1, cPar).trim();
+                colNames = colStr.split(",");
+            }
+        }
+        return colNames;
+    }
+
+    /**
+     * GetReferencedColumnName method
      *
      * @param refValue
      * @return
      */
-    public String getReferenceColumnName(String refValue) {
-        String colName = "";
+    public String[] getReferencedColumnName(String refValue) {
+        String[] colNames = new String[0];
         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();
+            String[] arr = refValue.split("(?i)REFERENCES", -1);
+            if (arr.length == 2) {
+                int oPar = arr[1].indexOf("(");
+                int cPar = arr[1].indexOf(")");
+                String colStr = arr[1].substring(oPar + 1, cPar).trim();
+                colNames = colStr.split(",");
+            }
         }
-        return colName;
+        return colNames;
     }
 
     /**
      * UpdateWhere method
      *
      * @param whStmt
-     * @param colName
+     * @param withRefsNames
+     * @param colNames
      * @return
      */
-    public String updateWhere(String whStmt, String colName) {
+    public String updateWhere(String whStmt, String[] withRefsNames, String[] colNames) {
         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);
+            if (withRefsNames.length == colNames.length) {
+                for (int i = 0; i < withRefsNames.length; i++) {
+                    String colType = "withRefsNames";
+                    int idx = stmt.indexOf(withRefsNames[i]);
+                    if (idx == -1) {
+                        idx = stmt.indexOf(colNames[i]);
+                        colType = "colNames";
+                    }
+                    if (idx > -1) {
+                        String valStr = "";
+                        int fEqual = stmt.indexOf("=", idx);
+                        if (fEqual > -1) {
+                            int iAnd = stmt.indexOf("AND", fEqual);
+                            int ilAnd = stmt.indexOf("and", fEqual);
+                            if (iAnd > -1) {
+                                valStr = (stmt.substring(fEqual + 1, iAnd - 1)).trim();
+                            } else if (ilAnd > -1) {
+                                valStr = (stmt.substring(fEqual + 1, ilAnd - 1)).trim();
+                            } else {
+                                valStr = (stmt.substring(fEqual + 1)).trim();
+                            }
+                            if (i > 0) {
+                                whereStmt += " AND ";
+                            }
+                            if (colType.equals("withRefsNames")) {
+                                whereStmt += colNames[i] + " = " + valStr;
+                            } else {
+                                whereStmt += withRefsNames[i] + " = " + valStr;
+                            }
+                        }
+                    }
+                }
+                whereStmt = "WHERE " + whereStmt;
+            }
         }
         return whereStmt;
     }
@@ -640,21 +731,49 @@ public class Database {
      * @return
      * @throws Exception
      */
-    public JSArray getReferences(Database mDB, String tableName) throws Exception {
+    public ArrayList<String> getReferences(Database mDB, String tableName) throws Exception {
         String sqlStmt =
             "SELECT sql FROM sqlite_master " +
-            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
             "sql LIKE('%" +
             tableName +
             "%') AND sql LIKE('%ON DELETE%');";
         try {
             JSArray references = mDB.selectSQL(sqlStmt, new ArrayList<Object>());
-            return references;
+            ArrayList<String> retRefs = new ArrayList<String>();
+            if (references.length() > 0) {
+                retRefs = getRefs(references.getJSONObject(0).getString("sql"));
+            }
+            return retRefs;
         } catch (Exception e) {
             throw new Exception(e.getMessage());
         }
     }
 
+    /**
+     * GetRefs
+     *
+     * @param str
+     * @return
+     * @throws Exception
+     */
+    private ArrayList<String> getRefs(String str) throws Exception {
+        ArrayList<String> retRefs = new ArrayList<String>();
+        String[] arrFor = str.split("(?i)FOREIGN KEY", -1);
+        // Loop through Foreign Keys
+        for (int i = 1; i < arrFor.length; i++) {
+            retRefs.add((arrFor[i].split("(?i)ON DELETE", -1))[0].trim());
+        }
+        // find table name with references
+        if (str.substring(0, 12).toLowerCase().equals("CREATE TABLE".toLowerCase())) {
+            int oPar = str.indexOf("(");
+            String tableName = str.substring(13, oPar).trim();
+            retRefs.add(tableName);
+        }
+
+        return retRefs;
+    }
+
     /**
      * SelectSQL Method
      * Query a raw sql statement with or without binding values

package/electron/dist/plugin.js

@@ -342,7 +342,9 @@ class UtilsSQLite {
                     if (trimStmt === 'DELETE FROM' &&
                         stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
                         const whereStmt = `${stmt.trim()};`;
+                        console.log(`in utilsSQLite execute whereStmt ${whereStmt}`);
                         const rStmt = await this.deleteSQL(mDB, whereStmt, []);
+                        console.log(`in utilsSQLite execute rStmt ${rStmt}`);
                         resArr.push(rStmt);
                     }
                     else {
@@ -351,12 +353,14 @@ class UtilsSQLite {
                 }
                 sqlStmt = resArr.join(';');
             }
+            console.log(`in utilsSQLite execute sqlStmt ${sqlStmt}`);
             await this.execDB(mDB, sqlStmt);
             changes = (await this.dbChanges(mDB)) - initChanges;
             return Promise.resolve(changes);
         }
         catch (err) {
-            return Promise.reject(`Execute: ${err.message}`);
+            const msg = err.message ? err.message : err;
+            return Promise.reject(`Execute: ${msg}`);
         }
     }
     /**
@@ -368,7 +372,8 @@ class UtilsSQLite {
         return new Promise((resolve, reject) => {
             mDB.exec(sql, async (err) => {
                 if (err) {
-                    reject(`Execute: ${err.message}: `);
+                    console.log(`in execDB err: ${JSON.stringify(err)}`);
+                    reject(`Execute: ${err}: `);
                 }
                 resolve();
             });
@@ -440,9 +445,12 @@ class UtilsSQLite {
     async runExec(db, stmt, values = []) {
         return new Promise((resolve, reject) => {
             if (values != null && values.length > 0) {
+                console.log(`in runExec stmt: ${stmt} values: ${values}`);
                 db.run(stmt, values, (err) => {
                     if (err) {
-                        reject(err.message);
+                        console.log(`in runExec err1: ${JSON.stringify(err)}`);
+                        const msg = err.message ? err.message : err;
+                        reject(msg);
                     }
                     else {
                         resolve();
@@ -452,7 +460,9 @@ class UtilsSQLite {
             else {
                 db.exec(stmt, (err) => {
                     if (err) {
-                        reject(err.message);
+                        console.log(`in runExec err2: ${JSON.stringify(err)}`);
+                        const msg = err.message ? err.message : err;
+                        reject(msg);
                     }
                     else {
                         resolve();
@@ -499,13 +509,14 @@ class UtilsSQLite {
                     .substring('DELETE FROM'.length)
                     .trim();
                 sqlStmt = `UPDATE ${tableName} SET sql_deleted = 1 ${clauseStmt}`;
+                console.log(`in deleteSQL sqlStmt: ${sqlStmt}`);
                 // Find REFERENCES if any and update the sql_deleted column
                 await this.findReferencesAndUpdate(db, tableName, clauseStmt, values);
             }
             return sqlStmt;
         }
         catch (err) {
-            return Promise.reject(`DeleteSL: ${err}`);
+            return Promise.reject(`DeleteSQL: ${err}`);
         }
     }
     /**
@@ -519,27 +530,70 @@ class UtilsSQLite {
     async findReferencesAndUpdate(db, tableName, whereStmt, values) {
         try {
             const references = await this.getReferences(db, tableName);
+            if (references.length <= 0) {
+                return;
+            }
+            const tableNameWithRefs = references.pop();
+            console.log(`references: ${references}`);
+            console.log(`tableNameWithRefs: ${tableNameWithRefs}`);
             for (const refe of references) {
                 // get the tableName of the reference
-                const refTable = await this.getReferenceTableName(refe.sql);
+                const refTable = await this.getReferenceTableName(refe);
                 if (refTable.length <= 0) {
                     continue;
                 }
-                // get the columnName
-                const colName = await this.getReferenceColumnName(refe.sql);
-                if (colName.length <= 0) {
+                console.log(`refTable: ${refTable}`);
+                // get the with references columnName
+                const withRefsNames = await this.getWithRefsColumnName(refe);
+                console.log(`withRefsNames: ${withRefsNames}`);
+                if (withRefsNames.length <= 0) {
+                    continue;
+                }
+                // get the referenced columnName
+                const colNames = await this.getReferencedColumnName(refe);
+                console.log(`colNames: ${colNames}`);
+                if (colNames.length <= 0) {
                     continue;
                 }
                 // update the where clause
-                const uWhereStmt = await this.updateWhere(whereStmt, colName);
+                const uWhereStmt = await this.updateWhere(whereStmt, withRefsNames, colNames);
+                console.log(`whereStmt: ${whereStmt}`);
+                console.log(`uWhereStmt: ${uWhereStmt}`);
                 if (uWhereStmt.length <= 0) {
                     continue;
                 }
+                let updTableName = tableNameWithRefs;
+                let updColNames = colNames;
+                if (tableNameWithRefs === tableName) {
+                    updTableName = refTable;
+                    updColNames = withRefsNames;
+                }
+                console.log(`updTableName: ${updTableName}`);
+                console.log(`updColNames: ${updColNames}`);
                 //update sql_deleted for this reference
-                const stmt = `UPDATE ${refTable} SET sql_deleted = 1 ${uWhereStmt}`;
+                const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
+                console.log(`stmt: ${stmt}`);
+                console.log(`values: ${values}`);
                 if (values != null && values.length > 0) {
                     const mVal = await this.replaceUndefinedByNull(values);
-                    await db.run(stmt, mVal);
+                    let arrVal = whereStmt.split('?');
+                    if (arrVal[arrVal.length - 1] === ';')
+                        arrVal = arrVal.slice(0, -1);
+                    console.log(`arrVal: ${arrVal}`);
+                    const selValues = [];
+                    for (const [j, val] of arrVal.entries()) {
+                        console.log(`j: ${j} val: ${val}`);
+                        for (const updVal of updColNames) {
+                            const idxVal = val.indexOf(updVal);
+                            console.log(`updVal: ${updVal} idxVal ${idxVal}`);
+                            if (idxVal > -1) {
+                                selValues.push(mVal[j]);
+                            }
+                        }
+                    }
+                    console.log(`*** stmt: ${selValues}`);
+                    console.log(`*** selValues: ${selValues}`);
+                    await db.run(stmt, selValues);
                 }
                 else {
                     await db.exec(stmt);
@@ -558,51 +612,120 @@ class UtilsSQLite {
     }
     async getReferenceTableName(refValue) {
         let tableName = '';
-        if (refValue.length > 0 &&
-            refValue.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
-            const oPar = refValue.indexOf('(');
-            tableName = refValue.substring(13, oPar).trim();
+        if (refValue.length > 0) {
+            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
+            if (arr.length === 2) {
+                const oPar = arr[1].indexOf('(');
+                tableName = arr[1].substring(0, oPar).trim();
+            }
         }
         return tableName;
     }
-    async getReferenceColumnName(refValue) {
-        let colName = '';
+    async getReferencedColumnName(refValue) {
+        let colNames = [];
+        if (refValue.length > 0) {
+            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
+            if (arr.length === 2) {
+                const oPar = arr[1].indexOf('(');
+                const cPar = arr[1].indexOf(')');
+                const colStr = arr[1].substring(oPar + 1, cPar).trim();
+                colNames = colStr.split(',');
+            }
+        }
+        return colNames;
+    }
+    async getWithRefsColumnName(refValue) {
+        let colNames = [];
         if (refValue.length > 0) {
-            const index = refValue
-                .toLowerCase()
-                .indexOf('FOREIGN KEY'.toLowerCase());
-            const stmt = refValue.substring(index + 12);
-            const oPar = stmt.indexOf('(');
-            const cPar = stmt.indexOf(')');
-            colName = stmt.substring(oPar + 1, cPar).trim();
+            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
+            if (arr.length === 2) {
+                const oPar = arr[0].indexOf('(');
+                const cPar = arr[0].indexOf(')');
+                const colStr = arr[0].substring(oPar + 1, cPar).trim();
+                colNames = colStr.split(',');
+            }
         }
-        return colName;
+        return colNames;
     }
-    async updateWhere(whStmt, colName) {
+    async updateWhere(whStmt, withRefsNames, colNames) {
         let whereStmt = '';
         if (whStmt.length > 0) {
             const index = whStmt.toLowerCase().indexOf('WHERE'.toLowerCase());
             const stmt = whStmt.substring(index + 6);
-            const fEqual = stmt.indexOf('=');
-            const whereColName = stmt.substring(0, fEqual).trim();
-            whereStmt = whStmt.replace(whereColName, colName);
+            if (withRefsNames.length === colNames.length) {
+                for (let i = 0; i < withRefsNames.length; i++) {
+                    let colType = 'withRefsNames';
+                    let idx = stmt.indexOf(withRefsNames[i]);
+                    if (idx === -1) {
+                        idx = stmt.indexOf(colNames[i]);
+                        colType = 'colNames';
+                    }
+                    if (idx > -1) {
+                        let valStr = '';
+                        const fEqual = stmt.indexOf('=', idx);
+                        if (fEqual > -1) {
+                            const iAnd = stmt.indexOf('AND', fEqual);
+                            const ilAnd = stmt.indexOf('and', fEqual);
+                            if (iAnd > -1) {
+                                valStr = stmt.substring(fEqual + 1, iAnd - 1).trim();
+                            }
+                            else if (ilAnd > -1) {
+                                valStr = stmt.substring(fEqual + 1, ilAnd - 1).trim();
+                            }
+                            else {
+                                valStr = stmt.substring(fEqual + 1, stmt.length).trim();
+                            }
+                            if (i > 0) {
+                                whereStmt += ' AND ';
+                            }
+                            if (colType === 'withRefsNames') {
+                                whereStmt += `${colNames[i]} = ${valStr}`;
+                            }
+                            else {
+                                whereStmt += `${withRefsNames[i]} = ${valStr}`;
+                            }
+                        }
+                    }
+                }
+                whereStmt = 'WHERE ' + whereStmt;
+            }
         }
         return whereStmt;
     }
     async getReferences(db, tableName) {
         const sqlStmt = 'SELECT sql FROM sqlite_master ' +
-            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
             "sql LIKE('%" +
             tableName +
             "%') AND sql LIKE('%ON DELETE%');";
         try {
             const res = await this.queryAll(db, sqlStmt, []);
-            return Promise.resolve(res);
+            // get the reference's string(s)
+            let retRefs = [];
+            if (res.length > 0) {
+                retRefs = await this.getRefs(res[0].sql);
+            }
+            return Promise.resolve(retRefs);
         }
         catch (err) {
             return Promise.reject(new Error(`getReferences: ${err.message}`));
         }
     }
+    async getRefs(str) {
+        const retRefs = [];
+        const arrFor = str.split(new RegExp('FOREIGN KEY', 'i'));
+        // Loop through Foreign Keys
+        for (let i = 1; i < arrFor.length; i++) {
+            retRefs.push(arrFor[i].split(new RegExp('ON DELETE', 'i'))[0].trim());
+        }
+        // find table name with references
+        if (str.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
+            const oPar = str.indexOf('(');
+            const tableName = str.substring(13, oPar).trim();
+            retRefs.push(tableName);
+        }
+        return retRefs;
+    }
     /**
      * QueryAll
      * @param mDB