@capacitor-community/sqlite 3.4.3-2 → 3.4.3-3

package/electron/dist/plugin.js

@@ -325,12 +325,33 @@ class UtilsSQLite {
      * @param mDB
      * @param sql
      */
-    async execute(mDB, sql) {
+    async execute(mDB, sql, fromJson) {
         let changes = -1;
         let initChanges = -1;
         try {
             initChanges = await this.dbChanges(mDB);
-            await this.execDB(mDB, sql);
+            let sqlStmt = sql;
+            // Check for DELETE FROM in sql string
+            if (!fromJson &&
+                sql.toLowerCase().includes('DELETE FROM'.toLowerCase())) {
+                sqlStmt = sql.replace(/\n/g, '');
+                const sqlStmts = sqlStmt.split(';');
+                const resArr = [];
+                for (const stmt of sqlStmts) {
+                    const trimStmt = stmt.trim().substring(0, 11).toUpperCase();
+                    if (trimStmt === 'DELETE FROM' &&
+                        stmt.toLowerCase().includes('WHERE'.toLowerCase())) {
+                        const whereStmt = `${stmt.trim()};`;
+                        const rStmt = await this.deleteSQL(mDB, whereStmt, []);
+                        resArr.push(rStmt);
+                    }
+                    else {
+                        resArr.push(stmt);
+                    }
+                }
+                sqlStmt = resArr.join(';');
+            }
+            await this.execDB(mDB, sqlStmt);
             changes = (await this.dbChanges(mDB)) - initChanges;
             return Promise.resolve(changes);
         }
@@ -358,7 +379,7 @@ class UtilsSQLite {
      * @param db
      * @param set
      */
-    async executeSet(db, set) {
+    async executeSet(db, set, fromJson) {
         let lastId = -1;
         for (let i = 0; i < set.length; i++) {
             const statement = 'statement' in set[i] ? set[i].statement : null;
@@ -371,11 +392,13 @@ class UtilsSQLite {
             try {
                 if (Array.isArray(values[0])) {
                     for (const val of values) {
-                        lastId = await this.prepareRun(db, statement, val);
+                        const mVal = await this.replaceUndefinedByNull(val);
+                        lastId = await this.prepareRun(db, statement, mVal, fromJson);
                     }
                 }
                 else {
-                    lastId = await this.prepareRun(db, statement, values);
+                    const mVal = await this.replaceUndefinedByNull(values);
+                    lastId = await this.prepareRun(db, statement, mVal, fromJson);
                 }
             }
             catch (err) {
@@ -390,24 +413,175 @@ class UtilsSQLite {
      * @param statement
      * @param values
      */
-    prepareRun(db, statement, values) {
-        return new Promise((resolve, reject) => {
-            let lastId = -1;
-            db.run(statement, values, async (err) => {
-                if (err) {
-                    reject(`PrepareRun: run ${err.message}`);
+    async prepareRun(db, statement, values, fromJson) {
+        const stmtType = statement
+            .replace(/\n/g, '')
+            .trim()
+            .substring(0, 6)
+            .toUpperCase();
+        let sqlStmt = statement;
+        let lastId = -1;
+        try {
+            if (!fromJson && stmtType === 'DELETE') {
+                sqlStmt = await this.deleteSQL(db, statement, values);
+            }
+            let mVal = [];
+            if (values != null && values.length > 0) {
+                mVal = await this.replaceUndefinedByNull(values);
+            }
+            if (mVal.length > 0) {
+                await db.run(sqlStmt, mVal);
+            }
+            else {
+                await db.exec(sqlStmt);
+            }
+            lastId = await this.getLastId(db);
+            return Promise.resolve(lastId);
+        }
+        catch (err) {
+            return Promise.reject(`PrepareRun: ${err}`);
+        }
+    }
+    /**
+     * replaceUndefinedByNull
+     * @param values
+     * @returns
+     */
+    async replaceUndefinedByNull(values) {
+        const retValues = [];
+        if (values.length > 0) {
+            for (const val of values) {
+                let mVal = val;
+                if (typeof val === 'undefined')
+                    mVal = null;
+                retValues.push(mVal);
+            }
+        }
+        return Promise.resolve(retValues);
+    }
+    /**
+     * deleteSQL
+     * @param db
+     * @param statement
+     * @param values
+     * @returns
+     */
+    async deleteSQL(db, statement, values) {
+        let sqlStmt = statement;
+        try {
+            const isLast = await this.isLastModified(db, true);
+            if (isLast) {
+                // 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
+                await this.findReferencesAndUpdate(db, tableName, clauseStmt, values);
+            }
+            return sqlStmt;
+        }
+        catch (err) {
+            return Promise.reject(`DeleteSL: ${err}`);
+        }
+    }
+    /**
+     * findReferencesAndUpdate
+     * @param db
+     * @param tableName
+     * @param whereStmt
+     * @param values
+     * @returns
+     */
+    async findReferencesAndUpdate(db, tableName, whereStmt, values) {
+        try {
+            const references = await this.getReferences(db, tableName);
+            for (const refe of references) {
+                // get the tableName of the reference
+                const refTable = await this.getReferenceTableName(refe.sql);
+                if (refTable.length <= 0) {
+                    continue;
+                }
+                // get the columnName
+                const colName = await this.getReferenceColumnName(refe.sql);
+                if (colName.length <= 0) {
+                    continue;
+                }
+                // update the where clause
+                const uWhereStmt = await this.updateWhere(whereStmt, colName);
+                if (uWhereStmt.length <= 0) {
+                    continue;
+                }
+                //update sql_deleted for this reference
+                const stmt = `UPDATE ${refTable} SET sql_deleted = 1 ${uWhereStmt}`;
+                if (values != null && values.length > 0) {
+                    const mVal = await this.replaceUndefinedByNull(values);
+                    await db.run(stmt, mVal);
                 }
                 else {
-                    try {
-                        lastId = await this.getLastId(db);
-                        resolve(lastId);
-                    }
-                    catch (err) {
-                        reject(`PrepareRun: lastId ${err}`);
-                    }
+                    await db.exec(stmt);
                 }
-            });
-        });
+                const lastId = await this.getLastId(db);
+                if (lastId == -1) {
+                    const msg = `UPDATE sql_deleted failed for references table: ${refTable}`;
+                    return Promise.reject(new Error(`findReferencesAndUpdate: ${msg}`));
+                }
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(new Error(`findReferencesAndUpdate: ${err.message}`));
+        }
+    }
+    async getReferenceTableName(refValue) {
+        let tableName = '';
+        if (refValue.length > 0 &&
+            refValue.substring(0, 12).toLowerCase() === 'CREATE TABLE'.toLowerCase()) {
+            const oPar = refValue.indexOf('(');
+            tableName = refValue.substring(13, oPar).trim();
+        }
+        return tableName;
+    }
+    async getReferenceColumnName(refValue) {
+        let colName = '';
+        if (refValue.length > 0) {
+            const index = refValue
+                .toLowerCase()
+                .indexOf('FOREIGN KEY'.toLowerCase());
+            const stmt = refValue.substring(index + 12);
+            const oPar = stmt.indexOf('(');
+            const cPar = stmt.indexOf(')');
+            colName = stmt.substring(oPar + 1, cPar).trim();
+        }
+        return colName;
+    }
+    async updateWhere(whStmt, colName) {
+        let whereStmt = '';
+        if (whStmt.length > 0) {
+            const index = whStmt.toLowerCase().indexOf('WHERE'.toLowerCase());
+            const stmt = whStmt.substring(index + 6);
+            const fEqual = stmt.indexOf('=');
+            const whereColName = stmt.substring(0, fEqual).trim();
+            whereStmt = whStmt.replace(whereColName, colName);
+        }
+        return whereStmt;
+    }
+    async getReferences(db, tableName) {
+        const sqlStmt = 'SELECT sql FROM sqlite_master ' +
+            "WHERE sql LIKE('%REFERENCES%') AND " +
+            "sql LIKE('%" +
+            tableName +
+            "%') AND sql LIKE('%ON DELETE%');";
+        try {
+            const res = await this.queryAll(db, sqlStmt, []);
+            return Promise.resolve(res);
+        }
+        catch (err) {
+            return Promise.reject(new Error(`getReferences: ${err.message}`));
+        }
     }
     /**
      * QueryAll
@@ -432,20 +606,6 @@ class UtilsSQLite {
             });
         });
     }
-}
-utilsSQLite.UtilsSQLite = UtilsSQLite;
-
-var utilsJson = {};
-
-var utilsDrop = {};
-
-Object.defineProperty(utilsDrop, "__esModule", { value: true });
-utilsDrop.UtilsDrop = void 0;
-const utilsSQLite_1$5 = utilsSQLite;
-class UtilsDrop {
-    constructor() {
-        this._uSQLite = new utilsSQLite_1$5.UtilsSQLite();
-    }
     /**
      * GetTablesNames
      * @param mDb
@@ -458,7 +618,7 @@ class UtilsDrop {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            const retQuery = await this.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -478,7 +638,7 @@ class UtilsDrop {
         sql += 'ORDER BY rootpage DESC;';
         const retArr = [];
         try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            const retQuery = await this.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 retArr.push(query.name);
             }
@@ -489,137 +649,63 @@ class UtilsDrop {
         }
     }
     /**
-     * DropElements
+     * isLastModified
      * @param db
-     * @param type ["table","index","trigger"]
+     * @param isOpen
      */
-    async dropElements(db, type) {
-        let msg = '';
-        let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
-        switch (type) {
-            case 'index':
-                msg = 'DropIndexes';
-                break;
-            case 'trigger':
-                msg = 'DropTriggers';
-                break;
-            case 'table':
-                msg = 'DropTables';
-                stmt1 += ` AND name NOT IN ('sync_table')`;
-                break;
-            case 'view':
-                msg = 'DropViews';
-                break;
-            default:
-                return Promise.reject(`DropElements: ${type} ` + 'not found');
+    async isLastModified(db, isOpen) {
+        if (!isOpen) {
+            return Promise.reject('isLastModified: database not opened');
         }
-        // get the element's names
-        let stmt = 'SELECT name FROM sqlite_master WHERE ';
-        stmt += `type = '${type}' ${stmt1};`;
         try {
-            const elements = await this._uSQLite.queryAll(db, stmt, []);
-            if (elements.length > 0) {
-                const upType = type.toUpperCase();
-                const statements = [];
-                for (const elem of elements) {
-                    let stmt = `DROP ${upType} IF EXISTS `;
-                    stmt += `${elem.name};`;
-                    statements.push(stmt);
-                }
-                for (const stmt of statements) {
-                    const lastId = await this._uSQLite.prepareRun(db, stmt, []);
-                    if (lastId < 0) {
-                        return Promise.reject(`${msg}: lastId < 0`);
-                    }
+            const tableList = await this.getTablesNames(db);
+            for (const table of tableList) {
+                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
+                const tableColumnNames = tableNamesTypes.names;
+                if (tableColumnNames.includes('last_modified')) {
+                    return Promise.resolve(true);
                 }
             }
-            return Promise.resolve();
-        }
-        catch (err) {
-            return Promise.reject(`${msg}: ${err}`);
-        }
-    }
-    /**
-     * DropAll
-     * Drop all database's elements
-     * @param db
-     */
-    async dropAll(db) {
-        try {
-            // drop tables
-            await this.dropElements(db, 'table');
-            // drop indexes
-            await this.dropElements(db, 'index');
-            // drop triggers
-            await this.dropElements(db, 'trigger');
-            // drop views
-            await this.dropElements(db, 'view');
-            // vacuum the database
-            await this._uSQLite.prepareRun(db, 'VACUUM;', []);
-            return Promise.resolve();
         }
         catch (err) {
-            return Promise.reject(`DropAll: ${err}`);
+            return Promise.reject(`isLastModified: ${err}`);
         }
     }
     /**
-     * DropTempTables
-     * @param db
-     * @param alterTables
+     * GetTableColumnNamesTypes
+     * @param mDB
+     * @param tableName
      */
-    async dropTempTables(db, alterTables) {
-        const tempTables = Object.keys(alterTables);
-        const statements = [];
-        for (const tTable of tempTables) {
-            let stmt = 'DROP TABLE IF EXISTS ';
-            stmt += `_temp_${tTable};`;
-            statements.push(stmt);
-        }
+    async getTableColumnNamesTypes(mDB, tableName) {
+        let resQuery = [];
+        const retNames = [];
+        const retTypes = [];
+        const query = `PRAGMA table_info('${tableName}');`;
         try {
-            const changes = await this._uSQLite.execute(db, statements.join('\n'));
-            if (changes < 0) {
-                return Promise.reject('DropTempTables: changes < 0');
+            resQuery = await this.queryAll(mDB, query, []);
+            if (resQuery.length > 0) {
+                for (const query of resQuery) {
+                    retNames.push(query.name);
+                    retTypes.push(query.type);
+                }
             }
-            return Promise.resolve();
+            return Promise.resolve({ names: retNames, types: retTypes });
         }
         catch (err) {
-            return Promise.reject(`DropTempTables: ${err}`);
+            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
         }
     }
 }
-utilsDrop.UtilsDrop = UtilsDrop;
+utilsSQLite.UtilsSQLite = UtilsSQLite;
+
+var utilsJson = {};
 
 Object.defineProperty(utilsJson, "__esModule", { value: true });
 utilsJson.UtilsJson = void 0;
-const utilsDrop_1$3 = utilsDrop;
-const utilsSQLite_1$4 = utilsSQLite;
+const utilsSQLite_1$5 = utilsSQLite;
 class UtilsJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
-        this._uDrop = new utilsDrop_1$3.UtilsDrop();
-    }
-    /**
-     * isLastModified
-     * @param db
-     * @param isOpen
-     */
-    async isLastModified(db, isOpen) {
-        if (!isOpen) {
-            return Promise.reject('isLastModified: database not opened');
-        }
-        try {
-            const tableList = await this._uDrop.getTablesNames(db);
-            for (const table of tableList) {
-                const tableNamesTypes = await this.getTableColumnNamesTypes(db, table);
-                const tableColumnNames = tableNamesTypes.names;
-                if (tableColumnNames.includes('last_modified')) {
-                    return Promise.resolve(true);
-                }
-            }
-        }
-        catch (err) {
-            return Promise.reject(`isLastModified: ${err}`);
-        }
+        this.sqliteUtil = new utilsSQLite_1$5.UtilsSQLite();
     }
     /**
      * IsTableExists
@@ -689,7 +775,7 @@ class UtilsJson {
         let changes = 0;
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`CreateDatabaseSchema: ${err}`);
@@ -698,10 +784,10 @@ class UtilsJson {
         if (stmts.length > 0) {
             const schemaStmt = stmts.join('\n');
             try {
-                changes = await this._uSQLite.execute(mDB, schemaStmt);
+                changes = await this.sqliteUtil.execute(mDB, schemaStmt, true);
                 if (changes < 0) {
                     try {
-                        await this._uSQLite.rollbackTransaction(mDB, true);
+                        await this.sqliteUtil.rollbackTransaction(mDB, true);
                     }
                     catch (err) {
                         return Promise.reject('CreateSchema: changes < 0 ' + `${err}`);
@@ -711,7 +797,7 @@ class UtilsJson {
             catch (err) {
                 const msg = err;
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(`CreateSchema: ${msg}`);
                 }
                 catch (err) {
@@ -720,7 +806,7 @@ class UtilsJson {
             }
         }
         try {
-            await this._uSQLite.commitTransaction(mDB, true);
+            await this.sqliteUtil.commitTransaction(mDB, true);
             return Promise.resolve(changes);
         }
         catch (err) {
@@ -829,7 +915,7 @@ class UtilsJson {
                 return Promise.reject('CreateDataTable: Table ' + `${table.name} does not exist`);
             }
             // Get the column names and types
-            const tableNamesTypes = await this.getTableColumnNamesTypes(mDB, table.name);
+            const tableNamesTypes = await this.sqliteUtil.getTableColumnNamesTypes(mDB, table.name);
             const tableColumnTypes = tableNamesTypes.types;
             const tableColumnNames = tableNamesTypes.names;
             if (tableColumnTypes.length === 0) {
@@ -837,54 +923,15 @@ class UtilsJson {
             }
             // Loop on Table Values
             for (let j = 0; j < table.values.length; j++) {
-                // Check the row number of columns
-                if (table.values[j].length != tableColumnTypes.length) {
-                    return Promise.reject(`CreateDataTable: Table ${table.name} ` +
-                        `values row ${j} not correct length`);
-                }
-                // Check the column's type before proceeding
-                // remove type checking for allowing RDBMS Types
-                /*    const isColumnTypes: boolean = await this.checkColumnTypes(
-                  tableColumnTypes,
-                  table.values[j],
-                );
-                if (!isColumnTypes) {
-                  return Promise.reject(
-                    new Error(
-                      `CreateDataTable: Table ${table.name} ` +
-                        `values row ${j} not correct types`,
-                    ),
-                  );
-                }
-                */
-                const retisIdExists = await this.isIdExists(mDB, table.name, tableColumnNames[0], table.values[j][0]);
-                let stmt;
+                let row = table.values[j];
                 let isRun = true;
-                if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
-                    // Insert
-                    const nameString = tableColumnNames.join();
-                    const questionMarkString = await this.createQuestionMarkString(tableColumnNames.length);
-                    stmt = `INSERT INTO ${table.name} (${nameString}) VALUES (`;
-                    stmt += `${questionMarkString});`;
-                }
-                else {
-                    // Update
-                    const setString = await this.setNameForUpdate(tableColumnNames);
-                    if (setString.length === 0) {
-                        return Promise.reject(`CreateDataTable: Table ${table.name} ` +
-                            `values row ${j} not set to String`);
-                    }
-                    stmt = `UPDATE ${table.name} SET ${setString} WHERE `;
-                    if (typeof table.values[j][0] == 'string') {
-                        stmt += `${tableColumnNames[0]} = '${table.values[j][0]}';`;
-                    }
-                    else {
-                        stmt += `${tableColumnNames[0]} = ${table.values[j][0]};`;
-                    }
-                    isRun = await this.checkUpdate(mDB, table.values[j], table.name, tableColumnNames);
-                }
+                const stmt = await this.createRowStatement(mDB, tableColumnNames, row, j, table.name, mode);
+                isRun = await this.checkUpdate(mDB, stmt, row, table.name, tableColumnNames);
                 if (isRun) {
-                    lastId = await this._uSQLite.prepareRun(mDB, stmt, table.values[j]);
+                    if (stmt.substring(0, 6).toUpperCase() === 'DELETE') {
+                        row = [];
+                    }
+                    lastId = await this.sqliteUtil.prepareRun(mDB, stmt, row, true);
                     if (lastId < 0) {
                         return Promise.reject('CreateDataTable: lastId < 0');
                     }
@@ -900,44 +947,117 @@ class UtilsJson {
         }
     }
     /**
-     *
-     * @param db
-     * @param values
-     * @param tbName
+     * CreateRowStatement
+     * @param mDB
      * @param tColNames
+     * @param row
+     * @param j
+     * @param tableName
+     * @param mode
      * @returns
      */
-    async checkUpdate(db, values, tbName, tColNames) {
+    async createRowStatement(mDB, tColNames, row, j, tableName, mode) {
+        // Check the row number of columns
+        if (row.length != tColNames.length ||
+            row.length === 0 ||
+            tColNames.length === 0) {
+            return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+                `values row ${j} not correct length`));
+        }
         try {
-            let query = `SELECT * FROM ${tbName} WHERE `;
-            if (typeof values[0] == 'string') {
-                query += `${tColNames[0]} = '${values[0]}';`;
+            const retisIdExists = await this.isIdExists(mDB, tableName, tColNames[0], row[0]);
+            let stmt;
+            if (mode === 'full' || (mode === 'partial' && !retisIdExists)) {
+                // Insert
+                const nameString = tColNames.join();
+                const questionMarkString = await this.createQuestionMarkString(tColNames.length);
+                stmt = `INSERT INTO ${tableName} (${nameString}) VALUES (`;
+                stmt += `${questionMarkString});`;
             }
             else {
-                query += `${tColNames[0]} = ${values[0]};`;
+                // Update or Delete
+                let isUpdate = true;
+                const isColDeleted = (element) => element === `sql_deleted`;
+                const idxDelete = tColNames.findIndex(isColDeleted);
+                if (idxDelete >= 0) {
+                    if (row[idxDelete] === 1) {
+                        isUpdate = false;
+                        stmt = `DELETE FROM ${tableName} WHERE `;
+                        if (typeof row[0] == 'string') {
+                            stmt += `${tColNames[0]} = '${row[0]}';`;
+                        }
+                        else {
+                            stmt += `${tColNames[0]} = ${row[0]};`;
+                        }
+                    }
+                }
+                if (isUpdate) {
+                    // Update
+                    const setString = await this.setNameForUpdate(tColNames);
+                    if (setString.length === 0) {
+                        return Promise.reject(new Error(`CreateRowStatement: Table ${tableName} ` +
+                            `values row ${j} not set to String`));
+                    }
+                    stmt = `UPDATE ${tableName} SET ${setString} WHERE `;
+                    if (typeof row[0] == 'string') {
+                        stmt += `${tColNames[0]} = '${row[0]}';`;
+                    }
+                    else {
+                        stmt += `${tColNames[0]} = ${row[0]};`;
+                    }
+                }
             }
-            const resQuery = await this.getValues(db, query, tbName);
-            let resValues = [];
-            if (resQuery.length > 0) {
-                resValues = resQuery[0];
-            }
-            if (values.length > 0 &&
-                resValues.length > 0 &&
-                values.length === resValues.length) {
-                for (let i = 0; i < values.length; i++) {
-                    if (values[i] !== resValues[i]) {
-                        return Promise.resolve(true);
+            return Promise.resolve(stmt);
+        }
+        catch (err) {
+            return Promise.reject(new Error(`CreateRowStatement: ${err.message}`));
+        }
+    }
+    /**
+     *
+     * @param db
+     * @param values
+     * @param tbName
+     * @param tColNames
+     * @returns
+     */
+    async checkUpdate(db, stmt, values, tbName, tColNames) {
+        const isRun = true;
+        if (stmt.substring(0, 6) === 'UPDATE') {
+            try {
+                let query = `SELECT * FROM ${tbName} WHERE `;
+                if (typeof values[0] == 'string') {
+                    query += `${tColNames[0]} = '${values[0]}';`;
+                }
+                else {
+                    query += `${tColNames[0]} = ${values[0]};`;
+                }
+                const resQuery = await this.getValues(db, query, tbName);
+                let resValues = [];
+                if (resQuery.length > 0) {
+                    resValues = resQuery[0];
+                }
+                if (values.length > 0 &&
+                    resValues.length > 0 &&
+                    values.length === resValues.length) {
+                    for (let i = 0; i < values.length; i++) {
+                        if (values[i] !== resValues[i]) {
+                            return Promise.resolve(true);
+                        }
                     }
+                    return Promise.resolve(false);
+                }
+                else {
+                    const msg = 'Both arrays not the same length';
+                    return Promise.reject(new Error(`CheckUpdate: ${msg}`));
                 }
-                return Promise.resolve(false);
             }
-            else {
-                const msg = 'Both arrays not the same length';
-                return Promise.reject(new Error(`CheckUpdate: ${msg}`));
+            catch (err) {
+                return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
             }
         }
-        catch (err) {
-            return Promise.reject(new Error(`CheckUpdate: ${err.message}`));
+        else {
+            return Promise.resolve(isRun);
         }
     }
     /**
@@ -950,7 +1070,7 @@ class UtilsJson {
         const values = [];
         try {
             // get table column names and types
-            const tableNamesTypes = await this.getTableColumnNamesTypes(mDb, tableName);
+            const tableNamesTypes = await this.sqliteUtil.getTableColumnNamesTypes(mDb, tableName);
             let rowNames = [];
             if (Object.keys(tableNamesTypes).includes('names')) {
                 rowNames = tableNamesTypes.names;
@@ -958,7 +1078,7 @@ class UtilsJson {
             else {
                 return Promise.reject(`GetValues: Table ${tableName} no names`);
             }
-            const retValues = await this._uSQLite.queryAll(mDb, query, []);
+            const retValues = await this.sqliteUtil.queryAll(mDb, query, []);
             for (const rValue of retValues) {
                 const row = [];
                 for (const rName of rowNames) {
@@ -977,30 +1097,6 @@ class UtilsJson {
             return Promise.reject(`GetValues: ${err}`);
         }
     }
-    /**
-     * GetTableColumnNamesTypes
-     * @param mDB
-     * @param tableName
-     */
-    async getTableColumnNamesTypes(mDB, tableName) {
-        let resQuery = [];
-        const retNames = [];
-        const retTypes = [];
-        const query = `PRAGMA table_info('${tableName}');`;
-        try {
-            resQuery = await this._uSQLite.queryAll(mDB, query, []);
-            if (resQuery.length > 0) {
-                for (const query of resQuery) {
-                    retNames.push(query.name);
-                    retTypes.push(query.type);
-                }
-            }
-            return Promise.resolve({ names: retNames, types: retTypes });
-        }
-        catch (err) {
-            return Promise.reject('GetTableColumnNamesTypes: ' + `${err}`);
-        }
-    }
     /**
      * CheckColumnTypes
      * @param tableTypes
@@ -1060,7 +1156,7 @@ class UtilsJson {
         if (typeof key === 'string')
             query += `'${key}';`;
         try {
-            const resQuery = await this._uSQLite.queryAll(db, query, []);
+            const resQuery = await this.sqliteUtil.queryAll(db, query, []);
             if (resQuery.length === 1)
                 ret = true;
             return Promise.resolve(ret);
@@ -1426,7 +1522,7 @@ class UtilsJson {
     async createView(mDB, view) {
         const stmt = `CREATE VIEW IF NOT EXISTS ${view.name} AS ${view.value};`;
         try {
-            const changes = await this._uSQLite.execute(mDB, stmt);
+            const changes = await this.sqliteUtil.execute(mDB, stmt, true);
             if (changes < 0) {
                 return Promise.reject(`CreateView: ${view.name} failed`);
             }
@@ -1441,12 +1537,12 @@ utilsJson.UtilsJson = UtilsJson;
 
 Object.defineProperty(exportToJson, "__esModule", { value: true });
 exportToJson.ExportToJson = void 0;
-const utilsSQLite_1$3 = utilsSQLite;
+const utilsSQLite_1$4 = utilsSQLite;
 const utilsJson_1$4 = utilsJson;
 class ExportToJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
-        this._uJson = new utilsJson_1$4.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$4.UtilsSQLite();
+        this.jsonUtil = new utilsJson_1$4.UtilsJson();
     }
     /**
      * CreateExportObject
@@ -1467,7 +1563,7 @@ class ExportToJson {
                 return Promise.reject("createExportObject: table's names failed");
             }
             else {
-                const isTable = await this._uJson.isTableExists(mDB, true, 'sync_table');
+                const isTable = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
                 if (!isTable && sqlObj.mode === 'partial') {
                     return Promise.reject('No sync_table available');
                 }
@@ -1517,13 +1613,102 @@ class ExportToJson {
         sql += "AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            retQuery = await this.sqliteUtil.queryAll(mDb, sql, []);
             return Promise.resolve(retQuery);
         }
         catch (err) {
             return Promise.reject(`getTablesNameSQL: ${err}`);
         }
     }
+    async getLastExportDate(mDb) {
+        return new Promise((resolve, reject) => {
+            let retDate = -1;
+            // get the last sync date
+            const stmt = `SELECT sync_date FROM sync_table WHERE id = 2;`;
+            mDb.get(stmt, [], (err, row) => {
+                // process the row here
+                if (err) {
+                    reject(`getLastExportDate: ${err.message}`);
+                }
+                else {
+                    if (row != null) {
+                        const key = Object.keys(row)[0];
+                        retDate = row[key];
+                    }
+                    resolve(retDate);
+                }
+            });
+        });
+    }
+    /**
+     * SetLastExportDate
+     * @param mDb
+     * @param lastExportedDate
+     * @returns
+     */
+    async setLastExportDate(mDb, lastExportedDate) {
+        try {
+            const isTable = await this.jsonUtil.isTableExists(mDb, true, 'sync_table');
+            if (!isTable) {
+                return Promise.reject(new Error('setLastExportDate: No sync_table available'));
+            }
+            const sDate = Math.round(new Date(lastExportedDate).getTime() / 1000);
+            let stmt = '';
+            if ((await this.getLastExportDate(mDb)) > 0) {
+                stmt = `UPDATE sync_table SET sync_date = ${sDate} WHERE id = 2;`;
+            }
+            else {
+                stmt = `INSERT INTO sync_table (sync_date) VALUES (${sDate});`;
+            }
+            const changes = await this.sqliteUtil.execute(mDb, stmt, false);
+            if (changes < 0) {
+                return { result: false, message: 'setLastExportDate failed' };
+            }
+            else {
+                return { result: true };
+            }
+        }
+        catch (err) {
+            return {
+                result: false,
+                message: `setLastExportDate failed: ${err.message}`,
+            };
+        }
+    }
+    async delExportedRows(mDb) {
+        let lastExportDate;
+        try {
+            // check if synchronization table exists
+            const isTable = await this.jsonUtil.isTableExists(mDb, true, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('DelExportedRows: No sync_table available');
+            }
+            // get the last export date
+            lastExportDate = await this.getLastExportDate(mDb);
+            if (lastExportDate < 0) {
+                return Promise.reject('DelExportedRows: no last exported date available');
+            }
+            // get the table' name list
+            const resTables = await this.sqliteUtil.getTablesNames(mDb);
+            if (resTables.length === 0) {
+                return Promise.reject("DelExportedRows: No table's names returned");
+            }
+            // Loop through the tables
+            for (const table of resTables) {
+                let lastId = -1;
+                // define the delete statement
+                const delStmt = `DELETE FROM ${table}
+              WHERE sql_deleted = 1 AND last_modified < ${lastExportDate};`;
+                lastId = await this.sqliteUtil.prepareRun(mDb, delStmt, [], true);
+                if (lastId < 0) {
+                    return Promise.reject('DelExportedRows: lastId < 0');
+                }
+            }
+        }
+        catch (err) {
+            return Promise.reject(`DelExportedRows failed: ${err.message}`);
+        }
+    }
     /**
      * GetViewsNameSQL
      * @param mDb
@@ -1534,7 +1719,7 @@ class ExportToJson {
         sql += "type='view' AND name NOT LIKE 'sqlite_%';";
         let retQuery = [];
         try {
-            retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            retQuery = await this.sqliteUtil.queryAll(mDb, sql, []);
             for (const query of retQuery) {
                 const view = {};
                 view.name = query.name;
@@ -1555,7 +1740,7 @@ class ExportToJson {
         return new Promise((resolve, reject) => {
             let retDate = -1;
             // get the last sync date
-            const stmt = `SELECT sync_date FROM sync_table;`;
+            const stmt = `SELECT sync_date FROM sync_table WHERE id = 1;`;
             mDb.get(stmt, [], (err, row) => {
                 // process the row here
                 if (err) {
@@ -1609,22 +1794,22 @@ class ExportToJson {
                     break;
                 }
                 // check schema validity
-                await this._uJson.checkSchemaValidity(schema);
+                await this.jsonUtil.checkSchemaValidity(schema);
                 // create Table's indexes if any
                 const indexes = await this.getIndexes(mDb, tableName);
                 if (indexes.length > 0) {
                     // check indexes validity
-                    await this._uJson.checkIndexesValidity(indexes);
+                    await this.jsonUtil.checkIndexesValidity(indexes);
                 }
                 // create Table's triggers if any
                 const triggers = await this.getTriggers(mDb, tableName);
                 if (triggers.length > 0) {
                     // check triggers validity
-                    await this._uJson.checkTriggersValidity(triggers);
+                    await this.jsonUtil.checkTriggersValidity(triggers);
                 }
                 // create Table's Data
                 const query = `SELECT * FROM ${tableName};`;
-                const values = await this._uJson.getValues(mDb, query, tableName);
+                const values = await this.jsonUtil.getValues(mDb, query, tableName);
                 table.name = tableName;
                 if (schema.length > 0) {
                     table.schema = schema;
@@ -1722,7 +1907,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 = await this._uSQLite.queryAll(mDb, stmt, []);
+            const retIndexes = await this.sqliteUtil.queryAll(mDb, stmt, []);
             if (retIndexes.length > 0) {
                 for (const rIndex of retIndexes) {
                     const keys = Object.keys(rIndex);
@@ -1771,7 +1956,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 = await this._uSQLite.queryAll(mDb, stmt, []);
+            const retTriggers = await this.sqliteUtil.queryAll(mDb, stmt, []);
             if (retTriggers.length > 0) {
                 for (const rTrg of retTriggers) {
                     const keys = Object.keys(rTrg);
@@ -1881,19 +2066,19 @@ class ExportToJson {
                     schema = await this.getSchema(sqlStmt);
                     if (schema.length > 0) {
                         // check schema validity
-                        await this._uJson.checkSchemaValidity(schema);
+                        await this.jsonUtil.checkSchemaValidity(schema);
                     }
                     // create Table's indexes if any
                     indexes = await this.getIndexes(mDb, tableName);
                     if (indexes.length > 0) {
                         // check indexes validity
-                        await this._uJson.checkIndexesValidity(indexes);
+                        await this.jsonUtil.checkIndexesValidity(indexes);
                     }
                     // create Table's triggers if any
                     triggers = await this.getTriggers(mDb, tableName);
                     if (triggers.length > 0) {
                         // check triggers validity
-                        await this._uJson.checkTriggersValidity(triggers);
+                        await this.jsonUtil.checkTriggersValidity(triggers);
                     }
                 }
                 // create Table's Data
@@ -1906,7 +2091,7 @@ class ExportToJson {
                         `SELECT * FROM ${tableName} ` +
                             `WHERE last_modified > ${syncDate};`;
                 }
-                const values = await this._uJson.getValues(mDb, query, tableName);
+                const values = await this.jsonUtil.getValues(mDb, query, tableName);
                 // check the table object validity
                 table.name = tableName;
                 if (schema.length > 0) {
@@ -1972,7 +2157,7 @@ class ExportToJson {
                 // get total count of the table
                 let stmt = 'SELECT count(*) AS tcount  ';
                 stmt += `FROM ${rTable.name};`;
-                let retQuery = await this._uSQLite.queryAll(db, stmt, []);
+                let retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
                 if (retQuery.length != 1) {
                     errmsg = 'GetTableModified: total ' + 'count not returned';
                     break;
@@ -1982,7 +2167,7 @@ class ExportToJson {
                 stmt = 'SELECT count(*) AS mcount FROM ';
                 stmt += `${rTable.name} WHERE last_modified > `;
                 stmt += `${syncDate};`;
-                retQuery = await this._uSQLite.queryAll(db, stmt, []);
+                retQuery = await this.sqliteUtil.queryAll(db, stmt, []);
                 if (retQuery.length != 1)
                     break;
                 const totalModifiedCount = retQuery[0]['mcount'];
@@ -2050,16 +2235,126 @@ exportToJson.ExportToJson = ExportToJson;
 
 var importFromJson = {};
 
+var utilsDrop = {};
+
+Object.defineProperty(utilsDrop, "__esModule", { value: true });
+utilsDrop.UtilsDrop = void 0;
+const utilsSQLite_1$3 = utilsSQLite;
+class UtilsDrop {
+    constructor() {
+        this.sqliteUtil = new utilsSQLite_1$3.UtilsSQLite();
+    }
+    /**
+     * DropElements
+     * @param db
+     * @param type ["table","index","trigger"]
+     */
+    async dropElements(db, type) {
+        let msg = '';
+        let stmt1 = `AND name NOT LIKE ('sqlite_%')`;
+        switch (type) {
+            case 'index':
+                msg = 'DropIndexes';
+                break;
+            case 'trigger':
+                msg = 'DropTriggers';
+                break;
+            case 'table':
+                msg = 'DropTables';
+                stmt1 += ` AND name NOT IN ('sync_table')`;
+                break;
+            case 'view':
+                msg = 'DropViews';
+                break;
+            default:
+                return Promise.reject(`DropElements: ${type} ` + 'not found');
+        }
+        // get the element's names
+        let stmt = 'SELECT name FROM sqlite_master WHERE ';
+        stmt += `type = '${type}' ${stmt1};`;
+        try {
+            const elements = await this.sqliteUtil.queryAll(db, stmt, []);
+            if (elements.length > 0) {
+                const upType = type.toUpperCase();
+                const statements = [];
+                for (const elem of elements) {
+                    let stmt = `DROP ${upType} IF EXISTS `;
+                    stmt += `${elem.name};`;
+                    statements.push(stmt);
+                }
+                for (const stmt of statements) {
+                    const lastId = await this.sqliteUtil.prepareRun(db, stmt, [], false);
+                    if (lastId < 0) {
+                        return Promise.reject(`${msg}: lastId < 0`);
+                    }
+                }
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`${msg}: ${err}`);
+        }
+    }
+    /**
+     * DropAll
+     * Drop all database's elements
+     * @param db
+     */
+    async dropAll(db) {
+        try {
+            // drop tables
+            await this.dropElements(db, 'table');
+            // drop indexes
+            await this.dropElements(db, 'index');
+            // drop triggers
+            await this.dropElements(db, 'trigger');
+            // drop views
+            await this.dropElements(db, 'view');
+            // vacuum the database
+            await this.sqliteUtil.prepareRun(db, 'VACUUM;', [], false);
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropAll: ${err}`);
+        }
+    }
+    /**
+     * DropTempTables
+     * @param db
+     * @param alterTables
+     */
+    async dropTempTables(db, alterTables) {
+        const tempTables = Object.keys(alterTables);
+        const statements = [];
+        for (const tTable of tempTables) {
+            let stmt = 'DROP TABLE IF EXISTS ';
+            stmt += `_temp_${tTable};`;
+            statements.push(stmt);
+        }
+        try {
+            const changes = await this.sqliteUtil.execute(db, statements.join('\n'), false);
+            if (changes < 0) {
+                return Promise.reject('DropTempTables: changes < 0');
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropTempTables: ${err}`);
+        }
+    }
+}
+utilsDrop.UtilsDrop = UtilsDrop;
+
 Object.defineProperty(importFromJson, "__esModule", { value: true });
 importFromJson.ImportFromJson = void 0;
-const utilsDrop_1$2 = utilsDrop;
+const utilsDrop_1$1 = utilsDrop;
 const utilsSQLite_1$2 = utilsSQLite;
 const utilsJson_1$3 = utilsJson;
 class ImportFromJson {
     constructor() {
-        this._uJson = new utilsJson_1$3.UtilsJson();
-        this._uSQLite = new utilsSQLite_1$2.UtilsSQLite();
-        this._uDrop = new utilsDrop_1$2.UtilsDrop();
+        this.jsonUtil = new utilsJson_1$3.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$2.UtilsSQLite();
+        this.dropUtil = new utilsDrop_1$1.UtilsDrop();
     }
     /**
      * CreateDatabaseSchema
@@ -2071,17 +2366,13 @@ class ImportFromJson {
         const version = jsonData.version;
         try {
             // set User Version PRAGMA
-            await this._uSQLite.setVersion(mDB, version);
+            await this.sqliteUtil.setVersion(mDB, version);
             // DROP ALL when mode="full"
             if (jsonData.mode === 'full') {
-                // set Foreign Keys Off
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
-                await this._uDrop.dropAll(mDB);
+                await this.dropUtil.dropAll(mDB);
             }
-            // set Foreign Keys On
-            await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
             // create database schema
-            changes = await this._uJson.createSchema(mDB, jsonData);
+            changes = await this.jsonUtil.createSchema(mDB, jsonData);
             return Promise.resolve(changes);
         }
         catch (err) {
@@ -2095,9 +2386,9 @@ class ImportFromJson {
         let msg = '';
         let initChanges = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(mDB);
+            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`createTablesData: ${err}`);
@@ -2106,7 +2397,7 @@ class ImportFromJson {
             if (jTable.values != null && jTable.values.length >= 1) {
                 // Create the table's data
                 try {
-                    lastId = await this._uJson.createDataTable(mDB, jTable, jsonData.mode);
+                    lastId = await this.jsonUtil.createDataTable(mDB, jTable, jsonData.mode);
                     if (lastId < 0)
                         break;
                     isValue = true;
@@ -2120,8 +2411,8 @@ class ImportFromJson {
         }
         if (isValue) {
             try {
-                await this._uSQLite.commitTransaction(mDB, true);
-                changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.commitTransaction(mDB, true);
+                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2131,7 +2422,7 @@ class ImportFromJson {
         else {
             if (msg.length > 0) {
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(new Error(`createTablesData: ${msg}`));
                 }
                 catch (err) {
@@ -2155,9 +2446,9 @@ class ImportFromJson {
         let initChanges = -1;
         let changes = -1;
         try {
-            initChanges = await this._uSQLite.dbChanges(mDB);
+            initChanges = await this.sqliteUtil.dbChanges(mDB);
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
         }
         catch (err) {
             return Promise.reject(`createViews: ${err}`);
@@ -2166,7 +2457,7 @@ class ImportFromJson {
             if (jView.value != null) {
                 // Create the view
                 try {
-                    await this._uJson.createView(mDB, jView);
+                    await this.jsonUtil.createView(mDB, jView);
                     isView = true;
                 }
                 catch (err) {
@@ -2178,8 +2469,8 @@ class ImportFromJson {
         }
         if (isView) {
             try {
-                await this._uSQLite.commitTransaction(mDB, true);
-                changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.commitTransaction(mDB, true);
+                changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2189,7 +2480,7 @@ class ImportFromJson {
         else {
             if (msg.length > 0) {
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                     return Promise.reject(new Error(`createViews: ${msg}`));
                 }
                 catch (err) {
@@ -2635,15 +2926,15 @@ var utilsUpgrade = {};
 Object.defineProperty(utilsUpgrade, "__esModule", { value: true });
 utilsUpgrade.UtilsUpgrade = void 0;
 const utilsJson_1$2 = utilsJson;
-const utilsDrop_1$1 = utilsDrop;
+const utilsDrop_1 = utilsDrop;
 const utilsFile_1$2 = utilsFile;
 const utilsSQLite_1$1 = utilsSQLite;
 class UtilsUpgrade {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$1.UtilsSQLite();
-        this._uFile = new utilsFile_1$2.UtilsFile();
-        this._uDrop = new utilsDrop_1$1.UtilsDrop();
-        this._uJson = new utilsJson_1$2.UtilsJson();
+        this.sqliteUtil = new utilsSQLite_1$1.UtilsSQLite();
+        this.fileUtil = new utilsFile_1$2.UtilsFile();
+        this.dropUtil = new utilsDrop_1.UtilsDrop();
+        this.jsonUtil = new utilsJson_1$2.UtilsJson();
         this._alterTables = {};
         this._commonColumns = {};
     }
@@ -2681,9 +2972,9 @@ class UtilsUpgrade {
             }
             try {
                 // set Foreign Keys Off
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, false);
-                await this._uFile.copyFileName(dbName, `backup-${dbName}`);
-                const initChanges = await this._uSQLite.dbChanges(mDB);
+                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, false);
+                await this.fileUtil.copyFileName(dbName, `backup-${dbName}`);
+                const initChanges = await this.sqliteUtil.dbChanges(mDB);
                 // Here we assume that all table schemas are given
                 // in the upgrade statement
                 if (statement.length > 0) {
@@ -2698,8 +2989,8 @@ class UtilsUpgrade {
                     }
                 }
                 // set Foreign Keys On
-                await this._uSQLite.setForeignKeyConstraintsEnabled(mDB, true);
-                const changes = (await this._uSQLite.dbChanges(mDB)) - initChanges;
+                await this.sqliteUtil.setForeignKeyConstraintsEnabled(mDB, true);
+                const changes = (await this.sqliteUtil.dbChanges(mDB)) - initChanges;
                 return Promise.resolve(changes);
             }
             catch (err) {
@@ -2721,11 +3012,11 @@ class UtilsUpgrade {
             //    "temp_tableName"
             await this.backupTables(mDB);
             // -> Drop all Indexes
-            await this._uDrop.dropElements(mDB, 'index');
+            await this.dropUtil.dropElements(mDB, 'index');
             // -> Drop all Triggers
-            await this._uDrop.dropElements(mDB, 'trigger');
+            await this.dropUtil.dropElements(mDB, 'trigger');
             // -> Create new tables from upgrade.statement
-            const changes = await this._uSQLite.execute(mDB, statement);
+            const changes = await this.sqliteUtil.execute(mDB, statement, false);
             if (changes < 0) {
                 return Promise.reject('ExecuteStatementProcess: ' + 'changes < 0');
             }
@@ -2742,7 +3033,7 @@ class UtilsUpgrade {
         }
         finally {
             // -> Drop _temp_tables
-            await this._uDrop.dropTempTables(mDB, this._alterTables);
+            await this.dropUtil.dropTempTables(mDB, this._alterTables);
             // -> Do some cleanup
             this._alterTables = {};
             this._commonColumns = {};
@@ -2757,19 +3048,19 @@ class UtilsUpgrade {
     async executeSetProcess(mDB, set, toVersion) {
         try {
             // -> load new data
-            const lastId = await this._uSQLite.executeSet(mDB, set);
+            const lastId = await this.sqliteUtil.executeSet(mDB, set, false);
             if (lastId < 0) {
                 return Promise.reject('ExecuteSetProcess: lastId ' + '< 0');
             }
             // -> update database version
-            await this._uSQLite.setVersion(mDB, toVersion);
+            await this.sqliteUtil.setVersion(mDB, toVersion);
             // -> update syncDate if any
-            const retB = await this._uJson.isTableExists(mDB, true, 'sync_table');
+            const retB = await this.jsonUtil.isTableExists(mDB, true, 'sync_table');
             if (retB) {
                 const sDate = Math.round(new Date().getTime() / 1000);
                 let stmt = 'UPDATE sync_table SET ';
                 stmt += `sync_date = ${sDate} WHERE id = 1;`;
-                const changes = await this._uSQLite.execute(mDB, stmt);
+                const changes = await this.sqliteUtil.execute(mDB, stmt, false);
                 if (changes < 0) {
                     return Promise.reject('ExecuteSetProcess: changes ' + '< 0');
                 }
@@ -2787,7 +3078,7 @@ class UtilsUpgrade {
     async backupTables(mDB) {
         const msg = 'BackupTables: ';
         try {
-            const tables = await this._uDrop.getTablesNames(mDB);
+            const tables = await this.sqliteUtil.getTablesNames(mDB);
             for (const table of tables) {
                 try {
                     await this.backupTable(mDB, table);
@@ -2810,22 +3101,22 @@ class UtilsUpgrade {
     async backupTable(mDB, table) {
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
             // get the table's column names
             const colNames = await this.getTableColumnNames(mDB, table);
             this._alterTables[`${table}`] = colNames;
             const tmpTable = `_temp_${table}`;
             // Drop the tmpTable if exists
             const delStmt = `DROP TABLE IF EXISTS ${tmpTable};`;
-            await this._uSQLite.prepareRun(mDB, delStmt, []);
+            await this.sqliteUtil.prepareRun(mDB, delStmt, [], false);
             // prefix the table with _temp_
             let stmt = `ALTER TABLE ${table} RENAME `;
             stmt += `TO ${tmpTable};`;
-            const lastId = await this._uSQLite.prepareRun(mDB, stmt, []);
+            const lastId = await this.sqliteUtil.prepareRun(mDB, stmt, [], false);
             if (lastId < 0) {
                 let msg = 'BackupTable: lastId < 0';
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
                     msg += `: ${err}`;
@@ -2834,7 +3125,7 @@ class UtilsUpgrade {
             }
             else {
                 try {
-                    await this._uSQLite.commitTransaction(mDB, true);
+                    await this.sqliteUtil.commitTransaction(mDB, true);
                 }
                 catch (err) {
                     return Promise.reject('BackupTable: ' + `${err}`);
@@ -2856,7 +3147,7 @@ class UtilsUpgrade {
         const retNames = [];
         const query = `PRAGMA table_info('${tableName}');`;
         try {
-            resQuery = await this._uSQLite.queryAll(mDB, query, []);
+            resQuery = await this.sqliteUtil.queryAll(mDB, query, []);
             if (resQuery.length > 0) {
                 for (const query of resQuery) {
                     retNames.push(query.name);
@@ -2875,7 +3166,7 @@ class UtilsUpgrade {
     async findCommonColumns(mDB) {
         try {
             // Get new table list
-            const tables = await this._uDrop.getTablesNames(mDB);
+            const tables = await this.sqliteUtil.getTablesNames(mDB);
             if (tables.length === 0) {
                 return Promise.reject('FindCommonColumns: get ' + "table's names failed");
             }
@@ -2916,7 +3207,7 @@ class UtilsUpgrade {
     async updateNewTablesData(mDB) {
         try {
             // start a transaction
-            await this._uSQLite.beginTransaction(mDB, true);
+            await this.sqliteUtil.beginTransaction(mDB, true);
             const statements = [];
             const keys = Object.keys(this._commonColumns);
             keys.forEach(key => {
@@ -2926,11 +3217,11 @@ class UtilsUpgrade {
                 stmt += `SELECT ${columns} FROM _temp_${key};`;
                 statements.push(stmt);
             });
-            const changes = await this._uSQLite.execute(mDB, statements.join('\n'));
+            const changes = await this.sqliteUtil.execute(mDB, statements.join('\n'), false);
             if (changes < 0) {
                 let msg = 'updateNewTablesData: ' + 'changes < 0';
                 try {
-                    await this._uSQLite.rollbackTransaction(mDB, true);
+                    await this.sqliteUtil.rollbackTransaction(mDB, true);
                 }
                 catch (err) {
                     msg += `: ${err}`;
@@ -2939,7 +3230,7 @@ class UtilsUpgrade {
             }
             else {
                 try {
-                    await this._uSQLite.commitTransaction(mDB, true);
+                    await this.sqliteUtil.commitTransaction(mDB, true);
                     return Promise.resolve();
                 }
                 catch (err) {
@@ -2960,7 +3251,6 @@ const exportToJson_1 = exportToJson;
 const importFromJson_1 = importFromJson;
 const utilsJson_1$1 = utilsJson;
 //import { UtilsEncryption } from './utilsEncryption';
-const utilsDrop_1 = utilsDrop;
 const utilsFile_1$1 = utilsFile;
 const utilsSQLite_1 = utilsSQLite;
 const utilsUpgrade_1 = utilsUpgrade;
@@ -2972,7 +3262,6 @@ class Database {
         this.fileUtil = new utilsFile_1$1.UtilsFile();
         this.sqliteUtil = new utilsSQLite_1.UtilsSQLite();
         this.jsonUtil = new utilsJson_1$1.UtilsJson();
-        this.dropUtil = new utilsDrop_1.UtilsDrop();
         //  private _uGlobal: GlobalSQLite = new GlobalSQLite();
         //  private _uEncrypt: UtilsEncryption = new UtilsEncryption();
         this.upgradeUtil = new utilsUpgrade_1.UtilsUpgrade();
@@ -3153,7 +3442,7 @@ class Database {
         try {
             const retB = await this.jsonUtil.isTableExists(this.database, isOpen, 'sync_table');
             if (!retB) {
-                const isLastModified = await this.jsonUtil.isLastModified(this.database, isOpen);
+                const isLastModified = await this.sqliteUtil.isLastModified(this.database, isOpen);
                 if (isLastModified) {
                     const date = Math.round(new Date().getTime() / 1000);
                     let stmts = `
@@ -3163,7 +3452,7 @@ class Database {
                               );`;
                     stmts += `INSERT INTO sync_table (sync_date) VALUES (
                               "${date}");`;
-                    changes = await this.sqliteUtil.execute(this.database, stmts);
+                    changes = await this.sqliteUtil.execute(this.database, stmts, false);
                     if (changes < 0) {
                         throw new Error(`CreateSyncTable: failed changes < 0`);
                     }
@@ -3175,7 +3464,6 @@ class Database {
             else {
                 changes = 0;
             }
-            console.log(`>>> CreateSyncTable changes: ${changes}`);
             return changes;
         }
         catch (err) {
@@ -3198,7 +3486,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 changes = await this.sqliteUtil.execute(this.database, stmt);
+            const changes = await this.sqliteUtil.execute(this.database, stmt, false);
             if (changes < 0) {
                 return { result: false, message: 'setSyncDate failed' };
             }
@@ -3246,7 +3534,7 @@ class Database {
             if (transaction) {
                 await this.sqliteUtil.beginTransaction(this.database, this._isDbOpen);
             }
-            const changes = await this.sqliteUtil.execute(this.database, sql);
+            const changes = await this.sqliteUtil.execute(this.database, sql, false);
             if (changes < 0) {
                 throw new Error('ExecuteSQL: changes < 0');
             }
@@ -3307,7 +3595,7 @@ class Database {
             throw new Error(`RunSQL: ${err}`);
         }
         try {
-            const lastId = await this.sqliteUtil.prepareRun(this.database, statement, values);
+            const lastId = await this.sqliteUtil.prepareRun(this.database, statement, values, false);
             if (lastId < 0) {
                 if (transaction) {
                     await this.sqliteUtil.rollbackTransaction(this.database, this._isDbOpen);
@@ -3350,7 +3638,7 @@ class Database {
             throw new Error(`ExecSet: ${err}`);
         }
         try {
-            result.lastId = await this.sqliteUtil.executeSet(this.database, set);
+            result.lastId = await this.sqliteUtil.executeSet(this.database, set, false);
             if (transaction) {
                 await this.sqliteUtil.commitTransaction(this.database, this._isDbOpen);
             }
@@ -3370,10 +3658,25 @@ class Database {
             }
         }
     }
+    async deleteExportedRows() {
+        this.ensureDatabaseIsOpen();
+        try {
+            await this.exportToJsonUtil.delExportedRows(this.database);
+            return;
+        }
+        catch (err) {
+            throw new Error(`DeleteExportedRows: ${err}`);
+        }
+    }
+    /**
+     * GetTableList
+     * get the table's list
+     * @returns
+     */
     async getTableList() {
         this.ensureDatabaseIsOpen();
         try {
-            const tableNames = await this.dropUtil.getTablesNames(this.database);
+            const tableNames = await this.sqliteUtil.getTablesNames(this.database);
             return tableNames;
         }
         catch (err) {
@@ -3384,6 +3687,8 @@ class Database {
         let changes = 0;
         this.ensureDatabaseIsOpen();
         try {
+            // set Foreign Keys Off
+            await this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, false);
             if (jsonData.tables && jsonData.tables.length > 0) {
                 // create the database schema
                 changes = await this.importFromJsonUtil.createDatabaseSchema(this.database, jsonData);
@@ -3396,6 +3701,8 @@ class Database {
                 // create the views
                 changes += await this.importFromJsonUtil.createViews(this.database, jsonData);
             }
+            // set Foreign Keys On
+            await this.sqliteUtil.setForeignKeyConstraintsEnabled(this.database, true);
             return changes;
         }
         catch (err) {
@@ -3410,7 +3717,13 @@ class Database {
         inJson.mode = mode;
         this.ensureDatabaseIsOpen();
         try {
+            await this.exportToJsonUtil.setLastExportDate(this.database, new Date().toISOString());
             const jsonResult = await this.exportToJsonUtil.createExportObject(this.database, inJson);
+            const keys = Object.keys(jsonResult);
+            if (keys.length === 0) {
+                const msg = `ExportJson: return Object is empty ` + `No data to synchronize`;
+                throw new Error(msg);
+            }
             const isValid = this.jsonUtil.isJsonSQLite(jsonResult);
             if (isValid) {
                 return jsonResult;
@@ -3773,6 +4086,17 @@ class CapacitorSQLite {
             throw new Error(`GetSyncDate: ${err}`);
         }
     }
+    async deleteExportedRows(options) {
+        const dbName = this.getOptionValue(options, 'database');
+        const database = this.getDatabaseConnectionOrThrowError(dbName);
+        try {
+            await database.deleteExportedRows();
+            return Promise.resolve();
+        }
+        catch (err) {
+            throw new Error(`DeleteExportedRows: ${err}`);
+        }
+    }
     async addUpgradeStatement(options) {
         const dbName = this.getOptionValue(options, 'database');
         const upgrades = this.getOptionValue(options, 'upgrade');
@@ -3984,12 +4308,6 @@ class CapacitorSQLite {
         console.log('isNCDatabase', options);
         throw new Error('Method not implemented.');
     }
-    async deleteExportedRows(options) {
-        const dbName = this.getOptionValue(options, 'database');
-        //    const database = this.getDatabaseConnectionOrThrowError(dbName);
-        console.log('deleteExportedRows', dbName);
-        throw new Error('Method not implemented.');
-    }
 }
 exports.CapacitorSQLite = src.CapacitorSQLite = CapacitorSQLite;