@capacitor-community/sqlite 5.0.7-2 → 5.0.8

package/electron/dist/plugin.js

@@ -9,8 +9,8 @@ var require$$3 = require('node-fetch');
 var require$$4 = require('os');
 var require$$5 = require('jszip');
 var require$$6 = require('electron');
-var require$$3$1 = require('better-sqlite3-multiple-ciphers');
-var require$$3$2 = require('electron-json-storage');
+var require$$4$1 = require('better-sqlite3-multiple-ciphers');
+var require$$3$1 = require('electron-json-storage');
 var require$$1$1 = require('crypto');
 var require$$2$1 = require('crypto-js');
 
@@ -23,8 +23,8 @@ var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
 var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6);
+var require$$4__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$4$1);
 var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
-var require$$3__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$3$2);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 
@@ -48,6 +48,205 @@ var exportToJson = {};
 
 var utilsSQLite = {};
 
+var UtilsSQL92Compatibility$1 = {};
+
+Object.defineProperty(UtilsSQL92Compatibility$1, "__esModule", { value: true });
+UtilsSQL92Compatibility$1.UtilsSQL92Compatibility = void 0;
+class UtilsSQL92Compatibility {
+    compatibleSQL92(statement) {
+        let newStatement = "";
+        const action = (statement.trim().substring(0, 6)).toUpperCase();
+        switch (action) {
+            case "INSERT":
+                newStatement = this.insertSQL92(statement);
+                break;
+            case "UPDATE":
+                newStatement = this.updateSQL92(statement);
+                break;
+            case "DELETE":
+            case "SELECT":
+                newStatement = this.whereSQL92(statement);
+                break;
+            default:
+                throw new Error(`Error: ${action} not implemented`);
+        }
+        return newStatement;
+    }
+    ;
+    insertSQL92(insertStatement) {
+        // Split the statement into parts
+        const inStmt = insertStatement.trim();
+        const valuesStartIndex = inStmt.indexOf('VALUES');
+        const columnsPart = inStmt.substring(0, valuesStartIndex);
+        const valuesPart = inStmt.substring(valuesStartIndex);
+        // Extract values and replace double quotes with single quotes
+        const modifiedValuesPart = valuesPart.replace(/"([^"]+)"/g, "'$1'");
+        // Reconstruct the modified statement
+        const modifiedStatement = columnsPart + modifiedValuesPart;
+        return modifiedStatement;
+    }
+    ;
+    updateSQL92(updateStatement) {
+        // Split the statement into SET and WHERE parts
+        let isWhere = true;
+        const setWhereSplit = updateStatement.toUpperCase().split('WHERE');
+        if (setWhereSplit.length <= 1)
+            isWhere = false;
+        const setUpdate = setWhereSplit[0].toUpperCase().split('SET')[0].trim();
+        const setPart = setWhereSplit[0].toUpperCase().split('SET')[1].trim();
+        const modifiedSetPart = this.modSetPart(setPart);
+        let modifiedStatement = `${setUpdate} SET ${modifiedSetPart}`;
+        if (isWhere) {
+            for (let i = 1; i < setWhereSplit.length; i++) {
+                const wherePart = setWhereSplit[i].trim();
+                const modifiedWherePart = this.modWherePart(wherePart);
+                modifiedStatement += ` WHERE ${modifiedWherePart}`;
+            }
+        }
+        return modifiedStatement;
+    }
+    ;
+    whereSQL92(statement) {
+        // Split the statement into SET and WHERE parts
+        const setWhereSplit = statement.toUpperCase().split('WHERE');
+        if (setWhereSplit.length <= 1)
+            return statement;
+        let modifiedStatement = `${setWhereSplit[0].trim()}`;
+        for (let i = 1; i < setWhereSplit.length; i++) {
+            const wherePart = setWhereSplit[1].trim();
+            const modifiedWherePart = this.modWherePart(wherePart);
+            modifiedStatement += `WHERE ${modifiedWherePart}`;
+        }
+        return modifiedStatement;
+    }
+    ;
+    modSetPart(setStatement) {
+        const commaPart = setStatement.split(",");
+        const modCommaPart = [];
+        for (const com of commaPart) {
+            const equalPart = com.split("=");
+            const value = equalPart[1].replaceAll(`"`, `'`);
+            modCommaPart.push(`${equalPart[0].trim()} = ${value.trim()}`);
+        }
+        return modCommaPart.toString();
+    }
+    ;
+    modWherePart(whereStatement) {
+        const keywords = new Set([
+            '=',
+            '<>',
+            '>',
+            '>=',
+            '<',
+            '<=',
+            'IN',
+            'VALUES',
+            '(',
+            ',',
+            ')',
+            'BETWEEN',
+            'LIKE',
+            'AND',
+            'OR',
+            'NOT'
+        ]);
+        const newTokens = [];
+        const tokens = whereStatement.split(/(\s|,|\(|\))/).filter(item => item !== ' ').filter(item => item !== '');
+        let inClause = false;
+        let inValues = false;
+        let modValue = false;
+        let betwClause = false;
+        let opsClause = false;
+        let inValValues = false;
+        let inValPar = false;
+        for (const token of tokens) {
+            if ((new Set(['=', '<>', '>', '>=', '<', '<='])).has(token)) {
+                newTokens.push(token);
+                modValue = true;
+                opsClause = false;
+            }
+            else if (token.toUpperCase() === 'BETWEEN') {
+                newTokens.push(token);
+                betwClause = true;
+                modValue = true;
+                opsClause = false;
+            }
+            else if (betwClause && token.toUpperCase() === 'AND') {
+                newTokens.push(token);
+                modValue = true;
+                betwClause = false;
+            }
+            else if (token.toUpperCase() === 'LIKE') {
+                newTokens.push(token);
+                opsClause = false;
+                modValue = true;
+            }
+            else if (token.toUpperCase() === 'AND' ||
+                token.toUpperCase() === 'OR' ||
+                token.toUpperCase() === 'NOT') {
+                newTokens.push(token);
+                opsClause = true;
+            }
+            else if (token.toUpperCase() === 'IN') {
+                newTokens.push(token);
+                opsClause = false;
+                inClause = true;
+            }
+            else if (inClause && token === '(') {
+                newTokens.push(token);
+                modValue = true;
+                inValues = true;
+            }
+            else if (inValues && token.toUpperCase() === ',') {
+                newTokens.push(token);
+                modValue = true;
+            }
+            else if (inValues && token.toUpperCase() === 'VALUES') {
+                newTokens.push(token);
+                inValues = false;
+                inValValues = true;
+                inClause = false;
+            }
+            else if (inValValues && token === '(') {
+                newTokens.push(token);
+                inValPar = true;
+                modValue = true;
+            }
+            else if (inValPar && token.toUpperCase() === ',') {
+                newTokens.push(token);
+                modValue = true;
+            }
+            else if (inValPar && inValValues && token === ')') {
+                newTokens.push(token);
+                inValPar = false;
+                inValues = true;
+            }
+            else if ((inValues || inValValues) && token === ')') {
+                newTokens.push(token);
+                inValValues = false;
+                inValues = false;
+                inClause = false;
+            }
+            else if (modValue &&
+                !opsClause &&
+                !keywords.has(token.toUpperCase())) {
+                if (token.length > 0) {
+                    const nwToken = token.replaceAll(`"`, `'`);
+                    newTokens.push(nwToken);
+                    modValue = false;
+                }
+            }
+            else {
+                newTokens.push(token);
+            }
+        }
+        const ns = newTokens.join(" ");
+        return ns;
+    }
+    ;
+}
+UtilsSQL92Compatibility$1.UtilsSQL92Compatibility = UtilsSQL92Compatibility;
+
 var utilsDelete = {};
 
 Object.defineProperty(utilsDelete, "__esModule", { value: true });
