@capacitor-community/sqlite 3.4.1-1 → 3.4.1-2

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

@@ -569,17 +569,22 @@ public class Database {
         // check if the table has already been created
         boolean isExists = _uJson.isTableExists(this, "sync_table");
         if (!isExists) {
-            Date date = new Date();
-            long syncTime = date.getTime() / 1000L;
-            String[] statements = {
-                "CREATE TABLE IF NOT EXISTS sync_table (" + "id INTEGER PRIMARY KEY NOT NULL," + "sync_date INTEGER);",
-                "INSERT INTO sync_table (sync_date) VALUES ('" + syncTime + "');"
-            };
-            try {
-                retObj = execute(statements);
-                return retObj;
-            } catch (Exception e) {
-                throw new Exception(e.getMessage());
+            boolean isLastModified = _uJson.isLastModified(this);
+            if (isLastModified) {
+                Date date = new Date();
+                long syncTime = date.getTime() / 1000L;
+                String[] statements = {
+                    "CREATE TABLE IF NOT EXISTS sync_table (" + "id INTEGER PRIMARY KEY NOT NULL," + "sync_date INTEGER);",
+                    "INSERT INTO sync_table (sync_date) VALUES ('" + syncTime + "');"
+                };
+                try {
+                    retObj = execute(statements);
+                    return retObj;
+                } catch (Exception e) {
+                    throw new Exception(e.getMessage());
+                }
+            } else {
+                throw new Exception("No last_modified column in tables");
             }
         } else {
             retObj.put("changes", Integer.valueOf(0));
@@ -596,6 +601,10 @@ public class Database {
     public void setSyncDate(String syncDate) throws Exception {
         JSObject retObj = new JSObject();
         try {
+            boolean isSyncTable = _uJson.isTableExists(this, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("No sync_table available");
+            }
             SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
             Date date = formatter.parse(syncDate.replaceAll("Z$", "+0000"));
             long syncTime = date.getTime() / 1000L;
@@ -614,6 +623,10 @@ public class Database {
     public Long getSyncDate() throws Exception {
         long syncDate = 0;
         try {
+            boolean isSyncTable = _uJson.isTableExists(this, "sync_table");
+            if (!isSyncTable) {
+                throw new Exception("No sync_table available");
+            }
             syncDate = toJson.getSyncDate(this);
             return syncDate;
         } catch (Exception e) {

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

@@ -68,6 +68,11 @@ public class ExportToJson {
             if (resTables.length() == 0) {
                 throw new Exception("CreateExportObject: table's names failed");
             } else {
+                boolean isSyncTable = uJson.isTableExists(db, "sync_table");
+                if (!isSyncTable && sqlObj.getMode().equals("partial")) {
+                    throw new Exception("No sync_table available");
+                }
+
                 switch (sqlObj.getMode()) {
                     case "partial":
                         tables = getTablesPartial(db, resTables);

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

@@ -167,11 +167,15 @@ public class ImportFromJson {
     private ArrayList<String> createTableSchema(ArrayList<JsonColumn> mSchema, String tableName) {
         ArrayList<String> statements = new ArrayList<>();
         String stmt = new StringBuilder("CREATE TABLE IF NOT EXISTS ").append(tableName).append(" (").toString();
+        Boolean isLastModified = false;
         for (int j = 0; j < mSchema.size(); j++) {
             if (j == mSchema.size() - 1) {
                 if (mSchema.get(j).getColumn() != null) {
                     stmt =
                         new StringBuilder(stmt).append(mSchema.get(j).getColumn()).append(" ").append(mSchema.get(j).getValue()).toString();
+                    if (mSchema.get(j).getColumn().equals("last_modified")) {
+                        isLastModified = true;
+                    }
                 } else if (mSchema.get(j).getForeignkey() != null) {
                     stmt =
                         new StringBuilder(stmt)
@@ -198,6 +202,9 @@ public class ImportFromJson {
                             .append(mSchema.get(j).getValue())
                             .append(",")
                             .toString();
+                    if (mSchema.get(j).getColumn().equals("last_modified")) {
+                        isLastModified = true;
+                    }
                 } else if (mSchema.get(j).getForeignkey() != null) {
                     stmt =
                         new StringBuilder(stmt)
@@ -221,21 +228,23 @@ public class ImportFromJson {
         }
         stmt = new StringBuilder(stmt).append(");").toString();
         statements.add(stmt);
-        // create trigger last_modified associated with the table
-        String stmtTrigger = new StringBuilder("CREATE TRIGGER IF NOT EXISTS ")
-            .append(tableName)
-            .append("_trigger_last_modified")
-            .append(" AFTER UPDATE ON ")
-            .append(tableName)
-            .append(" FOR EACH ROW ")
-            .append("WHEN NEW.last_modified <= " + "OLD.last_modified BEGIN ")
-            .append("UPDATE ")
-            .append(tableName)
-            .append(" SET last_modified = (strftime('%s','now')) ")
-            .append("WHERE id=OLD.id; ")
-            .append("END;")
-            .toString();
-        statements.add(stmtTrigger);
+        if (isLastModified) {
+            // create trigger last_modified associated with the table
+            String stmtTrigger = new StringBuilder("CREATE TRIGGER IF NOT EXISTS ")
+                .append(tableName)
+                .append("_trigger_last_modified")
+                .append(" AFTER UPDATE ON ")
+                .append(tableName)
+                .append(" FOR EACH ROW ")
+                .append("WHEN NEW.last_modified <= " + "OLD.last_modified BEGIN ")
+                .append("UPDATE ")
+                .append(tableName)
+                .append(" SET last_modified = (strftime('%s','now')) ")
+                .append("WHERE id=OLD.id; ")
+                .append("END;")
+                .toString();
+            statements.add(stmtTrigger);
+        }
         return statements;
     }
 

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

@@ -3,6 +3,7 @@ package com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson;
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.community.database.sqlite.SQLite.Database;
+import com.getcapacitor.community.database.sqlite.SQLite.UtilsDrop;
 import java.sql.Blob;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -16,6 +17,28 @@ public class UtilsJson {
     private JsonIndex uJIdx = new JsonIndex();
     private JsonTrigger uJTrg = new JsonTrigger();
     private JsonView uJView = new JsonView();
+    private UtilsDrop _uDrop = new UtilsDrop();
+
+    public boolean isLastModified(Database db) throws Exception {
+        if (!db.isOpen()) {
+            throw new Exception("isLastModified: Database not opened");
+        }
+        boolean ret = false;
+        try {
+            List<String> tables = _uDrop.getTablesNames(db);
+            for (String tableName : tables) {
+                JSObject namesTypes = getTableColumnNamesTypes(db, tableName);
+                ArrayList<String> colNames = (ArrayList<String>) namesTypes.get("names");
+                if (colNames.contains("last_modified")) {
+                    ret = true;
+                    break;
+                }
+            }
+            return ret;
+        } catch (Exception e) {
+            throw new Exception("isLastModified: " + e.getMessage());
+        }
+    }
 
     /**
      * Check if a table exists

package/electron/dist/plugin.js

@@ -435,12 +435,187 @@ 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
+     */
+    async getTablesNames(mDb) {
+        let sql = 'SELECT name FROM sqlite_master WHERE ';
+        sql += "type='table' AND name NOT LIKE 'sync_table' ";
+        sql += "AND name NOT LIKE '_temp_%' ";
+        sql += "AND name NOT LIKE 'sqlite_%' ";
+        sql += 'ORDER BY rootpage DESC;';
+        const retArr = [];
+        try {
+            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            for (const query of retQuery) {
+                retArr.push(query.name);
+            }
+            return Promise.resolve(retArr);
+        }
+        catch (err) {
+            return Promise.reject(`getTablesNames: ${err}`);
+        }
+    }
+    /**
+     * GetViewsNames
+     * @param mDb
+     */
+    async getViewsNames(mDb) {
+        let sql = 'SELECT name FROM sqlite_master WHERE ';
+        sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
+        sql += 'ORDER BY rootpage DESC;';
+        const retArr = [];
+        try {
+            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
+            for (const query of retQuery) {
+                retArr.push(query.name);
+            }
+            return Promise.resolve(retArr);
+        }
+        catch (err) {
+            return Promise.reject(`getViewsNames: ${err}`);
+        }
+    }
+    /**
+     * DropElements
+     * @param db
+     * @param type ["table","index","trigger"]
+     */
+    async dropElements(db, type) {
+        let msg = '';
+        switch (type) {
+            case 'index':
+                msg = 'DropIndexes';
+                break;
+            case 'trigger':
+                msg = 'DropTriggers';
+                break;
+            case 'table':
+                msg = 'DropTables';
+                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}' AND name NOT LIKE 'sqlite_%';`;
+        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`);
+                    }
+                }
+            }
+            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}`);
+        }
+    }
+    /**
+     * 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._uSQLite.execute(db, statements.join('\n'));
+            if (changes < 0) {
+                return Promise.reject('DropTempTables: changes < 0');
+            }
+            return Promise.resolve();
+        }
+        catch (err) {
+            return Promise.reject(`DropTempTables: ${err}`);
+        }
+    }
+}
+utilsDrop.UtilsDrop = UtilsDrop;
+
 Object.defineProperty(utilsJson, "__esModule", { value: true });
 utilsJson.UtilsJson = void 0;
-const utilsSQLite_1$5 = utilsSQLite;
+const utilsDrop_1$2 = utilsDrop;
+const utilsSQLite_1$4 = utilsSQLite;
 class UtilsJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$5.UtilsSQLite();
+        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
+        this._uDrop = new utilsDrop_1$2.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}`);
+        }
     }
     /**
      * IsTableExists
@@ -554,6 +729,7 @@ class UtilsJson {
      */
     async createSchemaStatement(jsonData) {
         const statements = [];
+        let isLastModified = false;
         // Prepare the statement to execute
         try {
             for (const jTable of jsonData.tables) {
@@ -564,6 +740,9 @@ class UtilsJson {
                         if (j === jTable.schema.length - 1) {
                             if (jTable.schema[j].column) {
                                 statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value}`);
+                                if (jTable.schema[j].column === 'last_modified') {
+                                    isLastModified = true;
+                                }
                             }
                             else if (jTable.schema[j].foreignkey) {
                                 statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value}`);
@@ -575,6 +754,9 @@ class UtilsJson {
                         else {
                             if (jTable.schema[j].column) {
                                 statements.push(`${jTable.schema[j].column} ${jTable.schema[j].value},`);
+                                if (jTable.schema[j].column === 'last_modified') {
+                                    isLastModified = true;
+                                }
                             }
                             else if (jTable.schema[j].foreignkey) {
                                 statements.push(`FOREIGN KEY (${jTable.schema[j].foreignkey}) ${jTable.schema[j].value},`);
@@ -585,17 +767,19 @@ class UtilsJson {
                         }
                     }
                     statements.push(');');
-                    // create trigger last_modified associated with the table
-                    let trig = 'CREATE TRIGGER IF NOT EXISTS ';
-                    trig += `${jTable.name}`;
-                    trig += `_trigger_last_modified `;
-                    trig += `AFTER UPDATE ON ${jTable.name} `;
-                    trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
-                    trig += 'OLD.last_modified BEGIN UPDATE ';
-                    trig += `${jTable.name} `;
-                    trig += `SET last_modified = `;
-                    trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
-                    statements.push(trig);
+                    if (isLastModified) {
+                        // create trigger last_modified associated with the table
+                        let trig = 'CREATE TRIGGER IF NOT EXISTS ';
+                        trig += `${jTable.name}`;
+                        trig += `_trigger_last_modified `;
+                        trig += `AFTER UPDATE ON ${jTable.name} `;
+                        trig += 'FOR EACH ROW WHEN NEW.last_modified <= ';
+                        trig += 'OLD.last_modified BEGIN UPDATE ';
+                        trig += `${jTable.name} `;
+                        trig += `SET last_modified = `;
+                        trig += "(strftime('%s','now')) WHERE id=OLD.id; END;";
+                        statements.push(trig);
+                    }
                 }
                 if (jTable.indexes != null && jTable.indexes.length >= 1) {
                     for (const jIndex of jTable.indexes) {
@@ -1165,11 +1349,11 @@ utilsJson.UtilsJson = UtilsJson;
 
 Object.defineProperty(exportToJson, "__esModule", { value: true });
 exportToJson.ExportToJson = void 0;
-const utilsSQLite_1$4 = utilsSQLite;
+const utilsSQLite_1$3 = utilsSQLite;
 const utilsJson_1$4 = utilsJson;
 class ExportToJson {
     constructor() {
-        this._uSQLite = new utilsSQLite_1$4.UtilsSQLite();
+        this._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
         this._uJson = new utilsJson_1$4.UtilsJson();
     }
     /**
@@ -1191,6 +1375,10 @@ class ExportToJson {
                 return Promise.reject("createExportObject: table's names failed");
             }
             else {
+                const isTable = await this._uJson.isTableExists(mDB, true, 'sync_table');
+                if (!isTable && sqlObj.mode === 'partial') {
+                    return Promise.reject('No sync_table available');
+                }
                 switch (sqlObj.mode) {
                     case 'partial': {
                         tables = await this.getTablesPartial(mDB, resTables);
@@ -1807,156 +1995,6 @@ 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._uSQLite = new utilsSQLite_1$3.UtilsSQLite();
-    }
-    /**
-     * GetTablesNames
-     * @param mDb
-     */
-    async getTablesNames(mDb) {
-        let sql = 'SELECT name FROM sqlite_master WHERE ';
-        sql += "type='table' AND name NOT LIKE 'sync_table' ";
-        sql += "AND name NOT LIKE '_temp_%' ";
-        sql += "AND name NOT LIKE 'sqlite_%' ";
-        sql += 'ORDER BY rootpage DESC;';
-        const retArr = [];
-        try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
-            for (const query of retQuery) {
-                retArr.push(query.name);
-            }
-            return Promise.resolve(retArr);
-        }
-        catch (err) {
-            return Promise.reject(`getTablesNames: ${err}`);
-        }
-    }
-    /**
-     * GetViewsNames
-     * @param mDb
-     */
-    async getViewsNames(mDb) {
-        let sql = 'SELECT name FROM sqlite_master WHERE ';
-        sql += "type='view' AND name NOT LIKE 'sqlite_%' ";
-        sql += 'ORDER BY rootpage DESC;';
-        const retArr = [];
-        try {
-            const retQuery = await this._uSQLite.queryAll(mDb, sql, []);
-            for (const query of retQuery) {
-                retArr.push(query.name);
-            }
-            return Promise.resolve(retArr);
-        }
-        catch (err) {
-            return Promise.reject(`getViewsNames: ${err}`);
-        }
-    }
-    /**
-     * DropElements
-     * @param db
-     * @param type ["table","index","trigger"]
-     */
-    async dropElements(db, type) {
-        let msg = '';
-        switch (type) {
-            case 'index':
-                msg = 'DropIndexes';
-                break;
-            case 'trigger':
-                msg = 'DropTriggers';
-                break;
-            case 'table':
-                msg = 'DropTables';
-                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}' AND name NOT LIKE 'sqlite_%';`;
-        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`);
-                    }
-                }
-            }
-            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}`);
-        }
-    }
-    /**
-     * 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._uSQLite.execute(db, statements.join('\n'));
-            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$1 = utilsDrop;
@@ -3069,17 +3107,23 @@ class Database {
         try {
             const retB = await this._uJson.isTableExists(this._mDB, isOpen, 'sync_table');
             if (!retB) {
-                const date = Math.round(new Date().getTime() / 1000);
-                let stmts = `
-                        CREATE TABLE IF NOT EXISTS sync_table (
-                            id INTEGER PRIMARY KEY NOT NULL,
-                            sync_date INTEGER
-                            );`;
-                stmts += `INSERT INTO sync_table (sync_date) VALUES (
-                            "${date}");`;
-                changes = await this._uSQLite.execute(this._mDB, stmts);
-                if (changes < 0) {
-                    return Promise.reject(`CreateSyncTable: failed changes < 0`);
+                const isLastModified = await this._uJson.isLastModified(this._mDB, isOpen);
+                if (isLastModified) {
+                    const date = Math.round(new Date().getTime() / 1000);
+                    let stmts = `
+                          CREATE TABLE IF NOT EXISTS sync_table (
+                              id INTEGER PRIMARY KEY NOT NULL,
+                              sync_date INTEGER
+                              );`;
+                    stmts += `INSERT INTO sync_table (sync_date) VALUES (
+                              "${date}");`;
+                    changes = await this._uSQLite.execute(this._mDB, stmts);
+                    if (changes < 0) {
+                        return Promise.reject(`CreateSyncTable: failed changes < 0`);
+                    }
+                }
+                else {
+                    return Promise.reject('No last_modified column in tables');
                 }
             }
             return Promise.resolve(changes);
@@ -3101,6 +3145,10 @@ class Database {
             return { result: false, message: msg };
         }
         try {
+            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('No sync_table available');
+            }
             const sDate = Math.round(new Date(syncDate).getTime() / 1000);
             let stmt = `UPDATE sync_table SET sync_date = `;
             stmt += `${sDate} WHERE id = 1;`;
@@ -3128,6 +3176,10 @@ class Database {
             return { syncDate: 0, message: msg };
         }
         try {
+            const isTable = await this._uJson.isTableExists(this._mDB, this._isDBOpen, 'sync_table');
+            if (!isTable) {
+                return Promise.reject('No sync_table available');
+            }
             const syncDate = await this._eTJson.getSyncDate(this._mDB);
             if (syncDate > 0) {
                 return { syncDate: syncDate };