@capacitor-community/sqlite 5.0.7-2 → 5.0.7

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

@@ -0,0 +1,169 @@
+package com.getcapacitor.community.database.sqlite.SQLite;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class UtilsSQLStatement {
+
+    public static String flattenMultilineString(String input) {
+        String[] lines = input.split("\\r?\\n");
+        return String.join(" ", lines);
+    }
+
+    public static String extractTableName(String statement) {
+        Pattern pattern = Pattern.compile("(?:INSERT\\s+INTO|UPDATE|DELETE\\s+FROM)\\s+([^\\s]+)", Pattern.CASE_INSENSITIVE);
+        Matcher match = pattern.matcher(statement);
+        if (match.find() && match.groupCount() > 0) {
+            String tableName = match.group(1);
+            return tableName;
+        }
+        return null;
+    }
+
+    public static String extractWhereClause(String statement) {
+        Pattern pattern = Pattern.compile("WHERE(.+?)(?:ORDER\\s+BY|LIMIT|$)", Pattern.CASE_INSENSITIVE);
+        Matcher match = pattern.matcher(statement);
+        if (match.find() && match.groupCount() > 0) {
+            String whereClause = match.group(1).trim();
+            return whereClause;
+        }
+        return null;
+    }
+
+    public static String addPrefixToWhereClause(String whereClause, String[] colNames, String[] refNames, String prefix) {
+        String[] columnValuePairs = null;
+        String[] logicalOperators = new String[] { "AND", "OR", "NOT" };
+
+        for (String logicalOperator : logicalOperators) {
+            if (whereClause.contains(logicalOperator)) {
+                columnValuePairs = whereClause.split("\\s*" + logicalOperator + "\\s*");
+                break;
+            }
+        }
+
+        if (columnValuePairs == null) {
+            columnValuePairs = new String[] { whereClause };
+        }
+
+        List<String> modifiedPairs = new ArrayList<>();
+
+        for (String pair : columnValuePairs) {
+            String trimmedPair = pair.trim();
+
+            int operatorIndex = -1;
+            String operator = null;
+            for (String op : new String[] { "=", "<>", "<", "<=", ">", ">=", "IN", "BETWEEN", "LIKE" }) {
+                operatorIndex = trimmedPair.indexOf(op);
+                if (operatorIndex != -1) {
+                    operator = op;
+                    break;
+                }
+            }
+
+            if (operator == null) {
+                modifiedPairs.add(trimmedPair);
+                continue;
+            }
+
+            String column = trimmedPair.substring(0, operatorIndex).trim();
+            String value = trimmedPair.substring(operatorIndex + operator.length()).trim();
+
+            String newColumn = column;
+            int index = findIndexOfStringInArray(column, refNames);
+            if (index != -1) {
+                newColumn = getStringAtIndex(colNames, index);
+            }
+
+            String modifiedColumn = prefix + newColumn;
+            String modifiedPair = modifiedColumn + " " + operator + " " + value;
+            modifiedPairs.add(modifiedPair);
+        }
+
+        String logicalOperatorUsed = logicalOperators[0];
+        for (String logicalOperator : logicalOperators) {
+            if (whereClause.contains(logicalOperator)) {
+                logicalOperatorUsed = logicalOperator;
+                break;
+            }
+        }
+        String modWhereClause = String.join(" " + logicalOperatorUsed + " ", modifiedPairs);
+        return modWhereClause;
+    }
+
+    public static int findIndexOfStringInArray(String target, String[] array) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].equals(target)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static String getStringAtIndex(String[] array, int index) {
+        if (index >= 0 && index < array.length) {
+            return array[index];
+        } else {
+            return null;
+        }
+    }
+
+    public static UtilsDelete.ForeignKeyInfo extractForeignKeyInfo(String sqlStatement) throws Exception {
+        // Define the regular expression pattern for extracting the FOREIGN KEY clause
+        String foreignKeyPattern =
+            "\\bFOREIGN\\s+KEY\\s*\\(([^)]+)\\)\\s+REFERENCES\\s+(\\w+)\\s*\\(([^)]+)\\)\\s+(ON\\s+DELETE\\s+(RESTRICT|CASCADE|SET\\s+NULL|SET\\s+DEFAULT|NO\\s+ACTION))?";
+        Pattern pattern = Pattern.compile(foreignKeyPattern);
+        Matcher matcher = pattern.matcher(sqlStatement);
+
+        if (matcher.find()) {
+            String[] forKeys = matcher.group(1).split(",");
+            String tableName = matcher.group(2);
+            String[] refKeys = matcher.group(3).split(",");
+            String action = matcher.group(5) != null ? matcher.group(5) : "NO ACTION";
+            List<String> lForKeys = new ArrayList<>(Arrays.asList(forKeys));
+            List<String> lRefKeys = new ArrayList<>(Arrays.asList(refKeys));
+            return new UtilsDelete.ForeignKeyInfo(lForKeys, tableName, lRefKeys, action);
+        } else {
+            throw new Exception("extractForeignKeyInfo: No FOREIGN KEY found");
+        }
+    }
+
+    public static List<String> extractColumnNames(String whereClause) {
+        Set<String> keywords = new HashSet<>(Arrays.asList("AND", "OR", "IN", "VALUES", "LIKE", "BETWEEN", "NOT"));
+        String[] tokens = whereClause.split("\\s|,|\\(|\\)");
+
+        List<String> columns = new ArrayList<>();
+        boolean inClause = false;
+        boolean inValues = false;
+
+        for (String token : tokens) {
+            if (token.equals("IN")) {
+                inClause = true;
+            } else if (inClause && token.equals("(")) {
+                inValues = true;
+            } else if (inValues && token.equals(")")) {
+                inValues = false;
+            } else if (token.matches("\\b[a-zA-Z]\\w*\\b") && !inValues && !keywords.contains(token.toUpperCase())) {
+                columns.add(token);
+            }
+        }
+
+        return new ArrayList<>(new HashSet<>(columns));
+    }
+
+    public static List<Integer> indicesOf(String str, String searchStr, int fromIndex) {
+        List<Integer> indices = new ArrayList<>();
+
+        int currentIndex = str.indexOf(searchStr, fromIndex);
+        while (currentIndex != -1) {
+            indices.add(currentIndex);
+            currentIndex = str.indexOf(searchStr, currentIndex + 1);
+        }
+
+        return indices;
+    }
+}

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

