@capacitor-community/sqlite 5.0.7-1 → 5.0.7

package/electron/dist/plugin.js

@@ -9,9 +9,9 @@ var require$$3 = require('node-fetch');
 var require$$4 = require('os');
 var require$$5 = require('jszip');
 var require$$6 = require('electron');
-var require$$1$1 = require('better-sqlite3-multiple-ciphers');
+var require$$4$1 = require('better-sqlite3-multiple-ciphers');
 var require$$3$1 = require('electron-json-storage');
-var require$$1$2 = require('crypto');
+var require$$1$1 = require('crypto');
 var require$$2$1 = require('crypto-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -23,9 +23,9 @@ 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$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$4__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$4$1);
 var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
-var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 
 var src = {};
@@ -48,6 +48,330 @@ 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 });
+utilsDelete.UtilsDelete = void 0;
+class UtilsDeleteError {
+    constructor(message) {
+        this.message = message;
+    }
+    static upDateWhereForDefault(message) {
+        return new UtilsDeleteError(message);
+    }
+    static upDateWhereForRestrict(message) {
+        return new UtilsDeleteError(message);
+    }
+    static upDateWhereForCascade(message) {
+        return new UtilsDeleteError(message);
+    }
+    static executeUpdateForDelete(message) {
+        return new UtilsDeleteError(message);
+    }
+}
+class UtilsDelete {
+    getReferencedTableName(refValue) {
+        let tableName = '';
+        if (refValue.length > 0) {
+            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
+            if (arr.length === 2) {
+                const oPar = arr[1].indexOf('(');
+                tableName = arr[1].substring(0, oPar).trim();
+            }
+        }
+        return tableName;
+    }
+    upDateWhereForDefault(withRefsNames, results) {
+        let setStmt = '';
+        let uWhereStmt = '';
+        try {
+            const key = results.key;
+            const cols = [];
+            for (const relItem of results.relatedItems) {
+                const mVal = relItem[key];
+                if (mVal !== undefined) {
+                    cols.push(mVal);
+                }
+            }
+            // Create the set statement
+            for (const name of withRefsNames) {
+                setStmt += `${name} = NULL, `;
+            }
+            setStmt += 'sql_deleted = 0';
+            // Create the where statement
+            uWhereStmt = `WHERE ${key} IN (`;
+            for (const col of cols) {
+                uWhereStmt += `${col},`;
+            }
+            if (uWhereStmt.endsWith(',')) {
+                uWhereStmt = uWhereStmt.slice(0, -1);
+            }
+            uWhereStmt += ');';
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForDefault(msg);
+        }
+        return { setStmt, uWhereStmt };
+    }
+    upDateWhereForRestrict(results) {
+        try {
+            const setStmt = '';
+            const uWhereStmt = '';
+            if (results.relatedItems.length > 0) {
+                const msg = 'Restrict mode related items exist, please delete them first';
+                throw UtilsDeleteError.upDateWhereForRestrict(msg);
+            }
+            return { setStmt, uWhereStmt };
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForRestrict(msg);
+        }
+    }
+    upDateWhereForCascade(results) {
+        let setStmt = '';
+        let uWhereStmt = '';
+        try {
+            const key = results.key;
+            const cols = [];
+            for (const relItem of results.relatedItems) {
+                const mVal = relItem[key];
+                if (mVal !== undefined) {
+                    cols.push(mVal);
+                }
+            }
+            setStmt += 'sql_deleted = 1';
+            // Create the where statement
+            uWhereStmt = `WHERE ${key} IN (`;
+            for (const col of cols) {
+                uWhereStmt += `${col},`;
+            }
+            if (uWhereStmt.endsWith(',')) {
+                uWhereStmt = uWhereStmt.slice(0, -1);
+            }
+            uWhereStmt += ');';
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw UtilsDeleteError.upDateWhereForCascade(msg);
+        }
+        return { setStmt, uWhereStmt };
+    }
+    getCurrentTimeAsInteger() {
+        const currentTime = Math.floor(Date.now() / 1000);
+        return currentTime;
+    }
+    checkValuesMatch(array1, array2) {
+        for (const value of array1) {
+            if (!array2.includes(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+utilsDelete.UtilsDelete = UtilsDelete;
+
 var utilsFile = {};
 
 Object.defineProperty(utilsFile, "__esModule", { value: true });
@@ -653,14 +977,300 @@ class UtilsFile {
 }
 utilsFile.UtilsFile = UtilsFile;
 
+var utilsSqlstatement = {};
+
+Object.defineProperty(utilsSqlstatement, "__esModule", { value: true });
+utilsSqlstatement.UtilsSQLStatement = void 0;
+class UtilsSQLStatement {
+    constructor() {
+        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);
+                return modifiedStr;
+            }
+            return originalStr;
+        };
+    }
+    extractTableName(statement) {
+        const pattern = /(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+([^\s]+)/i;
+        const match = statement.match(pattern);
+        if (match?.[1]) {
+            const tableName = match[1];
+            return tableName;
+        }
+        return null;
+    }
+    extractWhereClause(statement) {
+        const pattern = /WHERE(.+?)(?:ORDER\s+BY|LIMIT|$)/i;
+        const match = statement.match(pattern);
+        if (match?.[1]) {
+            const whereClause = match[1].trim();
+            return whereClause;
+        }
+        return null;
+    }
+    addPrefixToWhereClause(whereClause, colNames, refNames, prefix) {
+        let columnValuePairs;
+        if (whereClause.includes('AND')) {
+            // Split the WHERE clause based on the "AND" keyword
+            const subSequenceArray = whereClause.split('AND');
+            columnValuePairs = subSequenceArray.map(pair => pair.trim());
+        }
+        else {
+            columnValuePairs = [whereClause];
+        }
+        const modifiedPairs = columnValuePairs.map(pair => {
+            const match = pair.match(/(\w+)\s*(=|IN|BETWEEN|LIKE)\s*(.+)/);
+            if (!match) {
+                return pair;
+            }
+            const column = match[1].trim();
+            const operator = match[2].trim();
+            const value = match[3].trim();
+            let newColumn = column;
+            const index = this.findIndexOfStringInArray(column, refNames);
+            if (index !== -1) {
+                newColumn = this.getStringAtIndex(colNames, index);
+            }
+            const modifiedColumn = `${prefix}${newColumn}`;
+            const ret = `${modifiedColumn} ${operator} ${value}`;
+            return ret;
+        });
+        return modifiedPairs.join(' AND ');
+    }
+    findIndexOfStringInArray(target, array) {
+        return array.indexOf(target);
+    }
+    getStringAtIndex(array, index) {
+        if (index >= 0 && index < array.length) {
+            return array[index];
+        }
+        else {
+            return undefined;
+        }
+    }
+    extractForeignKeyInfo(sqlStatement) {
+        // Define the regular expression pattern for extracting the FOREIGN KEY clause
+        const 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))?/;
+        const matches = sqlStatement.match(foreignKeyPattern);
+        if (matches) {
+            const foreignKeyInfo = {
+                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',
+            };
+            return foreignKeyInfo;
+        }
+        else {
+            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 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(' ');
+    }
+    getStmtAndRetColNames(sqlStmt, retMode) {
+        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') {
+                const suffix = sqlStmt.substring(retWordIndex + retWord.length);
+                const names = suffix.trim();
+                if (names.endsWith(';')) {
+                    retStmtNames.names = names.substring(0, names.length - 1);
+                }
+                else {
+                    retStmtNames.names = names;
+                }
+            }
+        }
+        return retStmtNames;
+    }
+    extractCombinedPrimaryKey(whereClause) {
+        const pattern = /WHERE\s*\((.+?)\)\s*(?:=|IN)\s*\((.+?)\)/g;
+        const regex = new RegExp(pattern);
+        const matches = whereClause.matchAll(regex);
+        const primaryKeySets = [];
+        for (const match of matches) {
+            const keysString = match[1].trim();
+            const keys = keysString.split(',').map(key => key.trim());
+            primaryKeySets.push(keys);
+        }
+        return primaryKeySets.length === 0 ? null : primaryKeySets;
+    }
+    getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys) {
+        let retWhere = whStmt;
+        for (const grpKeys of keys) {
+            const repKeys = grpKeys.join(',') === withRefs.join(',') ? colNames : withRefs;
+            for (const [index, key] of grpKeys.entries()) {
+                retWhere = this.replaceAllString(retWhere, key, repKeys[index]);
+            }
+        }
+        return retWhere;
+    }
+    replaceAllString(originalStr, searchStr, replaceStr) {
+        return originalStr.split(searchStr).join(replaceStr);
+    }
+    indicesOf(str, searchStr, fromIndex = 0) {
+        // Helper function to find indices of a substring within a string
+        const indices = [];
+        let currentIndex = str.indexOf(searchStr, fromIndex);
+        while (currentIndex !== -1) {
+            indices.push(currentIndex);
+            currentIndex = str.indexOf(searchStr, currentIndex + 1);
+        }
+        return indices;
+    }
+    getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames) {
+        let whereStmt = '';
+        let stmt = whStmt.substring(6);
+        for (let idx = 0; idx < withRefs.length; idx++) {
+            let colType = 'withRefsNames';
+            let idxs = this.indicesOf(stmt, withRefs[idx]);
+            if (idxs.length === 0) {
+                idxs = this.indicesOf(stmt, colNames[idx]);
+                colType = 'colNames';
+            }
+            if (idxs.length > 0) {
+                let valStr = '';
+                const indicesEqual = this.indicesOf(stmt, '=', idxs[0]);
+                if (indicesEqual.length > 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);
+                    }
+                    else {
+                        valStr = stmt.substring(indicesEqual[0] + 1);
+                    }
+                    if (idx > 0) {
+                        whereStmt += ' AND ';
+                    }
+                    if (colType === 'withRefsNames') {
+                        whereStmt += colNames[idx] + ' = ' + valStr;
+                    }
+                    else {
+                        whereStmt += withRefs[idx] + ' = ' + valStr;
+                    }
+                }
+            }
+        }
+        whereStmt = 'WHERE ' + whereStmt;
+        return whereStmt;
+    }
+    updateWhere(whStmt, withRefs, colNames) {
+        let whereStmt = '';
+        if (whStmt.length <= 0) {
+            return whereStmt;
+        }
+        if (whStmt.toUpperCase().substring(0, 5) !== 'WHERE') {
+            return whereStmt;
+        }
+        if (withRefs.length === colNames.length) {
+            // get whereStmt for primary combined key
+            const keys = this.extractCombinedPrimaryKey(whStmt);
+            if (keys) {
+                whereStmt = this.getWhereStmtForCombinedPK(whStmt, withRefs, colNames, keys);
+            }
+            else {
+                // get for non primary combined key
+                whereStmt = this.getWhereStmtForNonCombinedPK(whStmt, withRefs, colNames);
+            }
+        }
+        return whereStmt;
+    }
+}
+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;
 //const SQLITE_OPEN_READONLY = 1;
 class UtilsSQLite {
     constructor() {
         this.fileUtil = new utilsFile_1$4.UtilsFile();
-        this.BCSQLite3 = require$$1__default$1["default"];
+        this.statUtil = new utilsSqlstatement_1.UtilsSQLStatement();
+        this.delUtil = new utilsDelete_1.UtilsDelete();
+        this.sql92Utils = new UtilsSQL92Compatibility_1$1.UtilsSQL92Compatibility();
+        this.BCSQLite3 = require$$4__default$1["default"];
     }
     /**
      * OpenOrCreateDatabase
@@ -945,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;
@@ -954,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);
@@ -971,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
@@ -981,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')) {
@@ -993,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;
             }
@@ -1041,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';
@@ -1072,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;
@@ -1095,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 };
@@ -1142,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);
@@ -1158,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;
@@ -1176,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;
@@ -1229,17 +1844,39 @@ class UtilsSQLite {
         try {
             const isLast = this.isLastModified(mDB, true);
             const isDel = this.isSqlDeleted(mDB, true);
-            if (isLast && isDel) {
-                // Replace DELETE by UPDATE and set sql_deleted to 1
-                const wIdx = statement.toUpperCase().indexOf('WHERE');
-                const preStmt = statement.substring(0, wIdx - 1);
-                const clauseStmt = statement.substring(wIdx, statement.length);
-                const tableName = preStmt
-                    .substring('DELETE FROM'.length)
-                    .trim();
-                sqlStmt = `UPDATE ${tableName} SET sql_deleted = 1 ${clauseStmt}`;
-                // Find REFERENCES if any and update the sql_deleted column
-                this.findReferencesAndUpdate(mDB, tableName, clauseStmt, values);
+            if (!isLast || !isDel) {
+                return sqlStmt;
+            }
+            // Replace DELETE by UPDATE
+            // set sql_deleted to 1 and the last_modified to
+            // timenow
+            const whereClause = this.statUtil.extractWhereClause(sqlStmt);
+            if (!whereClause) {
+                const msg = 'deleteSQL: cannot find a WHERE clause';
+                throw new Error(`${msg}`);
+            }
+            const tableName = this.statUtil.extractTableName(sqlStmt);
+            if (!tableName) {
+                const msg = 'deleteSQL: cannot find a WHERE clause';
+                throw new Error(`${msg}`);
+            }
+            const colNames = this.statUtil.extractColumnNames(whereClause);
+            if (colNames.length === 0) {
+                const msg = 'deleteSQL: Did not find column names in the WHERE Statement';
+                throw new Error(`${msg}`);
+            }
+            const setStmt = 'sql_deleted = 1';
+            // Find REFERENCES if any and update the sql_deleted
+            // column
+            const hasToUpdate = this.findReferencesAndUpdate(mDB, tableName, whereClause, colNames, values);
+            if (hasToUpdate) {
+                const whereStmt = whereClause.endsWith(';')
+                    ? whereClause.slice(0, -1)
+                    : whereClause;
+                sqlStmt = `UPDATE ${tableName} SET ${setStmt} WHERE ${whereStmt} AND sql_deleted = 0;`;
+            }
+            else {
+                sqlStmt = '';
             }
             return sqlStmt;
         }
@@ -1253,192 +1890,184 @@ class UtilsSQLite {
      * @param mDB
      * @param tableName
      * @param whereStmt
+     * @param initColNames
      * @param values
      * @returns
      */
-    findReferencesAndUpdate(mDB, tableName, whereStmt, values) {
-        const msg = 'FindReferencesAndUpdate';
+    findReferencesAndUpdate(mDB, tableName, whereStmt, initColNames, values) {
         try {
-            const references = this.getReferences(mDB, tableName);
+            const retBool = true;
+            const result = this.getReferences(mDB, tableName);
+            const references = result.retRefs;
+            const tableNameWithRefs = result.tableWithRefs;
             if (references.length <= 0) {
-                return;
-            }
-            const tableNameWithRefs = references.pop();
-            for (const refe of references) {
-                // get the tableName of the reference
-                const refTable = this.getReferenceTableName(refe);
-                if (refTable.length <= 0) {
+                return retBool;
+            }
+            if (tableName === tableNameWithRefs) {
+                return retBool;
+            }
+            // Loop through references
+            for (const ref of references) {
+                // Extract the FOREIGN KEY constraint info from the ref statement
+                const foreignKeyInfo = this.statUtil.extractForeignKeyInfo(ref);
+                // Get the tableName of the references
+                const refTable = foreignKeyInfo.tableName;
+                if (refTable === '' || refTable !== tableName) {
                     continue;
                 }
-                // get the with references columnName
-                const withRefsNames = this.getWithRefsColumnName(refe);
-                if (withRefsNames.length <= 0) {
-                    continue;
+                // Get the with ref column names
+                const withRefsNames = foreignKeyInfo.forKeys;
+                // Get the column names
+                const colNames = foreignKeyInfo.refKeys;
+                if (colNames.length !== withRefsNames.length) {
+                    const msg = 'findReferencesAndUpdate: mismatch length';
+                    throw new Error(msg);
                 }
-                // get the referenced columnName
-                const colNames = this.getReferencedColumnName(refe);
-                if (colNames.length <= 0) {
+                const action = foreignKeyInfo.action;
+                if (action === 'NO_ACTION') {
                     continue;
                 }
-                // update the where clause
-                const uWhereStmt = this.updateWhere(whereStmt, withRefsNames, colNames);
-                if (uWhereStmt.length <= 0) {
-                    continue;
-                }
-                let updTableName = tableNameWithRefs;
-                let updColNames = colNames;
-                if (tableNameWithRefs === tableName) {
-                    updTableName = refTable;
-                    updColNames = withRefsNames;
-                }
-                //update sql_deleted for this reference
-                const stmt = 'UPDATE ' + updTableName + ' SET sql_deleted = 1 ' + uWhereStmt;
-                const selValues = [];
-                if (values.length > 0) {
-                    const mVal = this.replaceUndefinedByNull(values);
-                    let arrVal = whereStmt.split('?');
-                    if (arrVal[arrVal.length - 1] === ';')
-                        arrVal = arrVal.slice(0, -1);
-                    for (const [j, val] of arrVal.entries()) {
-                        for (const updVal of updColNames) {
-                            const idxVal = val.indexOf(updVal);
-                            if (idxVal > -1) {
-                                selValues.push(mVal[j]);
-                            }
+                const updTableName = tableNameWithRefs;
+                const updColNames = withRefsNames;
+                let results = {
+                    uWhereStmt: '',
+                    setStmt: '',
+                };
+                if (!this.delUtil.checkValuesMatch(withRefsNames, initColNames)) {
+                    // Case: no match
+                    // Search for related items in tableName
+                    const result = this.searchForRelatedItems(mDB, updTableName, tableName, whereStmt, withRefsNames, colNames, values);
+                    if (result.relatedItems.length === 0 && result.key.length <= 0) {
+                        continue;
+                    }
+                    if (updTableName !== tableName) {
+                        switch (action) {
+                            case 'RESTRICT':
+                                results = this.delUtil.upDateWhereForRestrict(result);
+                                break;
+                            case 'CASCADE':
+                                results = this.delUtil.upDateWhereForCascade(result);
+                                break;
+                            default:
+                                results = this.delUtil.upDateWhereForDefault(withRefsNames, result);
+                                break;
                         }
                     }
                 }
-                const ret = this.runExec(mDB, stmt, selValues, 'no');
-                const lastId = ret.lastInsertRowid;
-                if (lastId == -1) {
-                    const msg = `UPDATE sql_deleted failed for references table: ${refTable}`;
-                    throw new Error(`findReferencesAndUpdate: ${msg}`);
+                else {
+                    throw new Error('Not implemented. Please transfer your example to the maintener');
                 }
-            }
-            return;
-        }
-        catch (err) {
-            const errmsg = err.message ? err.message : err;
-            throw new Error(`${msg} ${errmsg}`);
-        }
-    }
-    getReferenceTableName(refValue) {
-        let tableName = '';
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[1].indexOf('(');
-                tableName = arr[1].substring(0, oPar).trim();
-            }
-        }
-        return tableName;
-    }
-    getReferencedColumnName(refValue) {
-        let colNames = [];
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[1].indexOf('(');
-                const cPar = arr[1].indexOf(')');
-                const colStr = arr[1].substring(oPar + 1, cPar).trim();
-                colNames = colStr.split(',');
-            }
-        }
-        return colNames;
-    }
-    getWithRefsColumnName(refValue) {
-        let colNames = [];
-        if (refValue.length > 0) {
-            const arr = refValue.split(new RegExp('REFERENCES', 'i'));
-            if (arr.length === 2) {
-                const oPar = arr[0].indexOf('(');
-                const cPar = arr[0].indexOf(')');
-                const colStr = arr[0].substring(oPar + 1, cPar).trim();
-                colNames = colStr.split(',');
-            }
-        }
-        return colNames;
-    }
-    updateWhere(whStmt, withRefsNames, colNames) {
-        let whereStmt = '';
-        if (whStmt.length > 0) {
-            const index = whStmt.toLowerCase().indexOf('WHERE'.toLowerCase());
-            const stmt = whStmt.substring(index + 6);
-            if (withRefsNames.length === colNames.length) {
-                for (let i = 0; i < withRefsNames.length; i++) {
-                    let colType = 'withRefsNames';
-                    let idx = stmt.indexOf(withRefsNames[i]);
-                    if (idx === -1) {
-                        idx = stmt.indexOf(colNames[i]);
-                        colType = 'colNames';
-                    }
-                    if (idx > -1) {
-                        let valStr = '';
-                        const fEqual = stmt.indexOf('=', idx);
-                        if (fEqual > -1) {
-                            const iAnd = stmt.indexOf('AND', fEqual);
-                            const ilAnd = stmt.indexOf('and', fEqual);
-                            if (iAnd > -1) {
-                                valStr = stmt.substring(fEqual + 1, iAnd - 1).trim();
-                            }
-                            else if (ilAnd > -1) {
-                                valStr = stmt.substring(fEqual + 1, ilAnd - 1).trim();
-                            }
-                            else {
-                                valStr = stmt.substring(fEqual + 1, stmt.length).trim();
-                            }
-                            if (i > 0) {
-                                whereStmt += ' AND ';
-                            }
-                            if (colType === 'withRefsNames') {
-                                whereStmt += `${colNames[i]} = ${valStr}`;
-                            }
-                            else {
-                                whereStmt += `${withRefsNames[i]} = ${valStr}`;
-                            }
-                        }
-                    }
+                if (results.setStmt.length > 0 && results.uWhereStmt.length > 0) {
+                    this.executeUpdateForDelete(mDB, updTableName, results.uWhereStmt, results.setStmt, updColNames, values);
                 }
-                whereStmt = 'WHERE ' + whereStmt;
             }
+            return retBool;
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
         }
-        return whereStmt;
     }
-    getReferences(mDB, tableName) {
-        const msg = 'GetReferences';
+    /**
+     * getReferences
+     * @param db
+     * @param tableName
+     * @returns
+     */
+    getReferences(db, tableName) {
         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%');";
         try {
-            const res = this.queryAll(mDB, sqlStmt, []);
+            const res = this.queryAll(db, sqlStmt, [], true);
             // get the reference's string(s)
             let retRefs = [];
+            let tableWithRefs = '';
             if (res.length > 0) {
-                retRefs = this.getRefs(res[0].sql);
+                const result = this.getRefs(res[0].sql);
+                retRefs = result.foreignKeys;
+                tableWithRefs = result.tableName;
             }
-            return retRefs;
+            return { tableWithRefs: tableWithRefs, retRefs: retRefs };
         }
         catch (err) {
-            const errmsg = err.message ? err.message : err;
-            throw new Error(`${msg} ${errmsg}`);
+            const error = err.message ? err.message : err;
+            const msg = `getReferences: ${error}`;
+            throw new Error(msg);
         }
     }
-    getRefs(str) {
-        const retRefs = [];
-        const arrFor = str.split(new RegExp('FOREIGN KEY', 'i'));
-        // Loop through Foreign Keys
-        for (let i = 1; i < arrFor.length; i++) {
-            retRefs.push(arrFor[i].split(new RegExp('ON DELETE', 'i'))[0].trim());
+    /**
+     * getRefs
+     * @param sqlStatement
+     * @returns
+     */
+    getRefs(sqlStatement) {
+        let tableName = '';
+        const foreignKeys = [];
+        const statement = this.statUtil.flattenMultilineString(sqlStatement);
+        try {
+            // Regular expression pattern to match the table name
+            const tableNamePattern = /CREATE\s+TABLE\s+(\w+)\s+\(/;
+            const tableNameMatch = statement.match(tableNamePattern);
+            if (tableNameMatch) {
+                tableName = tableNameMatch[1];
+            }
+            // Regular expression pattern to match the FOREIGN KEY constraints
+            const foreignKeyPattern = /FOREIGN\s+KEY\s+\([^)]+\)\s+REFERENCES\s+(\w+)\s*\([^)]+\)\s+ON\s+DELETE\s+(CASCADE|RESTRICT|SET\s+DEFAULT|SET\s+NULL|NO\s+ACTION)/g;
+            const foreignKeyMatches = statement.matchAll(foreignKeyPattern);
+            for (const foreignKeyMatch of foreignKeyMatches) {
+                const foreignKey = foreignKeyMatch[0];
+                foreignKeys.push(foreignKey);
+            }
+        }
+        catch (error) {
+            const msg = `getRefs: Error creating regular expression: ${error}`;
+            throw new Error(msg);
+        }
+        return { tableName, foreignKeys };
+    }
+    /**
+     * executeUpdateForDelete
+     * @param mDB
+     * @param tableName
+     * @param whereStmt
+     * @param setStmt
+     * @param colNames
+     * @param values
+     */
+    executeUpdateForDelete(mDB, tableName, whereStmt, setStmt, colNames, values) {
+        try {
+            let lastId = -1;
+            // Update sql_deleted for this references
+            const stmt = `UPDATE ${tableName} SET ${setStmt} ${whereStmt}`;
+            const selValues = [];
+            if (values.length > 0) {
+                const arrVal = whereStmt.split('?');
+                if (arrVal[arrVal.length - 1] === ';') {
+                    arrVal.pop();
+                }
+                for (let jdx = 0; jdx < arrVal.length; jdx++) {
+                    for (const updVal of colNames) {
+                        const indices = this.statUtil.indicesOf(arrVal[jdx], updVal);
+                        if (indices.length > 0) {
+                            selValues.push(values[jdx]);
+                        }
+                    }
+                }
+            }
+            const retObj = this.runExec(mDB, stmt, selValues, 'no');
+            lastId = retObj['lastInsertRowid'];
+            if (lastId === -1) {
+                const msg = `UPDATE sql_deleted failed for table: ${tableName}`;
+                throw new Error(msg);
+            }
         }
-        // find table name with references
-        if (str.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
-            const oPar = str.indexOf('(');
-            const tableName = str.substring(13, oPar).trim();
-            retRefs.push(tableName);
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
         }
-        return retRefs;
     }
     /**
      * QueryAll
@@ -1446,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);
@@ -1474,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) {
@@ -1506,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);
             }
@@ -1528,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);
             }
@@ -1657,6 +2302,36 @@ class UtilsSQLite {
             throw new Error(`${msg} ${errmsg}`);
         }
     }
+    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}`);
+        try {
+            // addPrefix to the whereClause and swap colNames with  withRefsNames
+            let whereClause = this.statUtil.addPrefixToWhereClause(whStmt, colNames, withRefsNames, 't2.');
+            // look at the whereclause and change colNames with  withRefsNames
+            if (whereClause.endsWith(';')) {
+                whereClause = whereClause.slice(0, -1);
+            }
+            const resultString = t1Names
+                .map((t1, index) => `${t1} = ${t2Names[index]}`)
+                .join(' AND ');
+            const sql = `SELECT t1.rowid FROM ${updTableName} t1 ` +
+                `JOIN ${tableName} t2 ON ${resultString} ` +
+                `WHERE ${whereClause} AND t1.sql_deleted = 0;`;
+            const vals = this.queryAll(mDB, sql, values, true);
+            if (vals.length > 0) {
+                key = Object.keys(vals[0])[0];
+                relatedItems.push(...vals);
+            }
+            return { key: key, relatedItems: relatedItems };
+        }
+        catch (error) {
+            const msg = error.message ? error.message : error;
+            throw new Error(msg);
+        }
+    }
     cleanStatement(stmt) {
         let sql = '';
         if (stmt.toLowerCase().includes('INSERT INTO'.toLowerCase()) ||
@@ -1665,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 {
@@ -1759,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;
         }
@@ -1779,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;
         }
@@ -1796,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}`);
@@ -1805,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}`);
@@ -1819,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) {
@@ -1828,7 +2506,8 @@ class UtilsJson {
             }
         }
         try {
-            this.sqliteUtil.commitTransaction(mDB, true);
+            this.sqliteUtil.commitTransaction(mDB.database, true);
+            mDB.setIsTransActive(false);
             return changes;
         }
         catch (err) {
@@ -2113,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) {
@@ -2192,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;
@@ -2566,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`);
             }
@@ -2658,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) {
@@ -2671,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];
@@ -2703,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` };
             }
@@ -2763,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;
@@ -2785,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];
@@ -2959,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);
@@ -3009,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);
@@ -3213,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;
@@ -3223,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'];
@@ -3330,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 = [];
@@ -3389,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');
             }
@@ -3423,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);
@@ -3443,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}`);
@@ -3452,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;
@@ -3466,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) {
@@ -3476,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) {
@@ -3501,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}`);
@@ -3510,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) {
@@ -3522,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) {
@@ -3532,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) {
@@ -3689,7 +4374,7 @@ class UtilsJsonEncryption {
     constructor() {
         this.fileSecret = new utilsSecret_1$2.UtilsSecret();
         this.SALT = 'jeep_capacitor_sqlite';
-        this.Crypto = require$$1__default$2["default"];
+        this.Crypto = require$$1__default$1["default"];
         this.CryptoJS = require$$2__default$1["default"];
     }
     /**
@@ -3807,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}`);
@@ -3829,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}`);
         }
     }
@@ -3851,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;
@@ -3869,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;
@@ -3878,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);
@@ -3921,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}`);
                     }
@@ -3950,8 +4641,8 @@ class Database {
      * @returns Promise<boolean>
      */
     dbClose() {
-        this.ensureDatabaseIsOpen();
         try {
+            this.ensureDatabaseIsOpen();
             this.sqliteUtil.closeDB(this.database);
         }
         catch (err) {
@@ -3962,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
@@ -4074,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`);
@@ -4109,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' };
             }
@@ -4149,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) {
@@ -4159,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');
             }
@@ -4186,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) {
@@ -4203,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
@@ -4219,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);
@@ -4242,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 {
@@ -4259,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);
             }
@@ -4310,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);
@@ -4391,9 +5157,9 @@ class CapacitorSQLite {
         this.versionUpgrades = {};
         this.databases = {};
         this.fileUtil = new utilsFile_1.UtilsFile();
+        this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.jsonUtil = new utilsJson_1.UtilsJson();
         this.jsonEncryptUtil = new utilsJsonEncryption_1.UtilsJsonEncryption();
-        this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.secretUtil = new utilsSecret_1.UtilsSecret();
         this.globalUtil = new GlobalSQLite_1.GlobalSQLite();
         this.isEncryption = this.fileUtil.getIsEncryption();
@@ -4488,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;
@@ -4535,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()) {
@@ -4543,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');
                 }
@@ -4566,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) {
@@ -4579,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`);
                 }
@@ -4603,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()) {
@@ -4611,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) {
@@ -4631,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) {