@@ -75,7 +274,7 @@ class UtilsDelete {
         if (refValue.length > 0) {
             const arr = refValue.split(new RegExp('REFERENCES', 'i'));
             if (arr.length === 2) {
-                const oPar = arr[1].indexOf("(");
+                const oPar = arr[1].indexOf('(');
                 tableName = arr[1].substring(0, oPar).trim();
             }
         }
@@ -787,7 +986,9 @@ class UtilsSQLStatement {
         this.replaceString = (originalStr, searchStr, replaceStr) => {
             const range = originalStr.indexOf(searchStr);
             if (range !== -1) {
-                const modifiedStr = originalStr.substring(0, range) + replaceStr + originalStr.substring(range + searchStr.length);
+                const modifiedStr = originalStr.substring(0, range) +
+                    replaceStr +
+                    originalStr.substring(range + searchStr.length);
                 return modifiedStr;
             }
             return originalStr;
@@ -813,18 +1014,15 @@ class UtilsSQLStatement {
     }
     addPrefixToWhereClause(whereClause, colNames, refNames, prefix) {
         let columnValuePairs;
-        if (whereClause.includes("AND")) {
+        if (whereClause.includes('AND')) {
             // Split the WHERE clause based on the "AND" keyword
-            const subSequenceArray = whereClause.split("AND");
-            console.log(" whereClause", whereClause);
-            console.log(" subSequenceArray", subSequenceArray);
-            columnValuePairs = subSequenceArray.map((pair) => pair.trim());
+            const subSequenceArray = whereClause.split('AND');
+            columnValuePairs = subSequenceArray.map(pair => pair.trim());
         }
         else {
             columnValuePairs = [whereClause];
         }
-        console.log(" columnValuePairs", columnValuePairs);
-        const modifiedPairs = columnValuePairs.map((pair) => {
+        const modifiedPairs = columnValuePairs.map(pair => {
             const match = pair.match(/(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)/);
             if (!match) {
                 return pair;
@@ -841,7 +1039,7 @@ class UtilsSQLStatement {
             const ret = `${modifiedColumn} ${operator} ${value}`;
             return ret;
         });
-        return modifiedPairs.join(" AND ");
+        return modifiedPairs.join(' AND ');
     }
     findIndexOfStringInArray(target, array) {
         return array.indexOf(target);
@@ -860,60 +1058,100 @@ class UtilsSQLStatement {
         const matches = sqlStatement.match(foreignKeyPattern);
         if (matches) {
             const foreignKeyInfo = {
-                forKeys: matches[1].split(",").map(key => key.trim()),
+                forKeys: matches[1].split(',').map(key => key.trim()),
                 tableName: matches[2],
-                refKeys: matches[3].split(",").map(key => key.trim()),
-                action: matches[5] ? matches[5] : "NO ACTION"
+                refKeys: matches[3].split(',').map(key => key.trim()),
+                action: matches[5] ? matches[5] : 'NO ACTION',
             };
             return foreignKeyInfo;
         }
         else {
-            throw new Error("extractForeignKeyInfo: No FOREIGN KEY found");
+            throw new Error('extractForeignKeyInfo: No FOREIGN KEY found');
         }
     }
+    /*
+    public extractColumnNames(whereClause: string): string[] {
+      const regex = /\b(\w+)\s*(?=[=<>])|(?<=\()\s*(\w+),\s*(\w+)\s*(?=\))|(?<=\bIN\s*\(VALUES\s*\().*?(?=\))|(?<=\bIN\s*\().*?(?=\))|(?<=\bBETWEEN\s*).*?(?=\bAND\b)|(?<=\bLIKE\s*')\w+|\bAND\b/g;
+      const matches = whereClause.matchAll(regex);
+      const columnNames: string[] = [];
+  
+      let andGroup: string[] = [];
+  
+      for (const match of matches) {
+          if (match[0] === 'AND') {
+              columnNames.push(...andGroup);
+              andGroup = [];
+          } else if (match[1]) {
+              andGroup.push(match[1]);
+          } else if (match[2] && match[3]) {
+              andGroup.push(match[2]);
+              andGroup.push(match[3]);
+          } else if (match[0]) {
+              const values = match[0]
+                .replace(/[()']/g, '') // Remove parentheses and single quotes
+                .split(',')
+                .map(value => value.trim());
+              andGroup.push(...values);
+          }
+      }
+  
+      columnNames.push(...andGroup);
+  
+      return columnNames;
+    }
+  */
     extractColumnNames(whereClause) {
-        const regex = /\b(\w+)\s*(?=[=<>])|(?<=\()\s*(\w+),\s*(\w+)\s*(?=\))|(?<=\bIN\s*\(VALUES\s*\().*?(?=\))|(?<=\bIN\s*\().*?(?=\))|(?<=\bBETWEEN\s*).*?(?=\bAND\b)|(?<=\bLIKE\s*')\w+|\bAND\b/g;
-        const matches = whereClause.matchAll(regex);
-        const columnNames = [];
-        let andGroup = [];
-        for (const match of matches) {
-            if (match[0] === 'AND') {
-                columnNames.push(...andGroup);
-                andGroup = [];
-            }
-            else if (match[1]) {
-                andGroup.push(match[1]);
-            }
-            else if (match[2] && match[3]) {
-                andGroup.push(match[2]);
-                andGroup.push(match[3]);
-            }
-            else if (match[0]) {
-                const values = match[0]
-                    .replace(/[()']/g, '') // Remove parentheses and single quotes
-                    .split(',')
-                    .map(value => value.trim());
-                andGroup.push(...values);
-            }
-        }
-        columnNames.push(...andGroup);
-        return columnNames;
+        const keywords = new Set([
+            'AND',
+            'OR',
+            'IN',
+            'VALUES',
+            'LIKE',
+            'BETWEEN',
+            'NOT',
+        ]);
+        const tokens = whereClause.split(/(\s|,|\(|\))/).filter(item => item !== ' ');
+        const columns = [];
+        let inClause = false;
+        let inValues = false;
+        for (const token of tokens) {
+            if (token === 'IN') {
+                inClause = true;
+            }
+            else if (inClause && token === '(') {
+                inValues = true;
+            }
+            else if (inValues && token === ')') {
+                inValues = false;
+            }
+            else if (token.match(/\b[a-zA-Z]\w*\b/) &&
+                !inValues &&
+                !keywords.has(token.toUpperCase())) {
+                if (token.length > 0) {
+                    columns.push(token);
+                }
+            }
+        }
+        return Array.from(new Set(columns));
     }
     flattenMultilineString(input) {
         const lines = input.split(/\r?\n/);
-        return lines.join(" ");
+        return lines.join(' ');
     }
     getStmtAndRetColNames(sqlStmt, retMode) {
-        const retWord = "RETURNING";
-        const retStmtNames = { stmt: sqlStmt, names: "" };
+        const retWord = 'RETURNING';
+        const retStmtNames = {
+            stmt: sqlStmt,
+            names: '',
+        };
         const retWordIndex = sqlStmt.toUpperCase().indexOf(retWord);
         if (retWordIndex !== -1) {
             const prefix = sqlStmt.substring(0, retWordIndex);
             retStmtNames.stmt = `${prefix};`;
-            if (retMode.substring(0, 2) === "wA") {
+            if (retMode.substring(0, 2) === 'wA') {
                 const suffix = sqlStmt.substring(retWordIndex + retWord.length);
                 const names = suffix.trim();
-                if (names.endsWith(";")) {
+                if (names.endsWith(';')) {
                     retStmtNames.names = names.substring(0, names.length - 1);
                 }
                 else {
@@ -930,7 +1168,7 @@ class UtilsSQLStatement {
         const primaryKeySets = [];
         for (const match of matches) {
             const keysString = match[1].trim();
-            const keys = keysString.split(",").map((key) => key.trim());
+            const keys = keysString.split(',').map(key => key.trim());
             primaryKeySets.push(keys);
         }
         return primaryKeySets.length === 0 ? null : primaryKeySets;
@@ -938,7 +1176,7 @@ class UtilsSQLStatement {
     getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys) {
         let retWhere = whStmt;
         for (const grpKeys of keys) {
-            const repKeys = grpKeys.join(",") === withRefs.join(",") ? colNames : withRefs;
+            const repKeys = grpKeys.join(',') === withRefs.join(',') ? colNames : withRefs;
             for (const [index, key] of grpKeys.entries()) {
                 retWhere = this.replaceAllString(retWhere, key, repKeys[index]);
             }
@@ -959,20 +1197,20 @@ class UtilsSQLStatement {
         return indices;
     }
     getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames) {
-        let whereStmt = "";
+        let whereStmt = '';
         let stmt = whStmt.substring(6);
         for (let idx = 0; idx < withRefs.length; idx++) {
-            let colType = "withRefsNames";
+            let colType = 'withRefsNames';
             let idxs = this.indicesOf(stmt, withRefs[idx]);
             if (idxs.length === 0) {
                 idxs = this.indicesOf(stmt, colNames[idx]);
-                colType = "colNames";
+                colType = 'colNames';
             }
             if (idxs.length > 0) {
-                let valStr = "";
-                const indicesEqual = this.indicesOf(stmt, "=", idxs[0]);
+                let valStr = '';
+                const indicesEqual = this.indicesOf(stmt, '=', idxs[0]);
                 if (indicesEqual.length > 0) {
-                    const indicesAnd = this.indicesOf(stmt, "AND", indicesEqual[0]);
+                    const indicesAnd = this.indicesOf(stmt, 'AND', indicesEqual[0]);
                     if (indicesAnd.length > 0) {
                         valStr = stmt.substring(indicesEqual[0] + 1, indicesAnd[0] - 1);
                         stmt = stmt.substring(indicesAnd[0] + 3);
@@ -981,26 +1219,26 @@ class UtilsSQLStatement {
                         valStr = stmt.substring(indicesEqual[0] + 1);
                     }
                     if (idx > 0) {
-                        whereStmt += " AND ";
+                        whereStmt += ' AND ';
                     }
-                    if (colType === "withRefsNames") {
-                        whereStmt += colNames[idx] + " = " + valStr;
+                    if (colType === 'withRefsNames') {
+                        whereStmt += colNames[idx] + ' = ' + valStr;
                     }
                     else {
-                        whereStmt += withRefs[idx] + " = " + valStr;
+                        whereStmt += withRefs[idx] + ' = ' + valStr;
                     }
                 }
             }
         }
-        whereStmt = "WHERE " + whereStmt;
+        whereStmt = 'WHERE ' + whereStmt;
         return whereStmt;
     }
     updateWhere(whStmt, withRefs, colNames) {
-        let whereStmt = "";
+        let whereStmt = '';
         if (whStmt.length <= 0) {
             return whereStmt;
         }
-        if (whStmt.toUpperCase().substring(0, 5) !== "WHERE") {
+        if (whStmt.toUpperCase().substring(0, 5) !== 'WHERE') {
             return whereStmt;
         }
         if (withRefs.length === colNames.length) {
@@ -1021,6 +1259,7 @@ utilsSqlstatement.UtilsSQLStatement = UtilsSQLStatement;
 
 Object.defineProperty(utilsSQLite, "__esModule", { value: true });
 utilsSQLite.UtilsSQLite = void 0;
+const UtilsSQL92Compatibility_1$1 = UtilsSQL92Compatibility$1;
 const utilsDelete_1 = utilsDelete;
 const utilsFile_1$4 = utilsFile;
 const utilsSqlstatement_1 = utilsSqlstatement;
@@ -1030,7 +1269,8 @@ class UtilsSQLite {
         this.fileUtil = new utilsFile_1$4.UtilsFile();
         this.statUtil = new utilsSqlstatement_1.UtilsSQLStatement();
         this.delUtil = new utilsDelete_1.UtilsDelete();
-        this.BCSQLite3 = require$$3__default$1["default"];
+        this.sql92Utils = new UtilsSQL92Compatibility_1$1.UtilsSQL92Compatibility();
+        this.BCSQLite3 = require$$4__default$1["default"];
     }
     /**
      * OpenOrCreateDatabase
@@ -1315,7 +1555,7 @@ class UtilsSQLite {
      * @param mDB
      * @param sql
      */
-    execute(mDB, sql, fromJson) {
+    execute(mDB, sql, fromJson, isSQL92) {
         const result = { changes: 0, lastId: -1 };
         const msg = 'Execute';
         let changes = -1;
@@ -1324,11 +1564,8 @@ class UtilsSQLite {
         try {
             initChanges = this.dbChanges(mDB);
             let sqlStmt = sql;
-            if (sql.toLowerCase().includes('DELETE FROM'.toLowerCase()) ||
-                sql.toLowerCase().includes('INSERT INTO'.toLowerCase()) ||
-                sql.toLowerCase().includes('UPDATE'.toLowerCase())) {
-                sqlStmt = this.checkStatements(mDB, sql, fromJson);
-            }
+            // modify sql to sql92 compatible
+            sqlStmt = this.statementsToSQL92(mDB, sql, fromJson, isSQL92);
             this.execDB(mDB, sqlStmt);
             changes = this.dbChanges(mDB) - initChanges;
             lastId = this.getLastId(mDB);
@@ -1341,7 +1578,7 @@ class UtilsSQLite {
             throw new Error(`${msg} ${errmsg}`);
         }
     }
-    checkStatements(mDB, sql, fromJson) {
+    statementsToSQL92(mDB, sql, fromJson, isSQL92) {
         // split the statements in an array of statement
         let sqlStmt = sql.replace(/\n/g, '');
         // deal with trigger
@@ -1351,11 +1588,10 @@ class UtilsSQLite {
         const resArr = [];
         // loop through the statement
         for (const stmt of sqlStmts) {
-            const method = stmt
-                .trim()
+            let rStmt = stmt.trim();
+            const method = rStmt
                 .substring(0, Math.min(stmt.trim().length, 6))
                 .toUpperCase();
-            let rStmt = stmt.trim();
             switch (method) {
                 case 'CREATE':
                     if (rStmt.includes('&END')) {
@@ -1363,24 +1599,29 @@ class UtilsSQLite {
                     }
                     break;
                 case 'DELETE':
-                    if (!fromJson && stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
-                        const whereStmt = this.cleanStatement(`${stmt.trim()}`);
+                    if (!fromJson && rStmt.toLowerCase().includes('WHERE'.toLowerCase())) {
+                        let whereStmt = rStmt;
+                        if (!isSQL92)
+                            whereStmt = this.cleanStatement(rStmt);
                         rStmt = this.deleteSQL(mDB, whereStmt, []);
                     }
                     break;
                 case 'INSERT':
-                    if (stmt.toLowerCase().includes('VALUES'.toLowerCase())) {
-                        rStmt = this.cleanStatement(`${stmt.trim()}`);
+                    if (rStmt.toLowerCase().includes('VALUES'.toLowerCase())) {
+                        if (!isSQL92)
+                            rStmt = this.cleanStatement(rStmt);
                     }
                     break;
                 case 'UPDATE':
-                    if (stmt.toLowerCase().includes('SET'.toLowerCase())) {
-                        rStmt = this.cleanStatement(`${stmt.trim()}`);
+                    if (rStmt.toLowerCase().includes('SET'.toLowerCase())) {
+                        if (!isSQL92)
+                            rStmt = this.cleanStatement(`${stmt.trim()}`);
                     }
                     break;
                 case 'SELECT':
-                    if (!fromJson && stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
-                        rStmt = this.cleanStatement(`${stmt.trim()}`);
+                    if (!fromJson && rStmt.toLowerCase().includes('WHERE'.toLowerCase())) {
+                        if (!isSQL92)
+                            rStmt = this.cleanStatement(rStmt);
                     }
                     break;
             }
@@ -1411,7 +1652,7 @@ class UtilsSQLite {
      * @param set
      * @param fromJson
      */
-    executeSet(mDB, set, fromJson, returnMode) {
+    executeSet(mDB, set, fromJson, returnMode, isSQL92) {
         const ret = { changes: 0, lastId: -1, values: [] };
         let result = { changes: 0, lastId: -1 };
         const msg = 'ExecuteSet';
@@ -1442,7 +1683,11 @@ class UtilsSQLite {
                         result = this.prepareRun(mDB, statement, mVal, fromJson, returnMode);
                     }
                     else {
-                        result = this.prepareRun(mDB, statement, [], fromJson, returnMode);
+                        let nStatement = statement;
+                        if (!isSQL92) {
+                            nStatement = this.cleanStatement(statement);
+                        }
+                        result = this.prepareRun(mDB, nStatement, [], fromJson, returnMode);
                     }
                     ret.changes += result.changes;
                     ret.lastId = result.lastId;
@@ -1465,6 +1710,7 @@ class UtilsSQLite {
      * @param statement
      * @param values
      * @param fromJson
+     * @param returnMode
      */
     prepareRun(mDB, statement, values, fromJson, returnMode) {
         const result = { changes: 0, lastId: -1 };
@@ -1512,8 +1758,7 @@ class UtilsSQLite {
         let result = { changes: 0, lastInsertRowid: -1, values: [] };
         const msg = 'runExec: ';
         try {
-            const cStmt = this.cleanStatement(stmt);
-            const params = this.getStmtAndNames(cStmt, returnMode);
+            const params = this.getStmtAndNames(stmt, returnMode);
             switch (params.mMode) {
                 case 'one': {
                     const iniChanges = this.dbChanges(mDB);
@@ -1528,7 +1773,7 @@ class UtilsSQLite {
                         const res = statement.run(values);
                         result.lastInsertRowid = res.lastInsertRowid;
                         const sql = `SELECT ${params.names} FROM ${params.tableName} WHERE rowid = ${lowerId};`;
-                        const value = this.queryOne(mDB, sql, []);
+                        const value = this.queryOne(mDB, sql, [], true);
                         result.values.push(value);
                     }
                     result.changes = this.dbChanges(mDB) - iniChanges;
@@ -1546,7 +1791,7 @@ class UtilsSQLite {
                         const res = statement.run(values);
                         const upperId = res.lastInsertRowid;
                         const sql = `SELECT ${params.names} FROM ${params.tableName} WHERE rowid BETWEEN ${lowerId} AND ${upperId};`;
-                        result.values = this.queryAll(mDB, sql, []);
+                        result.values = this.queryAll(mDB, sql, [], true);
                         result.lastInsertRowid = res.lastInsertRowid;
                     }
                     result.changes = this.dbChanges(mDB) - iniChanges;
@@ -1675,7 +1920,7 @@ class UtilsSQLite {
                 // Get the column names
                 const colNames = foreignKeyInfo.refKeys;
                 if (colNames.length !== withRefsNames.length) {
-                    const msg = "findReferencesAndUpdate: mismatch length";
+                    const msg = 'findReferencesAndUpdate: mismatch length';
                     throw new Error(msg);
                 }
                 const action = foreignKeyInfo.action;
@@ -1712,8 +1957,7 @@ class UtilsSQLite {
                 else {
                     throw new Error('Not implemented. Please transfer your example to the maintener');
                 }
-                if (results.setStmt.length > 0 &&
-                    results.uWhereStmt.length > 0) {
+                if (results.setStmt.length > 0 && results.uWhereStmt.length > 0) {
                     this.executeUpdateForDelete(mDB, updTableName, results.uWhereStmt, results.setStmt, updColNames, values);
                 }
             }
@@ -1731,14 +1975,16 @@ class UtilsSQLite {
      * @returns
      */
     getReferences(db, tableName) {
-        const sqlStmt = "SELECT sql FROM sqlite_master " +
+        const sqlStmt = 'SELECT sql FROM sqlite_master ' +
             "WHERE sql LIKE('%FOREIGN KEY%') AND sql LIKE('%REFERENCES%') AND " +
-            "sql LIKE('%" + tableName + "%') AND sql LIKE('%ON DELETE%');";
+            "sql LIKE('%" +
+            tableName +
+            "%') AND sql LIKE('%ON DELETE%');";
         try {
-            const res = this.queryAll(db, sqlStmt, []);
+            const res = this.queryAll(db, sqlStmt, [], true);
             // get the reference's string(s)
             let retRefs = [];
-            let tableWithRefs = "";
+            let tableWithRefs = '';
             if (res.length > 0) {
                 const result = this.getRefs(res[0].sql);
                 retRefs = result.foreignKeys;
@@ -1812,7 +2058,7 @@ class UtilsSQLite {
                 }
             }
             const retObj = this.runExec(mDB, stmt, selValues, 'no');
-            lastId = retObj["lastInsertRowid"];
+            lastId = retObj['lastInsertRowid'];
             if (lastId === -1) {
                 const msg = `UPDATE sql_deleted failed for table: ${tableName}`;
                 throw new Error(msg);
@@ -1829,11 +2075,24 @@ class UtilsSQLite {
      * @param sql
      * @param values
      */
-    queryAll(mDB, sql, values) {
+    queryAll(mDB, sql, values, isSQL92) {
         const msg = 'QueryAll';
         try {
-            const cSql = this.cleanStatement(sql);
+            let cSql = sql;
+            if (!isSQL92) {
+                cSql = this.cleanStatement(sql);
+            }
             const stmt = mDB.prepare(cSql);
+            if (!stmt.reader) {
+                // statement doesn't returns data
+                if (values != null && values.length > 0) {
+                    stmt.run(values);
+                }
+                else {
+                    stmt.run();
+                }
+                return [];
+            }
             let rows;
             if (values != null && values.length > 0) {
                 rows = stmt.all(values);
@@ -1857,10 +2116,13 @@ class UtilsSQLite {
      * @param sql
      * @param values
      */
-    queryOne(mDB, sql, values) {
+    queryOne(mDB, sql, values, isSQL92) {
         const msg = 'QueryOne';
         try {
-            const cSql = this.cleanStatement(sql);
+            let cSql = sql;
+            if (!isSQL92) {
+                cSql = this.cleanStatement(sql);
+            }
             const stmt = mDB.prepare(cSql);
             let row;
             if (values != null && values.length > 0) {
@@ -1889,7 +2151,7 @@ class UtilsSQLite {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = this.queryAll(mDb, sql, []);
+            const retQuery = this.queryAll(mDb, sql, [], true);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -1911,7 +2173,7 @@ class UtilsSQLite {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = this.queryAll(mDb, sql, []);
+            const retQuery = this.queryAll(mDb, sql, [], true);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -2042,31 +2304,25 @@ class UtilsSQLite {
     }
     searchForRelatedItems(mDB, updTableName, tableName, whStmt, withRefsNames, colNames, values) {
         const relatedItems = [];
-        let key = "";
-        const t1Names = withRefsNames.map((name) => `t1.${name}`);
-        const t2Names = colNames.map((name) => `t2.${name}`);
-        console.log(" whStmt ", whStmt);
-        console.log(" t1Names ", t1Names);
-        console.log(" t2Names ", t2Names);
+        let key = '';
+        const t1Names = withRefsNames.map(name => `t1.${name}`);
+        const t2Names = colNames.map(name => `t2.${name}`);
         try {
             // addPrefix to the whereClause and swap colNames with  withRefsNames
-            let whereClause = this.statUtil
-                .addPrefixToWhereClause(whStmt, colNames, withRefsNames, "t2.");
+            let whereClause = this.statUtil.addPrefixToWhereClause(whStmt, colNames, withRefsNames, 't2.');
             // look at the whereclause and change colNames with  withRefsNames
-            if (whereClause.endsWith(";")) {
+            if (whereClause.endsWith(';')) {
                 whereClause = whereClause.slice(0, -1);
             }
-            console.log(" whereClause ", whereClause);
             const resultString = t1Names
                 .map((t1, index) => `${t1} = ${t2Names[index]}`)
-                .join(" AND ");
+                .join(' AND ');
             const sql = `SELECT t1.rowid FROM ${updTableName} t1 ` +
                 `JOIN ${tableName} t2 ON ${resultString} ` +
                 `WHERE ${whereClause} AND t1.sql_deleted = 0;`;
-            console.log(" sql ", sql);
-            const vals = this.queryAll(mDB, sql, values);
+            const vals = this.queryAll(mDB, sql, values, true);
             if (vals.length > 0) {
-                key = (Object.keys(vals[0]))[0];
+                key = Object.keys(vals[0])[0];
                 relatedItems.push(...vals);
             }
             return { key: key, relatedItems: relatedItems };
@@ -2084,7 +2340,7 @@ class UtilsSQLite {
             stmt.toLowerCase().includes('DELETE FROM'.toLowerCase())) {
             // check for JSON string
             sql = this.dealJsonString(stmt);
-            sql = sql.replaceAll('"', "'");
+            sql = this.sql92Utils.compatibleSQL92(sql);
             sql = sql.replaceAll('§', '"');
         }
         else {
@@ -2178,7 +2434,7 @@ class UtilsJson {
         }
         let query = 'SELECT name FROM sqlite_master WHERE ';
         query += `type='table' AND name='${tableName}';`;
-        const rows = this.sqliteUtil.queryAll(mDB, query, []);
+        const rows = this.sqliteUtil.queryAll(mDB, query, [], true);
         if (rows.length > 0) {
             ret = true;
         }
@@ -2198,7 +2454,7 @@ class UtilsJson {
         }
         let query = 'SELECT name FROM sqlite_master WHERE ';
         query += `type='view' AND name='${viewName}';`;
-        const rows = this.sqliteUtil.queryAll(mDB, query, []);
+        const rows = this.sqliteUtil.queryAll(mDB, query, [], true);
         if (rows.length > 0) {
             ret = true;
         }
@@ -2215,7 +2471,8 @@ class UtilsJson {
         let changes = 0;
         try {
             // start a transaction
-            this.sqliteUtil.beginTransaction(mDB, true);
+            this.sqliteUtil.beginTransaction(mDB.database, true);
+            mDB.setIsTransActive(true);
         }
         catch (err) {
             throw new Error(`${msg} ${err}`);
@@ -2224,11 +2481,12 @@ class UtilsJson {
         if (stmts.length > 0) {
             const schemaStmt = stmts.join('\n');
             try {
-                const results = this.sqliteUtil.execute(mDB, schemaStmt, true);
+                const results = this.sqliteUtil.execute(mDB.database, schemaStmt, true, true);
                 changes = results.changes;
                 if (changes < 0) {
                     try {
-                        this.sqliteUtil.rollbackTransaction(mDB, true);
+                        this.sqliteUtil.rollbackTransaction(mDB.database, true);
+                        mDB.setIsTransActive(false);
                     }
                     catch (err) {
                         throw new Error(`${msg} changes < 0 ${err}`);
@@ -2238,7 +2496,8 @@ class UtilsJson {
             catch (err) {
                 const msg = err;
                 try {
-                    this.sqliteUtil.rollbackTransaction(mDB, true);
+                    this.sqliteUtil.rollbackTransaction(mDB.database, true);
+                    mDB.setIsTransActive(false);
                     throw new Error(`CreateSchema: ${msg}`);
                 }
                 catch (err) {
@@ -2247,7 +2506,8 @@ class UtilsJson {
             }
         }
         try {
-            this.sqliteUtil.commitTransaction(mDB, true);
+            this.sqliteUtil.commitTransaction(mDB.database, true);
+            mDB.setIsTransActive(false);
             return changes;
         }
         catch (err) {
@@ -2532,7 +2792,7 @@ class UtilsJson {
             else {
                 throw new Error(`${msg} Table ${tableName} no names`);
             }
-            const retValues = this.sqliteUtil.queryAll(mDb, query, []);
+            const retValues = this.sqliteUtil.queryAll(mDb, query, [], true);
             for (const rValue of retValues) {
                 const row = [];
                 for (const rName of rowNames) {
@@ -2611,7 +2871,7 @@ class UtilsJson {
         if (typeof key === 'string')
             query += `'${key}';`;
         try {
-            const resQuery = this.sqliteUtil.queryAll(mDB, query, []);
+            const resQuery = this.sqliteUtil.queryAll(mDB, query, [], true);
             if (resQuery.length === 1)
                 ret = true;
             return ret;
@@ -2985,7 +3245,7 @@ class UtilsJson {
         const msg = 'CreateView';
         const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
         try {
-            const results = this.sqliteUtil.execute(mDB, stmt, true);
+            const results = this.sqliteUtil.execute(mDB, stmt, true, true);
             if (results.changes < 0) {
                 throw new Error(`${msg} ${view.name} failed`);
             }
@@ -3077,7 +3337,7 @@ class ExportToJson {
         sql += "AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = this.sqliteUtil.queryAll(mDb, sql, []);
+            retQuery = this.sqliteUtil.queryAll(mDb, sql, [], true);
             return retQuery;
         }
         catch (err) {
@@ -3090,7 +3350,7 @@ class ExportToJson {
         try {
             // get the last sync date
             const stmt = `SELECT sync_date FROM sync_table WHERE id = ?;`;
-            const row = this.sqliteUtil.queryOne(mDb, stmt, [2]);
+            const row = this.sqliteUtil.queryOne(mDb, stmt, [2], true);
             if (row != null) {
                 const key = Object.keys(row)[0];
                 retDate = row[key];
@@ -3122,7 +3382,7 @@ class ExportToJson {
             else {
                 stmt = `INSERT INTO sync_table (sync_date) VALUES (${sDate});`;
             }
-            const results = this.sqliteUtil.execute(mDb, stmt, false);
+            const results = this.sqliteUtil.execute(mDb, stmt, false, true);
             if (results.changes < 0) {
                 return { result: false, message: `${msg} failed` };
             }
@@ -3182,7 +3442,7 @@ class ExportToJson {
         sql += "type='view' AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = this.sqliteUtil.queryAll(mDb, sql, []);
+            retQuery = this.sqliteUtil.queryAll(mDb, sql, [], true);
             for (const query of retQuery) {
                 const view = {};
                 view.name = query.name;
@@ -3204,7 +3464,7 @@ class ExportToJson {
         let retDate = -1;
         // get the last sync date
         const stmt = `SELECT sync_date FROM sync_table WHERE id = ?;`;
-        const row = this.sqliteUtil.queryOne(mDb, stmt, [1]);
+        const row = this.sqliteUtil.queryOne(mDb, stmt, [1], true);
         if (row != null) {
             const key = Object.keys(row)[0];
             retDate = row[key];
@@ -3378,7 +3638,7 @@ class ExportToJson {
             let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
             stmt += `type = 'index' AND tbl_name = '${tableName}' `;
             stmt += `AND sql NOTNULL;`;
-            const retIndexes = this.sqliteUtil.queryAll(mDb, stmt, []);
+            const retIndexes = this.sqliteUtil.queryAll(mDb, stmt, [], true);
             if (retIndexes.length > 0) {
                 for (const rIndex of retIndexes) {
                     const keys = Object.keys(rIndex);
@@ -3428,7 +3688,7 @@ class ExportToJson {
             let stmt = 'SELECT name,tbl_name,sql FROM sqlite_master WHERE ';
             stmt += `type = 'trigger' AND tbl_name = '${tableName}' `;
             stmt += `AND sql NOT NULL;`;
-            const retTriggers = this.sqliteUtil.queryAll(mDb, stmt, []);
+            const retTriggers = this.sqliteUtil.queryAll(mDb, stmt, [], true);
             if (retTriggers.length > 0) {
                 for (const rTrg of retTriggers) {
                     const keys = Object.keys(rTrg);
@@ -3632,7 +3892,7 @@ class ExportToJson {
                 // get total count of the table
                 let stmt = 'SELECT count(*) AS tcount  ';
                 stmt += `FROM ${rTable.name};`;
-                let retQuery = this.sqliteUtil.queryAll(mDb, stmt, []);
+                let retQuery = this.sqliteUtil.queryAll(mDb, stmt, [], true);
                 if (retQuery.length != 1) {
                     errmsg = `${msg} total count not returned`;
                     break;
@@ -3642,7 +3902,7 @@ class ExportToJson {
                 stmt = 'SELECT count(*) AS mcount FROM ';
                 stmt += `${rTable.name} WHERE last_modified > `;
                 stmt += `${syncDate};`;
-                retQuery = this.sqliteUtil.queryAll(mDb, stmt, []);
+                retQuery = this.sqliteUtil.queryAll(mDb, stmt, [], true);
                 if (retQuery.length != 1)
                     break;
                 const totalModifiedCount = retQuery[0]['mcount'];
@@ -3749,7 +4009,7 @@ class UtilsDrop {
         let stmt = 'SELECT name FROM sqlite_master WHERE ';
         stmt += `type = '${type}' ${stmt1};`;
         try {
-            const elements = this.sqliteUtil.queryAll(db, stmt, []);
+            const elements = this.sqliteUtil.queryAll(db, stmt, [], true);
             if (elements.length > 0) {
                 const upType = type.toUpperCase();
                 const statements = [];
@@ -3808,7 +4068,7 @@ class UtilsDrop {
             statements.push(stmt);
         }
         try {
-            const results = this.sqliteUtil.execute(db, statements.join('\n'), false);
+            const results = this.sqliteUtil.execute(db, statements.join('\n'), false, true);
             if (results.changes < 0) {
                 throw new Error('DropTempTables: changes < 0');
             }
@@ -3842,10 +4102,10 @@ class ImportFromJson {
         const version = jsonData.version;
         try {
             // set User Version PRAGMA
-            this.sqliteUtil.setVersion(mDB, version);
+            this.sqliteUtil.setVersion(mDB.database, version);
             // DROP ALL when mode="full"
             if (jsonData.mode === 'full') {
-                this.dropUtil.dropAll(mDB);
+                this.dropUtil.dropAll(mDB.database);
             }
             // create database schema
             changes = this.jsonUtil.createSchema(mDB, jsonData);
@@ -3862,7 +4122,8 @@ class ImportFromJson {
         let message = '';
         try {
             // start a transaction
-            this.sqliteUtil.beginTransaction(mDB, true);
+            this.sqliteUtil.beginTransaction(mDB.database, true);
+            mDB.setIsTransActive(true);
         }
         catch (err) {
             throw new Error(`${msg} ${err}`);
@@ -3871,7 +4132,7 @@ class ImportFromJson {
             if (jTable.values != null && jTable.values.length >= 1) {
                 // Create the table's data
                 try {
-                    results = this.jsonUtil.createDataTable(mDB, jTable, jsonData.mode);
+                    results = this.jsonUtil.createDataTable(mDB.database, jTable, jsonData.mode);
                     if (results.lastId < 0)
                         break;
                     isValue = true;
@@ -3885,7 +4146,8 @@ class ImportFromJson {
         }
         if (isValue) {
             try {
-                this.sqliteUtil.commitTransaction(mDB, true);
+                this.sqliteUtil.commitTransaction(mDB.database, true);
+                mDB.setIsTransActive(false);
                 return results.changes;
             }
             catch (err) {
@@ -3895,7 +4157,8 @@ class ImportFromJson {
         else {
             if (message.length > 0) {
                 try {
-                    this.sqliteUtil.rollbackTransaction(mDB, true);
+                    this.sqliteUtil.rollbackTransaction(mDB.database, true);
+                    mDB.setIsTransActive(false);
                     throw new Error(`${msg} ${message}`);
                 }
                 catch (err) {
@@ -3920,7 +4183,8 @@ class ImportFromJson {
         let results;
         try {
             // start a transaction
-            this.sqliteUtil.beginTransaction(mDB, true);
+            this.sqliteUtil.beginTransaction(mDB.database, true);
+            mDB.setIsTransActive(true);
         }
         catch (err) {
             throw new Error(`${msg} ${err}`);
@@ -3929,7 +4193,7 @@ class ImportFromJson {
             if (jView.value != null) {
                 // Create the view
                 try {
-                    results = this.jsonUtil.createView(mDB, jView);
+                    results = this.jsonUtil.createView(mDB.database, jView);
                     isView = true;
                 }
                 catch (err) {
@@ -3941,7 +4205,8 @@ class ImportFromJson {
         }
         if (isView) {
             try {
-                this.sqliteUtil.commitTransaction(mDB, true);
+                this.sqliteUtil.commitTransaction(mDB.database, true);
+                mDB.setIsTransActive(false);
                 return results.changes;
             }
             catch (err) {
@@ -3951,7 +4216,8 @@ class ImportFromJson {
         else {
             if (message.length > 0) {
                 try {
-                    this.sqliteUtil.rollbackTransaction(mDB, true);
+                    this.sqliteUtil.rollbackTransaction(mDB.database, true);
+                    mDB.setIsTransActive(false);
                     throw new Error(`${msg} ${message}`);
                 }
                 catch (err) {
@@ -3981,7 +4247,7 @@ class UtilsSecret {
         this.globalUtil = new GlobalSQLite_1$2.GlobalSQLite();
         this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
         this.fileUtil = new utilsFile_1$3.UtilsFile();
-        this.storage = require$$3__default$2["default"];
+        this.storage = require$$3__default$1["default"];
     }
     isSecretStored() {
         const secret = this.getPassphrase();
@@ -4226,13 +4492,13 @@ class UtilsUpgrade {
                 }
                 try {
                     // set Foreign Keys Off
-                    await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, false);
-                    const initChanges = await this.sqliteUtil.dbChanges(mDB);
+                    this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB.database, false);
+                    const initChanges = this.sqliteUtil.dbChanges(mDB.database);
                     await this.executeStatementsProcess(mDB, statements);
-                    await this.sqliteUtil.setVersion(mDB, versionKey);
+                    this.sqliteUtil.setVersion(mDB.database, versionKey);
                     // set Foreign Keys On
-                    await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, true);
-                    changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
+                    this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB.database, true);
+                    changes = (await this.sqliteUtil.dbChanges(mDB.database)) - initChanges;
                 }
                 catch (err) {
                     return Promise.reject(`onUpgrade: ${err}`);
@@ -4248,15 +4514,18 @@ class UtilsUpgrade {
      */
     async executeStatementsProcess(mDB, statements) {
         try {
-            await this.sqliteUtil.beginTransaction(mDB, true);
+            this.sqliteUtil.beginTransaction(mDB.database, true);
+            mDB.setIsTransActive(true);
             for (const statement of statements) {
-                await this.sqliteUtil.execute(mDB, statement, false);
+                this.sqliteUtil.execute(mDB.database, statement, false, true);
             }
-            await this.sqliteUtil.commitTransaction(mDB, true);
+            this.sqliteUtil.commitTransaction(mDB.database, true);
+            mDB.setIsTransActive(false);
             return Promise.resolve();
         }
         catch (err) {
-            await this.sqliteUtil.rollbackTransaction(mDB, true);
+            this.sqliteUtil.rollbackTransaction(mDB.database, true);
+            mDB.setIsTransActive(false);
             return Promise.reject(`ExecuteStatementProcess: ${err}`);
         }
     }
@@ -4270,6 +4539,7 @@ const exportToJson_1 = exportToJson;
 const importFromJson_1 = importFromJson;
 const utilsJson_1$1 = utilsJson;
 const utilsJsonEncryption_1$1 = utilsJsonEncryption;
+const UtilsSQL92Compatibility_1 = UtilsSQL92Compatibility$1;
 const utilsEncryption_1 = utilsEncryption;
 const utilsFile_1$1 = utilsFile;
 const utilsSQLite_1$1 = utilsSQLite;
@@ -4288,6 +4558,7 @@ class Database {
         this.importFromJsonUtil = new importFromJson_1.ImportFromJson();
         this.exportToJsonUtil = new exportToJson_1.ExportToJson();
         this.upgradeVersionDict = {};
+        this.sql92Utils = new UtilsSQL92Compatibility_1.UtilsSQL92Compatibility();
         this.dbName = dbName;
         this._encrypted = encrypted;
         this._mode = mode;
@@ -4297,6 +4568,7 @@ class Database {
         this.upgradeVersionDict = upgDict;
         this.pathDB = this.fileUtil.getFilePath(dbName);
         this._isDbOpen = false;
+        this.isTransactionActive = false;
         this.globalUtil = globalUtil ? globalUtil : new GlobalSQLite_1$1.GlobalSQLite();
         if (this.pathDB.length === 0)
             throw new Error('Could not generate a path to ' + dbName);
@@ -4340,7 +4612,7 @@ class Database {
                     try {
                         await this.fileUtil.copyFileName(this.dbName, `backup-${this.dbName}`);
                         // execute the upgrade flow process
-                        await this.upgradeUtil.onUpgrade(this.database, this.upgradeVersionDict, curVersion, this.version);
+                        await this.upgradeUtil.onUpgrade(this, this.upgradeVersionDict, curVersion, this.version);
                         // delete the backup database
                         await this.fileUtil.deleteFileName(`backup-${this.dbName}`);
                     }
@@ -4369,8 +4641,8 @@ class Database {
      * @returns Promise<boolean>
      */
     dbClose() {
-        this.ensureDatabaseIsOpen();
         try {
+            this.ensureDatabaseIsOpen();
             this.sqliteUtil.closeDB(this.database);
         }
         catch (err) {
@@ -4381,6 +4653,70 @@ class Database {
         }
         return;
     }
+    /**
+     * IsTransActive
+     * Is Database Transaction Active
+     * @returns
+     */
+    isTransActive() {
+        return this.isTransactionActive;
+    }
+    /**
+     * SetIsTransActive
+     * Set the Database Transaction to Active
+     * @returns
+     */
+    setIsTransActive(value) {
+        this.isTransactionActive = value;
+    }
+    /**
+     * DbBeginTransaction
+     * Database Begin Transaction
+     * @returns
+     */
+    dbBeginTransaction() {
+        try {
+            this.ensureDatabaseIsOpen();
+            this.sqliteUtil.beginTransaction(this.database, true);
+            this.setIsTransActive(true);
+            return 0;
+        }
+        catch (err) {
+            throw new Error(`DbBeginTransaction: ${err}`);
+        }
+    }
+    /**
+     * DbCommitTransaction
+     * Database Commit Transaction
+     * @returns
+     */
+    dbCommitTransaction() {
+        try {
+            this.ensureDatabaseIsOpen();
+            this.sqliteUtil.commitTransaction(this.database, true);
+            this.setIsTransActive(false);
+            return 0;
+        }
+        catch (err) {
+            throw new Error(`DbCommitTransaction: ${err}`);
+        }
+    }
+    /**
+     * DbRollbackTransaction
+     * Database Rollback Transaction
+     * @returns
+     */
+    dbRollbackTransaction() {
+        try {
+            this.ensureDatabaseIsOpen();
+            this.sqliteUtil.rollbackTransaction(this.database, true);
+            this.setIsTransActive(false);
+            return 0;
+        }
+        catch (err) {
+            throw new Error(`DbCommitTransaction: ${err}`);
+        }
+    }
     /**
      * ChangeSecret
      * open the @journeyapps/sqlcipher sqlite3 database
@@ -4493,7 +4829,7 @@ class Database {
                               );`;
                     stmts += `INSERT INTO sync_table (sync_date) VALUES (
                               ${date});`;
-                    const results = this.sqliteUtil.execute(this.database, stmts, false);
+                    const results = this.sqliteUtil.execute(this.database, stmts, false, true);
                     changes = results.changes;
                     if (results.changes < 0) {
                         throw new Error(`CreateSyncTable: failed changes < 0`);
@@ -4528,7 +4864,7 @@ class Database {
             const syncDateUnixTimestamp = Math.round(new Date(syncDate).getTime() / 1000);
             let stmt = `UPDATE sync_table SET sync_date = `;
             stmt += `${syncDateUnixTimestamp} WHERE id = 1;`;
-            const results = this.sqliteUtil.execute(this.database, stmt, false);
+            const results = this.sqliteUtil.execute(this.database, stmt, false, true);
             if (results.changes < 0) {
                 return { result: false, message: 'setSyncDate failed' };
             }
@@ -4568,9 +4904,11 @@ class Database {
      * ExecuteSQL
      * execute raw sql statements store in a string
      * @param sql: string
+     * @param transaction: boolean
+     * @param isSQL92: boolean
      * @returns Promise<number>
      */
-    executeSQL(sql, transaction) {
+    executeSQL(sql, transaction, isSQL92) {
         this.ensureDatabaseIsOpen();
         try {
             if (transaction) {
@@ -4578,7 +4916,7 @@ class Database {
                 console.log(`$$$ in executeSQL journal_mode: ${mode} $$$`);
                 this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
             }
-            const results = this.sqliteUtil.execute(this.database, sql, false);
+            const results = this.sqliteUtil.execute(this.database, sql, false, isSQL92);
             if (results.changes < 0) {
                 throw new Error('ExecuteSQL: changes < 0');
             }
@@ -4605,12 +4943,13 @@ class Database {
      * execute a sql query with/without binding values
      * @param sql: string
      * @param values: string[]
+     * @param isSQL92: boolean
      * @returns Promise<any[]>
      */
-    selectSQL(sql, values) {
+    selectSQL(sql, values, isSQL92) {
         this.ensureDatabaseIsOpen();
         try {
-            const selectResult = this.sqliteUtil.queryAll(this.database, sql, values);
+            const selectResult = this.sqliteUtil.queryAll(this.database, sql, values, isSQL92);
             return selectResult;
         }
         catch (err) {
@@ -4622,9 +4961,10 @@ class Database {
      * execute a raw sql statement with/without binding values
      * @param sql: string
      * @param values: string[]
+     * @param isSQL92: boolean,
      * @returns Promise<{changes:number, lastId:number}>
      */
-    runSQL(statement, values, transaction, returnMode) {
+    runSQL(statement, values, transaction, returnMode, isSQL92) {
         this.ensureDatabaseIsOpen();
         try {
             // start a transaction
@@ -4638,7 +4978,11 @@ class Database {
             throw new Error(`RunSQL: ${err}`);
         }
         try {
-            const results = this.sqliteUtil.prepareRun(this.database, statement, values, false, returnMode);
+            let nStmt = statement;
+            if (!isSQL92 && values.length === 0) {
+                nStmt = this.sql92Utils.compatibleSQL92(statement);
+            }
+            const results = this.sqliteUtil.prepareRun(this.database, nStmt, values, false, returnMode);
             if (results.lastId < 0) {
                 if (transaction) {
                     this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
@@ -4661,9 +5005,12 @@ class Database {
      * ExecSet
      * execute a set of raw sql statements with/without binding values
      * @param set: any[]
+     * @param transaction: boolean,
+     * @param returnMode: string,
+     * @param isSQL92: boolean,
      * @returns Promise<{changes:number, lastId:number}>
      */
-    execSet(set, transaction, returnMode) {
+    execSet(set, transaction, returnMode, isSQL92) {
         this.ensureDatabaseIsOpen();
         let results = { changes: 0, lastId: -1 };
         try {
@@ -4678,7 +5025,7 @@ class Database {
             throw new Error(`ExecSet: ${err}`);
         }
         try {
-            results = this.sqliteUtil.executeSet(this.database, set, false, returnMode);
+            results = this.sqliteUtil.executeSet(this.database, set, false, returnMode, isSQL92);
             if (transaction) {
                 this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
             }
@@ -4729,15 +5076,15 @@ class Database {
             this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, false);
             if (jsonData.tables && jsonData.tables.length > 0) {
                 // create the database schema
-                changes = this.importFromJsonUtil.createDatabaseSchema(this.database, jsonData);
+                changes = this.importFromJsonUtil.createDatabaseSchema(this, jsonData);
                 if (changes != -1) {
                     // create the tables data
-                    changes += this.importFromJsonUtil.createTablesData(this.database, jsonData);
+                    changes += this.importFromJsonUtil.createTablesData(this, jsonData);
                 }
             }
             if (jsonData.views && jsonData.views.length > 0) {
                 // create the views
-                changes += this.importFromJsonUtil.createViews(this.database, jsonData);
+                changes += this.importFromJsonUtil.createViews(this, jsonData);
             }
             // set Foreign Keys On
             this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, true);
@@ -4747,7 +5094,7 @@ class Database {
             throw new Error(`ImportJson: ${err}`);
         }
     }
-    exportJson(mode) {
+    exportJson(mode, encrypted) {
         const inJson = {};
         inJson.database = this.dbName.slice(0, -9);
         inJson.version = this.version;
@@ -4766,7 +5113,7 @@ class Database {
                 throw new Error(msg);
             }
             let isValid = this.jsonUtil.isJsonSQLite(jsonResult);
-            if (this._encrypted && this._isEncryption) {
+            if (this._encrypted && this._isEncryption && encrypted) {
                 jsonResult.overwrite = true;
                 jsonResult.encrypted = true;
                 const base64Str = this.jsonEncryptUtil.encryptJSONObject(jsonResult);
@@ -4907,6 +5254,78 @@ class CapacitorSQLite {
             throw new Error(`Close: ${msg}`);
         }
     }
+    async beginTransaction(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const connName = 'RW_' + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const changes = database.dbBeginTransaction();
+                return { changes: { changes: changes } };
+            }
+            catch (err) {
+                throw new Error(`BeginTransaction: ${err}`);
+            }
+        }
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`BeginTransaction: ${msg}`);
+        }
+    }
+    async commitTransaction(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const connName = 'RW_' + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const changes = database.dbCommitTransaction();
+                return { changes: { changes: changes } };
+            }
+            catch (err) {
+                throw new Error(`CommitTransaction: ${err}`);
+            }
+        }
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`CommitTransaction: ${msg}`);
+        }
+    }
+    async rollbackTransaction(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const connName = 'RW_' + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const changes = database.dbRollbackTransaction();
+                return { changes: { changes: changes } };
+            }
+            catch (err) {
+                throw new Error(`RollbackTransaction: ${err}`);
+            }
+        }
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`RollbackTransaction: ${msg}`);
+        }
+    }
+    async isTransactionActive(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const connName = 'RW_' + dbName;
+        const database = this.getDatabaseConnectionOrThrowError(connName);
+        if (database.isDBOpen()) {
+            try {
+                const ret = database.isTransActive();
+                return { result: ret };
+            }
+            catch (err) {
+                throw new Error(`IsTransactionActive: ${err}`);
+            }
+        }
+        else {
+            const msg = `Database ${dbName} not opened`;
+            throw new Error(`IsTransactionActive: ${msg}`);
+        }
+    }
     async getVersion(options) {
         const dbName = this.getOptionValue(options, 'database');
         const readonly = options.readonly ? options.readonly : false;
@@ -4954,6 +5373,7 @@ class CapacitorSQLite {
         const statements = this.getOptionValue(options, 'statements');
         const transaction = this.getOptionValue(options, 'transaction', true);
         const readonly = options.readonly ? options.readonly : false;
+        const isSQL92 = (Object.keys(options)).includes('isSQL92') ? options.isSQL92 : true;
         const connName = 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
@@ -4962,7 +5382,7 @@ class CapacitorSQLite {
                 throw new Error(`Execute: ${msg}`);
             }
             try {
-                const executeResult = database.executeSQL(statements, transaction);
+                const executeResult = database.executeSQL(statements, transaction, isSQL92);
                 if (executeResult < 0) {
                     throw new Error('Execute changes < 0');
                 }
@@ -4985,6 +5405,7 @@ class CapacitorSQLite {
         const transaction = this.getOptionValue(options, 'transaction', true);
         const readonly = options.readonly ? options.readonly : false;
         const returnMode = options.returnMode ? options.returnMode : 'no';
+        const isSQL92 = (Object.keys(options)).includes('isSQL92') ? options.isSQL92 : true;
         const connName = 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
         for (const sStmt of setOfStatements) {
@@ -4998,7 +5419,7 @@ class CapacitorSQLite {
                 throw new Error(`ExecuteSet failed: ${msg}`);
             }
             try {
-                const execSetResult = database.execSet(setOfStatements, transaction, returnMode);
+                const execSetResult = database.execSet(setOfStatements, transaction, returnMode, isSQL92);
                 if (execSetResult.lastId < 0) {
                     throw new Error(`ExecuteSet failed changes <0`);
                 }
@@ -5022,6 +5443,7 @@ class CapacitorSQLite {
         const transaction = this.getOptionValue(options, 'transaction', true);
         const readonly = options.readonly ? options.readonly : false;
         const returnMode = options.returnMode ? options.returnMode : 'no';
+        const isSQL92 = (Object.keys(options)).includes('isSQL92') ? options.isSQL92 : true;
         const connName = 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
@@ -5030,7 +5452,7 @@ class CapacitorSQLite {
                 throw new Error(`Run failed: ${msg}`);
             }
             try {
-                const runResult = database.runSQL(statement, values, transaction, returnMode);
+                const runResult = database.runSQL(statement, values, transaction, returnMode, isSQL92);
                 return { changes: runResult };
             }
             catch (err) {
@@ -5050,11 +5472,12 @@ class CapacitorSQLite {
             throw new Error('Query: Statement may not be an empty string.');
         }
         const readonly = options.readonly ? options.readonly : false;
+        const isSQL92 = (Object.keys(options)).includes('isSQL92') ? options.isSQL92 : true;
         const connName = readonly ? 'RO_' + dbName : 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
             try {
-                const queryResult = database.selectSQL(statement, values);
+                const queryResult = database.selectSQL(statement, values, isSQL92);
                 return { values: queryResult };
             }
             catch (err) {
@@ -5197,12 +5620,13 @@ class CapacitorSQLite {
     async exportToJson(options) {
         const dbName = this.getOptionValue(options, 'database');
         const exportMode = this.getOptionValue(options, 'jsonexportmode');
-        const readonly = options.readonly ? options.readonly : false;
+        const readonly = this.getOptionValue(options, 'readonly', false);
+        const encrypted = this.getOptionValue(options, 'encrypted', false);
         const connName = readonly ? 'RO_' + dbName : 'RW_' + dbName;
         const database = this.getDatabaseConnectionOrThrowError(connName);
         if (database.isDBOpen()) {
             try {
-                const exportJsonResult = database.exportJson(exportMode);
+                const exportJsonResult = database.exportJson(exportMode, encrypted);
                 const resultKeys = Object.keys(exportJsonResult);
                 if (resultKeys.includes('message')) {
                     throw new Error(`exportToJson: ${exportJsonResult.message}`);