@@ -69,15 +69,15 @@ public class UtilsUpgrade {
      * @throws Exception
      */
     private void executeStatementsProcess(Database db, String[] statements) throws Exception {
-        db.getDb().beginTransaction();
+        db.beginTransaction();
         try {
-            db.execute(statements);
+            db.execute(statements, false);
 
-            db.getDb().setTransactionSuccessful();
+            db.commitTransaction();
         } catch (Exception e) {
             throw new Exception("Error: executeStatementsProcess " + " failed " + e);
         } finally {
-            db.getDb().endTransaction();
+            db.rollbackTransaction();
         }
     }
 }

package/dist/esm/definitions.d.ts

@@ -112,6 +112,34 @@ export interface CapacitorSQLitePlugin {
      * @since 0.0.1
      */
     close(options: capSQLiteOptions): Promise<void>;
+    /**
+     * Begin Database Transaction
+     * @param options
+     * @returns capSQLiteChanges
+     * @since 5.0.7
+     */
+    beginTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+    /**
+     * Commit Database Transaction
+     * @param options
+     * @returns capSQLiteChanges
+     * @since 5.0.7
+     */
+    commitTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+    /**
+   * Rollback Database Transaction
+   * @param options
+   * @returns capSQLiteChanges
+   * @since 5.0.7
+   */
+    rollbackTransaction(options: capSQLiteOptions): Promise<capSQLiteChanges>;
+    /**
+     * Is Database Transaction Active
+     * @param options
+     * @returns capSQLiteResult
+     * @since 5.0.7
+     */
+    isTransactionActive(options: capSQLiteOptions): Promise<capSQLiteResult>;
     /**
      * Load a SQlite extension
      * @param options :capSQLiteExtensionPath
@@ -514,6 +542,13 @@ export interface capSQLiteExecuteOptions {
      * @since 4.1.0-7
      */
     readonly?: boolean;
+    /**
+     * Compatibility SQL92
+     * !!! ELECTRON ONLY
+     * default (true)
+     * @since 5.0.7
+     */
+    isSQL92?: boolean;
 }
 export interface capSQLiteSetOptions {
     /**
@@ -544,6 +579,13 @@ export interface capSQLiteSetOptions {
      * @since 5.0.5-3
      */
     returnMode?: string;
+    /**
+     * Compatibility SQL92
+     * !!! ELECTRON ONLY
+     * default (true)
+     * @since 5.0.7
+     */
+    isSQL92?: boolean;
 }
 export interface capSQLiteRunOptions {
     /**
@@ -578,6 +620,13 @@ export interface capSQLiteRunOptions {
      * @since 5.0.5-3
      */
     returnMode?: string;
+    /**
+     * Compatibility SQL92
+     * !!! ELECTRON ONLY
+     * default (true)
+     * @since 5.0.7
+     */
+    isSQL92?: boolean;
 }
 export interface capSQLiteQueryOptions {
     /**
@@ -600,6 +649,13 @@ export interface capSQLiteQueryOptions {
      * @since 4.1.0-7
      */
     readonly?: boolean;
+    /**
+     * Compatibility SQL92
+     * !!! ELECTRON ONLY
+     * default (true)
+     * @since 5.0.7
+     */
+    isSQL92?: boolean;
 }
 export interface capSQLiteImportOptions {
     /**
@@ -1301,6 +1357,30 @@ export interface ISQLiteDBConnection {
      * @since 2.9.0 refactor
      */
     close(): Promise<void>;
+    /**
+     * Begin Database Transaction
+     * @returns capSQLiteChanges
+     * @since 5.0.7
+     */
+    beginTransaction(): Promise<capSQLiteChanges>;
+    /**
+     * Commit Database Transaction
+     * @returns capSQLiteChanges
+     * @since 5.0.7
+     */
+    commitTransaction(): Promise<capSQLiteChanges>;
+    /**
+     * Rollback Database Transaction
+     * @returns capSQLiteChanges
+     * @since 5.0.7
+     */
+    rollbackTransaction(): Promise<capSQLiteChanges>;
+    /**
+     * Is Database Transaction Active
+     * @returns capSQLiteResult
+     * @since 5.0.7
+     */
+    isTransactionActive(): Promise<capSQLiteResult>;
     /**
      * Get Database Url
      * @returns Promise<capSQLiteUrl>
@@ -1333,7 +1413,7 @@ export interface ISQLiteDBConnection {
      * @returns Promise<capSQLiteChanges>
      * @since 2.9.0 refactor
      */
-    execute(statements: string, transaction?: boolean): Promise<capSQLiteChanges>;
+    execute(statements: string, transaction?: boolean, isSQL92?: boolean): Promise<capSQLiteChanges>;
     /**
      * Execute SQLite DB Connection Query
      * @param statement
@@ -1341,7 +1421,7 @@ export interface ISQLiteDBConnection {
      * @returns Promise<Promise<DBSQLiteValues>
      * @since 2.9.0 refactor
      */
-    query(statement: string, values?: any[]): Promise<DBSQLiteValues>;
+    query(statement: string, values?: any[], isSQL92?: boolean): Promise<DBSQLiteValues>;
     /**
      * Execute SQLite DB Connection Raw Statement
      * @param statement
@@ -1349,14 +1429,14 @@ export interface ISQLiteDBConnection {
      * @returns Promise<capSQLiteChanges>
      * @since 2.9.0 refactor
      */
-    run(statement: string, values?: any[], transaction?: boolean, returnMode?: string): Promise<capSQLiteChanges>;
+    run(statement: string, values?: any[], transaction?: boolean, returnMode?: string, isSQL92?: boolean): Promise<capSQLiteChanges>;
     /**
      * Execute SQLite DB Connection Set
      * @param set
      * @returns Promise<capSQLiteChanges>
      * @since 2.9.0 refactor
      */
-    executeSet(set: capSQLiteSet[], transaction?: boolean, returnMode?: string): Promise<capSQLiteChanges>;
+    executeSet(set: capSQLiteSet[], transaction?: boolean, returnMode?: string, isSQL92?: boolean): Promise<capSQLiteChanges>;
     /**
      * Check if a SQLite DB Connection exists
      * @returns Promise<capSQLiteResult>
@@ -1421,13 +1501,14 @@ export interface ISQLiteDBConnection {
     /**
      *
      * @param txn
-     * @returns Promise<void>
+     * @param isSQL92
+     * @returns Promise<capSQLiteChanges> since 5.0.7
      * @since 3.4.0
      */
     executeTransaction(txn: {
         statement: string;
         values?: any[];
-    }[]): Promise<void>;
+    }[], isSQL92: boolean): Promise<capSQLiteChanges>;
 }
 /**
  * SQLiteDBConnection Class
@@ -1441,15 +1522,19 @@ export declare class SQLiteDBConnection implements ISQLiteDBConnection {
     getConnectionReadOnly(): boolean;
     open(): Promise<void>;
     close(): Promise<void>;
+    beginTransaction(): Promise<capSQLiteChanges>;
+    commitTransaction(): Promise<capSQLiteChanges>;
+    rollbackTransaction(): Promise<capSQLiteChanges>;
+    isTransactionActive(): Promise<capSQLiteResult>;
     loadExtension(path: string): Promise<void>;
     enableLoadExtension(toggle: boolean): Promise<void>;
     getUrl(): Promise<capSQLiteUrl>;
     getVersion(): Promise<capVersionResult>;
     getTableList(): Promise<DBSQLiteValues>;
-    execute(statements: string, transaction?: boolean): Promise<capSQLiteChanges>;
-    query(statement: string, values?: any[]): Promise<DBSQLiteValues>;
-    run(statement: string, values?: any[], transaction?: boolean, returnMode?: string): Promise<capSQLiteChanges>;
-    executeSet(set: capSQLiteSet[], transaction?: boolean, returnMode?: string): Promise<capSQLiteChanges>;
+    execute(statements: string, transaction?: boolean, isSQL92?: boolean): Promise<capSQLiteChanges>;
+    query(statement: string, values?: any[], isSQL92?: boolean): Promise<DBSQLiteValues>;
+    run(statement: string, values?: any[], transaction?: boolean, returnMode?: string, isSQL92?: boolean): Promise<capSQLiteChanges>;
+    executeSet(set: capSQLiteSet[], transaction?: boolean, returnMode?: string, isSQL92?: boolean): Promise<capSQLiteChanges>;
     isExists(): Promise<capSQLiteResult>;
     isTable(table: string): Promise<capSQLiteResult>;
     isDBOpen(): Promise<capSQLiteResult>;
@@ -1462,6 +1547,6 @@ export declare class SQLiteDBConnection implements ISQLiteDBConnection {
     executeTransaction(txn: {
         statement: string;
         values?: any[];
-    }[]): Promise<void>;
+    }[], isSQL92?: boolean): Promise<capSQLiteChanges>;
     private reorderRows;
 }

package/dist/esm/definitions.js

@@ -468,40 +468,69 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
+    async beginTransaction() {
+        try {
+            const changes = await this.sqlite
+                .beginTransaction({ database: this.dbName });
+            return Promise.resolve(changes);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    async commitTransaction() {
+        try {
+            const changes = await this.sqlite
+                .commitTransaction({ database: this.dbName });
+            return Promise.resolve(changes);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    async rollbackTransaction() {
+        try {
+            const changes = await this.sqlite
+                .rollbackTransaction({ database: this.dbName });
+            return Promise.resolve(changes);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    async isTransactionActive() {
+        try {
+            const result = await this.sqlite
+                .isTransactionActive({ database: this.dbName });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
     async loadExtension(path) {
         try {
-            console.log(`database: ${this.dbName}`);
-            console.log(`readonly: ${this.readonly}}`);
-            console.log(`path: ${path}}`);
             await this.sqlite.loadExtension({
                 database: this.dbName,
                 path: path,
                 readonly: this.readonly,
             });
-            console.log(`loadExtension successful`);
             return Promise.resolve();
         }
         catch (err) {
-            console.log(`loadExtension failed `);
             return Promise.reject(err);
         }
     }
     async enableLoadExtension(toggle) {
         try {
-            console.log(`database: ${this.dbName}`);
-            console.log(`readonly: ${this.readonly}`);
-            console.log(`toggle: ${toggle}`);
             await this.sqlite.enableLoadExtension({
                 database: this.dbName,
                 toggle: toggle,
                 readonly: this.readonly,
             });
-            console.log(`enableLoadExtension successful`);
             return Promise.resolve();
         }
         catch (err) {
-            console.log(err);
-            console.log(`enableLoadExtension failed `);
             return Promise.reject(err);
         }
     }
@@ -541,7 +570,7 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
-    async execute(statements, transaction = true) {
+    async execute(statements, transaction = true, isSQL92 = true) {
         try {
             if (!this.readonly) {
                 const res = await this.sqlite.execute({
@@ -549,6 +578,7 @@ export class SQLiteDBConnection {
                     statements: statements,
                     transaction: transaction,
                     readonly: false,
+                    isSQL92: isSQL92
                 });
                 return Promise.resolve(res);
             }
@@ -560,7 +590,7 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
-    async query(statement, values) {
+    async query(statement, values, isSQL92 = true) {
         let res;
         try {
             if (values && values.length > 0) {
@@ -569,6 +599,7 @@ export class SQLiteDBConnection {
                     statement: statement,
                     values: values,
                     readonly: this.readonly,
+                    isSql92: true
                 });
             }
             else {
@@ -577,6 +608,7 @@ export class SQLiteDBConnection {
                     statement: statement,
                     values: [],
                     readonly: this.readonly,
+                    isSQL92: isSQL92
                 });
             }
             // reorder rows for ios
@@ -587,7 +619,7 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
-    async run(statement, values, transaction = true, returnMode = 'no') {
+    async run(statement, values, transaction = true, returnMode = 'no', isSQL92 = true) {
         let res;
         try {
             if (!this.readonly) {
@@ -602,6 +634,7 @@ export class SQLiteDBConnection {
                         transaction: transaction,
                         readonly: false,
                         returnMode: mRetMode,
+                        isSQL92: true
                     });
                     //        }
                 }
@@ -616,6 +649,7 @@ export class SQLiteDBConnection {
                         transaction: transaction,
                         readonly: false,
                         returnMode: mRetMode,
+                        isSQL92: isSQL92
                     });
                 }
                 // reorder rows for ios
@@ -630,7 +664,7 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
-    async executeSet(set, transaction = true, returnMode = 'no') {
+    async executeSet(set, transaction = true, returnMode = 'no', isSQL92 = true) {
         let res;
         try {
             if (!this.readonly) {
@@ -640,6 +674,7 @@ export class SQLiteDBConnection {
                     transaction: transaction,
                     readonly: false,
                     returnMode: returnMode,
+                    isSQL92: isSQL92
                 });
                 //      }
                 // reorder rows for ios
@@ -788,17 +823,25 @@ export class SQLiteDBConnection {
             return Promise.reject(err);
         }
     }
-    async executeTransaction(txn) {
-        try {
-            if (!this.readonly) {
-                const ret = await this.sqlite.execute({
-                    database: this.dbName,
-                    statements: 'BEGIN TRANSACTION;',
-                    transaction: false,
+    async executeTransaction(txn, isSQL92 = true) {
+        let changes = 0;
+        let isActive = false;
+        if (!this.readonly) {
+            try {
+                await this.sqlite.beginTransaction({
+                    database: this.dbName
                 });
-                if (ret.changes.changes < 0) {
-                    return Promise.reject('Error in BEGIN TRANSACTION');
+                isActive = await this.sqlite.isTransactionActive({
+                    database: this.dbName
+                });
+                if (!isActive) {
+                    return Promise.reject('After Begin Transaction, no transaction active');
                 }
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+            try {
                 for (const task of txn) {
                     if (task.values && task.values.length > 0) {
                         const retMode = task.statement.toUpperCase().includes('RETURNING')
@@ -811,11 +854,12 @@ export class SQLiteDBConnection {
                             transaction: false,
                             readonly: false,
                             returnMode: retMode,
+                            isSQL92: isSQL92
                         });
-                        if (ret.changes.lastId === -1) {
-                            await this.execute('ROLLBACK;', false);
-                            return Promise.reject('Error in transaction run ');
+                        if (ret.changes.changes <= 0) {
+                            throw new Error('Error in transaction method run ');
                         }
+                        changes += ret.changes.changes;
                     }
                     else {
                         const ret = await this.sqlite.execute({
@@ -824,37 +868,42 @@ export class SQLiteDBConnection {
                             transaction: false,
                             readonly: false,
                         });
+                        isActive = await this.sqlite.isTransactionActive({
+                            database: this.dbName
+                        });
                         if (ret.changes.changes < 0) {
-                            await this.sqlite.execute({
-                                database: this.dbName,
-                                statements: 'ROLLBACK;',
-                                transaction: false,
-                                readonly: false,
-                            });
-                            return Promise.reject('Error in transaction execute ');
+                            throw new Error('Error in transaction method execute ');
                         }
+                        changes += ret.changes.changes;
                     }
                 }
-                await this.sqlite.execute({
-                    database: this.dbName,
-                    statements: 'COMMIT;',
-                    transaction: false,
-                    readonly: false,
+                isActive = await this.sqlite.isTransactionActive({
+                    database: this.dbName
                 });
-                return Promise.resolve();
+                if (isActive) {
+                    const retC = await this.sqlite.commitTransaction({
+                        database: this.dbName
+                    });
+                    changes += retC.changes.changes;
+                }
+                const retChanges = { changes: { changes: changes } };
+                return Promise.resolve(retChanges);
             }
-            else {
-                return Promise.reject('not allowed in read-only mode');
+            catch (err) {
+                const msg = err.message ? err.message : err;
+                isActive = await this.sqlite.isTransactionActive({
+                    database: this.dbName
+                });
+                if (isActive) {
+                    await this.sqlite.rollbackTransaction({
+                        database: this.dbName,
+                    });
+                }
+                return Promise.reject(msg);
             }
         }
-        catch (err) {
-            await this.sqlite.execute({
-                database: this.dbName,
-                statements: 'ROLLBACK;',
-                transaction: false,
-                readonly: false,
-            });
-            return Promise.reject(err);
+        else {
+            return Promise.reject('not allowed in read-only mode');
         }
     }
     async reorderRows(res) {