From c54438d6d3bad38bc76dfcd61f58929fe30279cb Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Sat, 13 Nov 2021 11:34:30 +0100
Subject: [PATCH 01/10] feat(SQLite): connection add/edit masks

---
 .vscode/settings.json                         |  3 +-
 src/common/customizations/defaults.js         |  3 +
 src/common/customizations/index.js            |  3 +-
 src/common/customizations/mysql.js            |  2 +
 src/common/customizations/postgresql.js       |  2 +
 src/common/customizations/sqlite.js           | 81 +++++++++++++++++++
 .../WorkspaceAddConnectionPanel.vue           | 52 +++++++-----
 .../WorkspaceEditConnectionPanel.vue          | 47 +++++++----
 .../images/svg/{sqllite.svg => sqlite.svg}    |  0
 src/renderer/scss/_db-icons.scss              |  4 +
 .../store/modules/connections.store.js        | 24 ++++--
 11 files changed, 180 insertions(+), 41 deletions(-)
 create mode 100644 src/common/customizations/sqlite.js
 rename src/renderer/images/svg/{sqllite.svg => sqlite.svg} (100%)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 5b0c8130..649205af 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,7 +3,8 @@
       "UI",
       "core",
       "MySQL",
-      "PostgreSQL"
+      "PostgreSQL",
+      "SQLite"
    ],
    "svg.preview.background": "transparent"
 }
\ No newline at end of file
diff --git a/src/common/customizations/defaults.js b/src/common/customizations/defaults.js
index 062836a2..70b5295a 100644
--- a/src/common/customizations/defaults.js
+++ b/src/common/customizations/defaults.js
@@ -8,6 +8,9 @@ module.exports = {
    collations: false,
    engines: false,
    connectionSchema: false,
+   sslConnection: false,
+   sshConnection: false,
+   fileConnection: false,
    // Tools
    processesList: false,
    usersManagement: false,
diff --git a/src/common/customizations/index.js b/src/common/customizations/index.js
index 304889a4..931e18f2 100644
--- a/src/common/customizations/index.js
+++ b/src/common/customizations/index.js
@@ -1,5 +1,6 @@
 module.exports = {
    maria: require('./mysql'),
    mysql: require('./mysql'),
-   pg: require('./postgresql')
+   pg: require('./postgresql'),
+   sqlite: require('./sqlite')
 };
diff --git a/src/common/customizations/mysql.js b/src/common/customizations/mysql.js
index 673adea2..0b6c683e 100644
--- a/src/common/customizations/mysql.js
+++ b/src/common/customizations/mysql.js
@@ -10,6 +10,8 @@ module.exports = {
    connectionSchema: true,
    collations: true,
    engines: true,
+   sslConnection: true,
+   sshConnection: true,
    // Tools
    processesList: true,
    // Structure
diff --git a/src/common/customizations/postgresql.js b/src/common/customizations/postgresql.js
index b3547ccc..341aa538 100644
--- a/src/common/customizations/postgresql.js
+++ b/src/common/customizations/postgresql.js
@@ -8,6 +8,8 @@ module.exports = {
    defaultDatabase: 'postgres',
    // Core
    database: true,
+   sslConnection: true,
+   sshConnection: true,
    // Tools
    processesList: true,
    // Structure
diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
new file mode 100644
index 00000000..96e2a56f
--- /dev/null
+++ b/src/common/customizations/sqlite.js
@@ -0,0 +1,81 @@
+module.exports = {
+   // Defaults
+   defaultPort: null,
+   defaultUser: null,
+   defaultDatabase: null,
+   // Core
+   database: false,
+   collations: false,
+   engines: false,
+   connectionSchema: false,
+   fileConnection: true,
+   // Tools
+   processesList: false,
+   usersManagement: false,
+   variables: false,
+   // Structure
+   schemas: false,
+   tables: false,
+   views: false,
+   triggers: false,
+   triggerFunctions: false,
+   routines: false,
+   functions: false,
+   schedulers: false,
+   // Settings
+   elementsWrapper: '',
+   stringsWrapper: '"',
+   tableAdd: false,
+   viewAdd: false,
+   triggerAdd: false,
+   triggerFunctionAdd: false,
+   routineAdd: false,
+   functionAdd: false,
+   schedulerAdd: false,
+   databaseEdit: false,
+   schemaEdit: false,
+   tableSettings: false,
+   viewSettings: false,
+   triggerSettings: false,
+   triggerFunctionSettings: false,
+   routineSettings: false,
+   functionSettings: false,
+   schedulerSettings: false,
+   indexes: false,
+   foreigns: false,
+   sortableFields: false,
+   unsigned: false,
+   nullable: false,
+   zerofill: false,
+   tableOptions: false,
+   autoIncrement: false,
+   comment: false,
+   collation: false,
+   definer: false,
+   onUpdate: false,
+   tableArray: false,
+   viewAlgorithm: false,
+   viewSqlSecurity: false,
+   viewUpdateOption: false,
+   procedureDeterministic: false,
+   procedureDataAccess: false,
+   procedureSql: false,
+   procedureContext: false,
+   procedureLanguage: false,
+   functionDeterministic: false,
+   functionDataAccess: false,
+   functionSql: false,
+   functionContext: false,
+   functionLanguage: false,
+   triggerSql: false,
+   triggerStatementInCreation: false,
+   triggerMultipleEvents: false,
+   triggerTableInName: false,
+   triggerUpdateColumns: false,
+   triggerOnlyRename: false,
+   triggerEnableDisable: false,
+   triggerFunctionSql: false,
+   triggerFunctionlanguages: false,
+   parametersLength: false,
+   languages: false
+};
diff --git a/src/renderer/components/WorkspaceAddConnectionPanel.vue b/src/renderer/components/WorkspaceAddConnectionPanel.vue
index e8802235..ede77563 100644
--- a/src/renderer/components/WorkspaceAddConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceAddConnectionPanel.vue
@@ -11,6 +11,7 @@
                   <a class="tab-link">{{ $t('word.general') }}</a>
                </li>
                <li
+                  v-if="customizations.sslConnection"
                   class="tab-item c-hand"
                   :class="{'active': selectedTab === 'ssl'}"
                   @click="selectTab('ssl')"
@@ -18,6 +19,7 @@
                   <a class="tab-link">{{ $t('word.ssl') }}</a>
                </li>
                <li
+                  v-if="customizations.sshConnection"
                   class="tab-item c-hand"
                   :class="{'active': selectedTab === 'ssh'}"
                   @click="selectTab('ssh')"
@@ -49,25 +51,17 @@
                         </div>
                         <div class="column col-8 col-sm-12">
                            <select v-model="connection.client" class="form-select">
-                              <option value="mysql">
-                                 MySQL
+                              <option
+                                 v-for="client in clients"
+                                 :key="client.slug"
+                                 :value="client.slug"
+                              >
+                                 {{ client.name }}
                               </option>
-                              <option value="maria">
-                                 MariaDB
-                              </option>
-                              <option value="pg">
-                                 PostgreSQL
-                              </option>
-                              <!-- <option value="mssql">
-                                       Microsoft SQL
-                                    </option>
-                                    <option value="oracledb">
-                                       Oracle DB
-                                    </option> -->
                            </select>
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.hostName') }}/IP</label>
                         </div>
@@ -79,7 +73,20 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="customizations.fileConnection" class="form-group columns">
+                        <div class="column col-4 col-sm-12">
+                           <label class="form-label">{{ $t('word.database') }}</label>
+                        </div>
+                        <div class="column col-8 col-sm-12">
+                           <BaseUploadInput
+                              :value="connection.databasePath"
+                              :message="$t('word.browse')"
+                              @clear="pathClear('databasePath')"
+                              @change="pathSelection($event, 'databasePath')"
+                           />
+                        </div>
+                     </div>
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.port') }}</label>
                         </div>
@@ -105,7 +112,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.user') }}</label>
                         </div>
@@ -118,7 +125,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.password') }}</label>
                         </div>
@@ -144,7 +151,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12" />
                         <div class="column col-8 col-sm-12">
                            <label class="form-checkbox form-inline">
@@ -369,11 +376,18 @@ export default {
    },
    data () {
       return {
+         clients: [
+            { name: 'MySQL', slug: 'mysql' },
+            { name: 'MariaDB', slug: 'maria' },
+            { name: 'PostgreSQL', slug: 'pg' },
+            { name: 'SQLite', slug: 'sqlite' }
+         ],
          connection: {
             name: '',
             client: 'mysql',
             host: '127.0.0.1',
             database: null,
+            databasePath: '',
             port: null,
             user: null,
             password: '',
diff --git a/src/renderer/components/WorkspaceEditConnectionPanel.vue b/src/renderer/components/WorkspaceEditConnectionPanel.vue
index 01361862..55e5253e 100644
--- a/src/renderer/components/WorkspaceEditConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceEditConnectionPanel.vue
@@ -11,6 +11,7 @@
                   <a class="tab-link">{{ $t('word.general') }}</a>
                </li>
                <li
+                  v-if="customizations.sslConnection"
                   class="tab-item c-hand"
                   :class="{'active': selectedTab === 'ssl'}"
                   @click="selectTab('ssl')"
@@ -18,6 +19,7 @@
                   <a class="tab-link">{{ $t('word.ssl') }}</a>
                </li>
                <li
+                  v-if="customizations.sshConnection"
                   class="tab-item c-hand"
                   :class="{'active': selectedTab === 'ssh'}"
                   @click="selectTab('ssh')"
@@ -49,19 +51,17 @@
                         </div>
                         <div class="column col-8 col-sm-12">
                            <select v-model="localConnection.client" class="form-select">
-                              <option value="mysql">
-                                 MySQL
-                              </option>
-                              <option value="maria">
-                                 MariaDB
-                              </option>
-                              <option value="pg">
-                                 PostgreSQL
+                              <option
+                                 v-for="client in clients"
+                                 :key="client.slug"
+                                 :value="client.slug"
+                              >
+                                 {{ client.name }}
                               </option>
                            </select>
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.hostName') }}/IP</label>
                         </div>
@@ -73,7 +73,20 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="customizations.fileConnection" class="form-group columns">
+                        <div class="column col-4 col-sm-12">
+                           <label class="form-label">{{ $t('word.database') }}</label>
+                        </div>
+                        <div class="column col-8 col-sm-12">
+                           <BaseUploadInput
+                              :value="localConnection.databasePath"
+                              :message="$t('word.browse')"
+                              @clear="pathClear('databasePath')"
+                              @change="pathSelection($event, 'databasePath')"
+                           />
+                        </div>
+                     </div>
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.port') }}</label>
                         </div>
@@ -99,7 +112,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.user') }}</label>
                         </div>
@@ -112,7 +125,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12">
                            <label class="form-label">{{ $t('word.password') }}</label>
                         </div>
@@ -138,7 +151,7 @@
                            >
                         </div>
                      </div>
-                     <div class="form-group columns">
+                     <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12" />
                         <div class="column col-8 col-sm-12">
                            <label class="form-checkbox form-inline">
@@ -374,6 +387,12 @@ export default {
    },
    data () {
       return {
+         clients: [
+            { name: 'MySQL', slug: 'mysql' },
+            { name: 'MariaDB', slug: 'maria' },
+            { name: 'PostgreSQL', slug: 'pg' },
+            { name: 'SQLite', slug: 'sqlite' }
+         ],
          isConnecting: false,
          isTesting: false,
          isAsking: false,
@@ -383,7 +402,7 @@ export default {
    },
    computed: {
       customizations () {
-         return customizations[this.connection.client];
+         return customizations[this.localConnection.client];
       },
       isBusy () {
          return this.isConnecting || this.isTesting;
diff --git a/src/renderer/images/svg/sqllite.svg b/src/renderer/images/svg/sqlite.svg
similarity index 100%
rename from src/renderer/images/svg/sqllite.svg
rename to src/renderer/images/svg/sqlite.svg
diff --git a/src/renderer/scss/_db-icons.scss b/src/renderer/scss/_db-icons.scss
index 23e157d7..9124f837 100644
--- a/src/renderer/scss/_db-icons.scss
+++ b/src/renderer/scss/_db-icons.scss
@@ -20,6 +20,10 @@
     background-image: url("../images/svg/pg.svg");
   }
 
+  &.dbi-sqlite { 
+    background-image: url("../images/svg/sqlite.svg");
+  }
+
   &.dbi-oracledb {
     background-image: url("../images/svg/oracledb.svg");
   }
diff --git a/src/renderer/store/modules/connections.store.js b/src/renderer/store/modules/connections.store.js
index 5f352fff..e87c25d3 100644
--- a/src/renderer/store/modules/connections.store.js
+++ b/src/renderer/store/modules/connections.store.js
@@ -24,12 +24,24 @@ export default {
       getConnections: state => state.connections,
       getConnectionName: state => uid => {
          const connection = state.connections.filter(connection => connection.uid === uid)[0];
-         if (!connection) return '';
-         return connection.name
-            ? connection.name
-            : connection.ask
-               ? `${connection.host}:${connection.port}`
-               : `${connection.user + '@'}${connection.host}:${connection.port}`;
+         let connectionName = '';
+
+         if (connection.name)
+            connectionName = connection.name;
+         else if (connection.ask)
+            connectionName = `${connection.host}:${connection.port}`;
+         else if (connection.databasePath) {
+            let string = connection.databasePath.split(/[/\\]+/).pop();
+
+            if (string.length >= 30)
+               string = `...${string.slice(-30)}`;
+
+            connectionName = string;
+         }
+         else
+            connectionName = `${connection.user + '@'}${connection.host}:${connection.port}`;
+
+         return connectionName;
       }
    },
    mutations: {

From f2fcc9883972402eab4d51ef2a9796638dde2d3d Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Sat, 13 Nov 2021 23:00:53 +0100
Subject: [PATCH 02/10] feat(SQLite): table data visualization

---
 package.json                          |    5 +-
 src/main/ipc-handlers/connection.js   |    6 +
 src/main/libs/ClientsFactory.js       |    3 +
 src/main/libs/clients/SQLiteClient.js | 1296 +++++++++++++++++++++++++
 4 files changed, 1308 insertions(+), 2 deletions(-)
 create mode 100644 src/main/libs/clients/SQLiteClient.js

diff --git a/package.json b/package.json
index 9f8c5039..ddbc32a0 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,7 @@
     "build": "cross-env NODE_ENV=production npm run compile",
     "build:local": "npm run build && electron-builder",
     "build:appx": "npm run build:local -- --win appx",
-    "rebuild:electron": "npm run postinstall && electron-rebuild",
+    "rebuild:electron": "npm run postinstall",
     "release": "standard-version",
     "release:pre": "npm run release -- --prerelease alpha",
     "postinstall": "electron-builder install-app-deps",
@@ -30,6 +30,7 @@
     "appId": "com.fabio286.antares",
     "artifactName": "${productName}-${version}-${os}_${arch}.${ext}",
     "asar": true,
+    "buildDependenciesFromSource": true,
     "directories": {
       "output": "build",
       "buildResources": "assets"
@@ -104,6 +105,7 @@
     "@electron/remote": "^2.0.1",
     "@mdi/font": "^6.1.95",
     "ace-builds": "^1.4.13",
+    "better-sqlite3": "^7.4.4",
     "electron-log": "^4.4.1",
     "electron-store": "^8.0.1",
     "electron-updater": "^4.3.9",
@@ -134,7 +136,6 @@
     "electron": "^15.3.0",
     "electron-builder": "^22.13.1",
     "electron-devtools-installer": "^3.2.0",
-    "electron-rebuild": "^3.2.3",
     "eslint": "^7.32.0",
     "eslint-config-standard": "^16.0.3",
     "eslint-plugin-import": "^2.24.2",
diff --git a/src/main/ipc-handlers/connection.js b/src/main/ipc-handlers/connection.js
index aa2c1378..78d6278b 100644
--- a/src/main/ipc-handlers/connection.js
+++ b/src/main/ipc-handlers/connection.js
@@ -15,6 +15,9 @@ export default connections => {
       if (conn.database)
          params.database = conn.database;
 
+      if (conn.databasePath)
+         params.databasePath = conn.databasePath;
+
       if (conn.ssl) {
          params.ssl = {
             key: conn.key ? fs.readFileSync(conn.key) : null,
@@ -68,6 +71,9 @@ export default connections => {
       if (conn.database)
          params.database = conn.database;
 
+      if (conn.databasePath)
+         params.databasePath = conn.databasePath;
+
       if (conn.schema)
          params.schema = conn.schema;
 
diff --git a/src/main/libs/ClientsFactory.js b/src/main/libs/ClientsFactory.js
index 54211908..6543eaff 100644
--- a/src/main/libs/ClientsFactory.js
+++ b/src/main/libs/ClientsFactory.js
@@ -1,6 +1,7 @@
 'use strict';
 import { MySQLClient } from './clients/MySQLClient';
 import { PostgreSQLClient } from './clients/PostgreSQLClient';
+import { SQLiteClient } from './clients/SQLiteClient';
 
 const queryLogger = sql => {
    // Remove comments, newlines and multiple spaces
@@ -37,6 +38,8 @@ export class ClientsFactory {
             return new MySQLClient(args);
          case 'pg':
             return new PostgreSQLClient(args);
+         case 'sqlite':
+            return new SQLiteClient(args);
          default:
             throw new Error(`Unknown database client: ${args.client}`);
       }
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
new file mode 100644
index 00000000..3b60d330
--- /dev/null
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -0,0 +1,1296 @@
+'use strict';
+import sqlite from 'better-sqlite3';
+import { AntaresCore } from '../AntaresCore';
+import dataTypes from 'common/data-types/mysql';
+
+export class SQLiteClient extends AntaresCore {
+   constructor (args) {
+      super(args);
+
+      this._schema = null;
+   }
+
+   _getTypeInfo (type) {
+      return dataTypes
+         .reduce((acc, group) => [...acc, ...group.types], [])
+         .filter(_type => _type.name === type.toUpperCase())[0];
+   }
+
+   /**
+    * @memberof SQLiteClient
+    */
+   async connect () {
+      this._connection = sqlite(this._params.databasePath, {
+         fileMustExist: true
+      });
+   }
+
+   /**
+    * @memberof SQLiteClient
+    */
+   destroy () {}
+
+   /**
+    * Executes an USE query
+    *
+    * @memberof SQLiteClient
+    */
+   use () {}
+
+   /**
+    * @param {Array} schemas list
+    * @returns {Array.<Object>} databases scructure
+    * @memberof SQLiteClient
+    */
+   async getStructure (schemas) {
+      const { rows: databases } = await this.raw('SELECT * FROM pragma_database_list');
+
+      const filteredDatabases = databases;
+
+      const tablesArr = [];
+      const triggersArr = [];
+      let schemaSize = 0;
+
+      for (const db of filteredDatabases) {
+         if (!schemas.has(db.name)) continue;
+
+         let { rows: tables } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';`);
+         if (tables.length) {
+            tables = tables.map(table => {
+               table.Db = db.name;
+               return table;
+            });
+            tablesArr.push(...tables);
+         }
+
+         let { rows: triggers } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='trigger' AND name NOT LIKE 'sqlite_%'`);
+         if (triggers.length) {
+            triggers = triggers.map(trigger => {
+               trigger.Db = db.name;
+               return trigger;
+            });
+            triggersArr.push(...triggers);
+         }
+      }
+
+      return filteredDatabases.map(db => {
+         if (schemas.has(db.name)) {
+            // TABLES
+            const remappedTables = tablesArr.filter(table => table.Db === db.name).map(table => {
+               let tableType;
+               switch (table.Comment) {
+                  case 'VIEW':
+                     tableType = 'view';
+                     break;
+                  default:
+                     tableType = 'table';
+                     break;
+               }
+
+               const tableSize = table.Data_length + table.Index_length;
+               schemaSize += tableSize;
+
+               return {
+                  name: table.name,
+                  type: table.type,
+                  rows: false,
+                  size: false
+               };
+            });
+
+            // TRIGGERS
+            const remappedTriggers = triggersArr.filter(trigger => trigger.Db === db.name).map(trigger => {
+               return {
+                  name: trigger.Trigger,
+                  statement: trigger.Statement,
+                  timing: trigger.Timing,
+                  definer: trigger.Definer,
+                  event: trigger.Event,
+                  table: trigger.Table,
+                  sqlMode: trigger.sql_mode,
+                  created: trigger.Created,
+                  charset: trigger.character_set_client
+               };
+            });
+
+            return {
+               name: db.name,
+               size: schemaSize,
+               tables: remappedTables,
+               functions: [],
+               procedures: [],
+               triggers: remappedTriggers,
+               schedulers: []
+            };
+         }
+         else {
+            return {
+               name: db.name,
+               size: 0,
+               tables: [],
+               functions: [],
+               procedures: [],
+               triggers: [],
+               schedulers: []
+            };
+         }
+      });
+   }
+
+   /**
+    * @param {Object} params
+    * @param {String} params.schema
+    * @param {String} params.table
+    * @returns {Object} table scructure
+    * @memberof SQLiteClient
+    */
+   async getTableColumns ({ schema, table }) {
+      const { rows } = await this
+         .select('*')
+         .schema('information_schema')
+         .from('COLUMNS')
+         .where({ TABLE_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'` })
+         .orderBy({ ORDINAL_POSITION: 'ASC' })
+         .run();
+
+      const { rows: fields } = await this.raw(`SHOW CREATE TABLE \`${schema}\`.\`${table}\``);
+
+      const remappedFields = fields.map(row => {
+         if (!row['Create Table']) return false;
+
+         let n = 0;
+         return row['Create Table']
+            .split('')
+            .reduce((acc, curr) => {
+               if (curr === ')') n--;
+               if (n !== 0) acc += curr;
+               if (curr === '(') n++;
+               return acc;
+            }, '')
+            .replaceAll('\n', '')
+            .split(',')
+            .map(f => {
+               try {
+                  const fieldArr = f.trim().split(' ');
+                  const nameAndType = fieldArr.slice(0, 2);
+                  if (nameAndType[0].charAt(0) !== '`') return false;
+
+                  const details = fieldArr.slice(2).join(' ');
+                  let defaultValue = null;
+                  if (details.includes('DEFAULT'))
+                     defaultValue = details.match(/(?<=DEFAULT ).*?$/gs)[0].split(' COMMENT')[0];
+                     // const defaultValueArr = defaultValue.split('');
+                     // if (defaultValueArr[0] === '\'') {
+                     //    defaultValueArr.shift();
+                     //    defaultValueArr.pop();
+                     //    defaultValue = defaultValueArr.join('');
+                     // }
+
+                  const typeAndLength = nameAndType[1].replace(')', '').split('(');
+
+                  return {
+                     name: nameAndType[0].replaceAll('`', ''),
+                     type: typeAndLength[0].toUpperCase(),
+                     length: typeAndLength[1] ? typeAndLength[1] : null,
+                     default: defaultValue
+                  };
+               }
+               catch (err) {
+                  return false;
+               }
+            })
+            .filter(Boolean)
+            .reduce((acc, curr) => {
+               acc[curr.name] = curr;
+               return acc;
+            }, {});
+      })[0];
+
+      return rows.map(field => {
+         let numLength = field.COLUMN_TYPE.match(/int\(([^)]+)\)/);
+         numLength = numLength ? +numLength.pop() : null;
+         const enumValues = /(enum|set)/.test(field.COLUMN_TYPE)
+            ? field.COLUMN_TYPE.match(/\(([^)]+)\)/)[0].slice(1, -1)
+            : null;
+
+         return {
+            name: field.COLUMN_NAME,
+            key: field.COLUMN_KEY.toLowerCase(),
+            type: remappedFields ? remappedFields[field.COLUMN_NAME].type : field.DATA_TYPE,
+            schema: field.TABLE_SCHEMA,
+            table: field.TABLE_NAME,
+            numPrecision: field.NUMERIC_PRECISION,
+            numLength,
+            enumValues,
+            datePrecision: field.DATETIME_PRECISION,
+            charLength: field.CHARACTER_MAXIMUM_LENGTH,
+            nullable: field.IS_NULLABLE.includes('YES'),
+            unsigned: field.COLUMN_TYPE.includes('unsigned'),
+            zerofill: field.COLUMN_TYPE.includes('zerofill'),
+            order: field.ORDINAL_POSITION,
+            default: remappedFields ? remappedFields[field.COLUMN_NAME].default : field.COLUMN_DEFAULT,
+            charset: field.CHARACTER_SET_NAME,
+            collation: field.COLLATION_NAME,
+            autoIncrement: field.EXTRA.includes('auto_increment'),
+            onUpdate: field.EXTRA.toLowerCase().includes('on update') ? field.EXTRA.replace('on update', '') : '',
+            comment: field.COLUMN_COMMENT
+         };
+      });
+   }
+
+   /**
+    * @param {Object} params
+    * @param {String} params.schema
+    * @param {String} params.table
+    * @returns {Object} table row count
+    * @memberof SQLiteClient
+    */
+   async getTableApproximateCount ({ schema, table }) {
+      const { rows } = await this.raw(`SELECT table_rows "count" FROM information_schema.tables WHERE table_name = "${table}" AND table_schema = "${schema}"`);
+
+      return rows.length ? rows[0].count : 0;
+   }
+
+   /**
+    * @param {Object} params
+    * @param {String} params.schema
+    * @param {String} params.table
+    * @returns {Object} table options
+    * @memberof SQLiteClient
+    */
+   async getTableOptions ({ schema, table }) {
+      const { rows } = await this.raw(`SHOW TABLE STATUS FROM \`${schema}\` WHERE Name = '${table}'`);
+
+      if (rows.length) {
+         let tableType;
+         switch (rows[0].Comment) {
+            case 'VIEW':
+               tableType = 'view';
+               break;
+            default:
+               tableType = 'table';
+               break;
+         }
+
+         return {
+            name: rows[0].Name,
+            type: tableType,
+            rows: rows[0].Rows,
+            created: rows[0].Create_time,
+            updated: rows[0].Update_time,
+            engine: rows[0].Engine,
+            comment: rows[0].Comment,
+            size: rows[0].Data_length + rows[0].Index_length,
+            autoIncrement: rows[0].Auto_increment,
+            collation: rows[0].Collation
+         };
+      };
+      return {};
+   }
+
+   /**
+    * @param {Object} params
+    * @param {String} params.schema
+    * @param {String} params.table
+    * @returns {Object} table indexes
+    * @memberof SQLiteClient
+    */
+   async getTableIndexes ({ schema, table }) {
+      const { rows } = await this.raw(`SHOW INDEXES FROM \`${table}\` FROM \`${schema}\``);
+
+      return rows.map(row => {
+         return {
+            unique: !row.Non_unique,
+            name: row.Key_name,
+            column: row.Column_name,
+            indexType: row.Index_type,
+            type: row.Key_name === 'PRIMARY' ? 'PRIMARY' : !row.Non_unique ? 'UNIQUE' : row.Index_type === 'FULLTEXT' ? 'FULLTEXT' : 'INDEX',
+            cardinality: row.Cardinality,
+            comment: row.Comment,
+            indexComment: row.Index_comment
+         };
+      });
+   }
+
+   /**
+    * @param {Object} params
+    * @param {String} params.schema
+    * @param {String} params.table
+    * @returns {Object} table key usage
+    * @memberof SQLiteClient
+    */
+   async getKeyUsage ({ schema, table }) {
+      const { rows } = await this
+         .select('*')
+         .schema('information_schema')
+         .from('KEY_COLUMN_USAGE')
+         .where({ TABLE_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'`, REFERENCED_TABLE_NAME: 'IS NOT NULL' })
+         .run();
+
+      const { rows: extras } = await this
+         .select('*')
+         .schema('information_schema')
+         .from('REFERENTIAL_CONSTRAINTS')
+         .where({ CONSTRAINT_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'`, REFERENCED_TABLE_NAME: 'IS NOT NULL' })
+         .run();
+
+      return rows.map(field => {
+         const extra = extras.find(x => x.CONSTRAINT_NAME === field.CONSTRAINT_NAME);
+         return {
+            schema: field.TABLE_SCHEMA,
+            table: field.TABLE_NAME,
+            field: field.COLUMN_NAME,
+            position: field.ORDINAL_POSITION,
+            constraintPosition: field.POSITION_IN_UNIQUE_CONSTRAINT,
+            constraintName: field.CONSTRAINT_NAME,
+            refSchema: field.REFERENCED_TABLE_SCHEMA,
+            refTable: field.REFERENCED_TABLE_NAME,
+            refField: field.REFERENCED_COLUMN_NAME,
+            onUpdate: extra.UPDATE_RULE,
+            onDelete: extra.DELETE_RULE
+         };
+      });
+   }
+
+   async getUsers () {}
+
+   /**
+    * CREATE DATABASE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createSchema (params) {
+      return await this.raw(`CREATE DATABASE \`${params.name}\` COLLATE ${params.collation}`);
+   }
+
+   /**
+    * ALTER DATABASE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterSchema (params) {
+      return await this.raw(`ALTER DATABASE \`${params.name}\` COLLATE ${params.collation}`);
+   }
+
+   /**
+    * DROP DATABASE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropSchema (params) {
+      return await this.raw(`DROP DATABASE \`${params.database}\``);
+   }
+
+   /**
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async getDatabaseCollation (params) {
+      return await this.raw(`SELECT \`DEFAULT_COLLATION_NAME\` FROM \`information_schema\`.\`SCHEMATA\` WHERE \`SCHEMA_NAME\`='${params.database}'`);
+   }
+
+   /**
+    * SHOW CREATE VIEW
+    *
+    * @returns {Array.<Object>} view informations
+    * @memberof SQLiteClient
+    */
+   async getViewInformations ({ schema, view }) {
+      const sql = `SHOW CREATE VIEW \`${schema}\`.\`${view}\``;
+      const results = await this.raw(sql);
+
+      return results.rows.map(row => {
+         return {
+            algorithm: row['Create View'].match(/(?<=CREATE ALGORITHM=).*?(?=\s)/gs)[0],
+            definer: row['Create View'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
+            security: row['Create View'].match(/(?<=SQL SECURITY ).*?(?=\s)/gs)[0],
+            updateOption: row['Create View'].match(/(?<=WITH ).*?(?=\s)/gs) ? row['Create View'].match(/(?<=WITH ).*?(?=\s)/gs)[0] : '',
+            sql: row['Create View'].match(/(?<=AS ).*?$/gs)[0],
+            name: row.View
+         };
+      })[0];
+   }
+
+   /**
+    * DROP VIEW
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropView (params) {
+      const sql = `DROP VIEW \`${params.schema}\`.\`${params.view}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER VIEW
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterView (params) {
+      const { view } = params;
+      let sql = `
+         USE \`${view.schema}\`; 
+         ALTER ALGORITHM = ${view.algorithm}${view.definer ? ` DEFINER=${view.definer}` : ''} 
+         SQL SECURITY ${view.security} 
+         VIEW \`${view.schema}\`.\`${view.oldName}\` AS ${view.sql} ${view.updateOption ? `WITH ${view.updateOption} CHECK OPTION` : ''}
+      `;
+
+      if (view.name !== view.oldName)
+         sql += `; RENAME TABLE \`${view.schema}\`.\`${view.oldName}\` TO \`${view.schema}\`.\`${view.name}\``;
+
+      return await this.raw(sql);
+   }
+
+   /**
+    * CREATE VIEW
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createView (params) {
+      const sql = `CREATE ALGORITHM = ${params.algorithm} ${params.definer ? `DEFINER=${params.definer} ` : ''}SQL SECURITY ${params.security} VIEW \`${params.schema}\`.\`${params.name}\` AS ${params.sql} ${params.updateOption ? `WITH ${params.updateOption} CHECK OPTION` : ''}`;
+      return await this.raw(sql);
+   }
+
+   /**
+    * SHOW CREATE TRIGGER
+    *
+    * @returns {Array.<Object>} view informations
+    * @memberof SQLiteClient
+    */
+   async getTriggerInformations ({ schema, trigger }) {
+      const sql = `SHOW CREATE TRIGGER \`${schema}\`.\`${trigger}\``;
+      const results = await this.raw(sql);
+
+      return results.rows.map(row => {
+         return {
+            definer: row['SQL Original Statement'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
+            sql: row['SQL Original Statement'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
+            name: row.Trigger,
+            table: row['SQL Original Statement'].match(/(?<=ON `).*?(?=`)/gs)[0],
+            activation: row['SQL Original Statement'].match(/(BEFORE|AFTER)/gs)[0],
+            event: row['SQL Original Statement'].match(/(INSERT|UPDATE|DELETE)/gs)[0]
+         };
+      })[0];
+   }
+
+   /**
+    * DROP TRIGGER
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropTrigger (params) {
+      const sql = `DROP TRIGGER \`${params.schema}\`.\`${params.trigger}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER TRIGGER
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterTrigger (params) {
+      const { trigger } = params;
+      const tempTrigger = Object.assign({}, trigger);
+      tempTrigger.name = `Antares_${tempTrigger.name}_tmp`;
+
+      try {
+         await this.createTrigger(tempTrigger);
+         await this.dropTrigger({ schema: trigger.schema, trigger: tempTrigger.name });
+         await this.dropTrigger({ schema: trigger.schema, trigger: trigger.oldName });
+         await this.createTrigger(trigger);
+      }
+      catch (err) {
+         return Promise.reject(err);
+      }
+   }
+
+   /**
+    * CREATE TRIGGER
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createTrigger (params) {
+      const sql = `CREATE ${params.definer ? `DEFINER=${params.definer} ` : ''}TRIGGER \`${params.schema}\`.\`${params.name}\` ${params.activation} ${params.event} ON \`${params.table}\` FOR EACH ROW ${params.sql}`;
+      return await this.raw(sql, { split: false });
+   }
+
+   /**
+    * SHOW CREATE PROCEDURE
+    *
+    * @returns {Array.<Object>} view informations
+    * @memberof SQLiteClient
+    */
+   async getRoutineInformations ({ schema, routine }) {
+      const sql = `SHOW CREATE PROCEDURE \`${schema}\`.\`${routine}\``;
+      const results = await this.raw(sql);
+
+      return results.rows.map(async row => {
+         if (!row['Create Procedure']) {
+            return {
+               definer: null,
+               sql: '',
+               parameters: [],
+               name: row.Procedure,
+               comment: '',
+               security: 'DEFINER',
+               deterministic: false,
+               dataAccess: 'CONTAINS SQL'
+            };
+         }
+
+         const sql = `SELECT * 
+               FROM information_schema.parameters 
+               WHERE SPECIFIC_NAME = '${routine}'
+               AND SPECIFIC_SCHEMA = '${schema}'
+               ORDER BY ORDINAL_POSITION
+            `;
+
+         const results = await this.raw(sql);
+
+         const parameters = results.rows.map(row => {
+            return {
+               name: row.PARAMETER_NAME,
+               type: row.DATA_TYPE.toUpperCase(),
+               length: row.NUMERIC_PRECISION || row.DATETIME_PRECISION || row.CHARACTER_MAXIMUM_LENGTH || '',
+               context: row.PARAMETER_MODE
+            };
+         });
+
+         let dataAccess = 'CONTAINS SQL';
+         if (row['Create Procedure'].includes('NO SQL'))
+            dataAccess = 'NO SQL';
+         if (row['Create Procedure'].includes('READS SQL DATA'))
+            dataAccess = 'READS SQL DATA';
+         if (row['Create Procedure'].includes('MODIFIES SQL DATA'))
+            dataAccess = 'MODIFIES SQL DATA';
+
+         return {
+            definer: row['Create Procedure'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
+            sql: row['Create Procedure'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
+            parameters: parameters || [],
+            name: row.Procedure,
+            comment: row['Create Procedure'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Procedure'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
+            security: row['Create Procedure'].includes('SQL SECURITY INVOKER') ? 'INVOKER' : 'DEFINER',
+            deterministic: row['Create Procedure'].includes('DETERMINISTIC'),
+            dataAccess
+         };
+      })[0];
+   }
+
+   /**
+    * DROP PROCEDURE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropRoutine (params) {
+      const sql = `DROP PROCEDURE \`${params.schema}\`.\`${params.routine}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER PROCEDURE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterRoutine (params) {
+      const { routine } = params;
+      const tempProcedure = Object.assign({}, routine);
+      tempProcedure.name = `Antares_${tempProcedure.name}_tmp`;
+
+      try {
+         await this.createRoutine(tempProcedure);
+         await this.dropRoutine({ schema: routine.schema, routine: tempProcedure.name });
+         await this.dropRoutine({ schema: routine.schema, routine: routine.oldName });
+         await this.createRoutine(routine);
+      }
+      catch (err) {
+         return Promise.reject(err);
+      }
+   }
+
+   /**
+    * CREATE PROCEDURE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createRoutine (params) {
+      const parameters = 'parameters' in params
+         ? params.parameters.reduce((acc, curr) => {
+            acc.push(`${curr.context} \`${curr.name}\` ${curr.type}${curr.length ? `(${curr.length})` : ''}`);
+            return acc;
+         }, []).join(',')
+         : '';
+
+      const sql = `CREATE ${params.definer ? `DEFINER=${params.definer} ` : ''}PROCEDURE \`${params.schema}\`.\`${params.name}\`(${parameters})
+         LANGUAGE SQL
+         ${params.deterministic ? 'DETERMINISTIC' : 'NOT DETERMINISTIC'}
+         ${params.dataAccess}
+         SQL SECURITY ${params.security}
+         COMMENT '${params.comment}'
+         ${params.sql}`;
+
+      return await this.raw(sql, { split: false });
+   }
+
+   /**
+    * SHOW CREATE FUNCTION
+    *
+    * @returns {Array.<Object>} view informations
+    * @memberof SQLiteClient
+    */
+   async getFunctionInformations ({ schema, func }) {
+      const sql = `SHOW CREATE FUNCTION \`${schema}\`.\`${func}\``;
+      const results = await this.raw(sql);
+
+      return results.rows.map(async row => {
+         if (!row['Create Function']) {
+            return {
+               definer: null,
+               sql: '',
+               parameters: [],
+               name: row.Procedure,
+               comment: '',
+               security: 'DEFINER',
+               deterministic: false,
+               dataAccess: 'CONTAINS SQL',
+               returns: 'INT',
+               returnsLength: null
+            };
+         }
+
+         const sql = `SELECT * 
+            FROM information_schema.parameters 
+            WHERE SPECIFIC_NAME = '${func}'
+            AND SPECIFIC_SCHEMA = '${schema}'
+            ORDER BY ORDINAL_POSITION
+         `;
+
+         const results = await this.raw(sql);
+
+         const parameters = results.rows.filter(row => row.PARAMETER_MODE).map(row => {
+            return {
+               name: row.PARAMETER_NAME,
+               type: row.DATA_TYPE.toUpperCase(),
+               length: row.NUMERIC_PRECISION || row.DATETIME_PRECISION || row.CHARACTER_MAXIMUM_LENGTH || '',
+               context: row.PARAMETER_MODE
+            };
+         });
+
+         let dataAccess = 'CONTAINS SQL';
+         if (row['Create Function'].includes('NO SQL'))
+            dataAccess = 'NO SQL';
+         if (row['Create Function'].includes('READS SQL DATA'))
+            dataAccess = 'READS SQL DATA';
+         if (row['Create Function'].includes('MODIFIES SQL DATA'))
+            dataAccess = 'MODIFIES SQL DATA';
+
+         const output = row['Create Function'].match(/(?<=RETURNS ).*?(?=\s)/gs).length ? row['Create Function'].match(/(?<=RETURNS ).*?(?=\s)/gs)[0].replace(')', '').split('(') : ['', null];
+
+         return {
+            definer: row['Create Function'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
+            sql: row['Create Function'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
+            parameters: parameters || [],
+            name: row.Function,
+            comment: row['Create Function'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Function'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
+            security: row['Create Function'].includes('SQL SECURITY INVOKER') ? 'INVOKER' : 'DEFINER',
+            deterministic: row['Create Function'].includes('DETERMINISTIC'),
+            dataAccess,
+            returns: output[0].toUpperCase(),
+            returnsLength: +output[1]
+         };
+      })[0];
+   }
+
+   /**
+    * DROP FUNCTION
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropFunction (params) {
+      const sql = `DROP FUNCTION \`${params.schema}\`.\`${params.func}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER FUNCTION
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterFunction (params) {
+      const { func } = params;
+      const tempProcedure = Object.assign({}, func);
+      tempProcedure.name = `Antares_${tempProcedure.name}_tmp`;
+
+      try {
+         await this.createFunction(tempProcedure);
+         await this.dropFunction({ schema: func.schema, func: tempProcedure.name });
+         await this.dropFunction({ schema: func.schema, func: func.oldName });
+         await this.createFunction(func);
+      }
+      catch (err) {
+         return Promise.reject(err);
+      }
+   }
+
+   /**
+    * CREATE FUNCTION
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createFunction (params) {
+      const parameters = 'parameters' in params
+         ? params.parameters.reduce((acc, curr) => {
+            acc.push(`\`${curr.name}\` ${curr.type}${curr.length ? `(${curr.length})` : ''}`);
+            return acc;
+         }, []).join(',')
+         : '';
+
+      const body = params.returns ? params.sql : 'BEGIN\n  RETURN 0;\nEND';
+
+      const sql = `CREATE ${params.definer ? `DEFINER=${params.definer} ` : ''}FUNCTION \`${params.schema}\`.\`${params.name}\`(${parameters}) RETURNS ${params.returns || 'SMALLINT'}${params.returnsLength ? `(${params.returnsLength})` : ''}
+         LANGUAGE SQL
+         ${params.deterministic ? 'DETERMINISTIC' : 'NOT DETERMINISTIC'}
+         ${params.dataAccess}
+         SQL SECURITY ${params.security}
+         COMMENT '${params.comment}'
+         ${body}`;
+
+      return await this.raw(sql, { split: false });
+   }
+
+   /**
+    * SHOW CREATE EVENT
+    *
+    * @returns {Array.<Object>} view informations
+    * @memberof SQLiteClient
+    */
+   async getEventInformations ({ schema, scheduler }) {
+      const sql = `SHOW CREATE EVENT \`${schema}\`.\`${scheduler}\``;
+      const results = await this.raw(sql);
+
+      return results.rows.map(row => {
+         const schedule = row['Create Event'];
+         const execution = schedule.includes('EVERY') ? 'EVERY' : 'ONCE';
+         const every = execution === 'EVERY' ? row['Create Event'].match(/(?<=EVERY )(\s*([^\s]+)){0,2}/gs)[0].replaceAll('\'', '').split(' ') : [];
+         const starts = execution === 'EVERY' && schedule.includes('STARTS') ? schedule.match(/(?<=STARTS ').*?(?='\s)/gs)[0] : '';
+         const ends = execution === 'EVERY' && schedule.includes('ENDS') ? schedule.match(/(?<=ENDS ').*?(?='\s)/gs)[0] : '';
+         const at = execution === 'ONCE' && schedule.includes('AT') ? schedule.match(/(?<=AT ').*?(?='\s)/gs)[0] : '';
+
+         return {
+            definer: row['Create Event'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
+            sql: row['Create Event'].match(/(?<=DO )(.*)/gs)[0],
+            name: row.Event,
+            comment: row['Create Event'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Event'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
+            state: row['Create Event'].includes('ENABLE') ? 'ENABLE' : row['Create Event'].includes('DISABLE ON SLAVE') ? 'DISABLE ON SLAVE' : 'DISABLE',
+            preserve: row['Create Event'].includes('ON COMPLETION PRESERVE'),
+            execution,
+            every,
+            starts,
+            ends,
+            at
+         };
+      })[0];
+   }
+
+   /**
+    * DROP EVENT
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropEvent (params) {
+      const sql = `DROP EVENT \`${params.schema}\`.\`${params.scheduler}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER EVENT
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterEvent (params) {
+      const { scheduler } = params;
+
+      if (scheduler.execution === 'EVERY' && scheduler.every[0].includes('-'))
+         scheduler.every[0] = `'${scheduler.every[0]}'`;
+
+      const sql = `ALTER ${scheduler.definer ? ` DEFINER=${scheduler.definer}` : ''} EVENT \`${scheduler.schema}\`.\`${scheduler.oldName}\` 
+      ON SCHEDULE
+         ${scheduler.execution === 'EVERY'
+      ? `EVERY ${scheduler.every.join(' ')}${scheduler.starts ? ` STARTS '${scheduler.starts}'` : ''}${scheduler.ends ? ` ENDS '${scheduler.ends}'` : ''}`
+      : `AT '${scheduler.at}'`}
+      ON COMPLETION${!scheduler.preserve ? ' NOT' : ''} PRESERVE
+      ${scheduler.name !== scheduler.oldName ? `RENAME TO \`${scheduler.schema}\`.\`${scheduler.name}\`` : ''}
+      ${scheduler.state}
+      COMMENT '${scheduler.comment}'
+      DO ${scheduler.sql}`;
+
+      return await this.raw(sql, { split: false });
+   }
+
+   /**
+    * CREATE EVENT
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createEvent (params) {
+      const sql = `CREATE ${params.definer ? ` DEFINER=${params.definer}` : ''} EVENT \`${params.schema}\`.\`${params.name}\` 
+      ON SCHEDULE
+         ${params.execution === 'EVERY'
+      ? `EVERY ${params.every.join(' ')}${params.starts ? ` STARTS '${params.starts}'` : ''}${params.ends ? ` ENDS '${params.ends}'` : ''}`
+      : `AT '${params.at}'`}
+      ON COMPLETION${!params.preserve ? ' NOT' : ''} PRESERVE
+      ${params.state}
+      COMMENT '${params.comment}'
+      DO ${params.sql}`;
+
+      return await this.raw(sql, { split: false });
+   }
+
+   async enableEvent ({ schema, scheduler }) {
+      const sql = `ALTER EVENT \`${schema}\`.\`${scheduler}\` ENABLE`;
+      return await this.raw(sql, { split: false });
+   }
+
+   async disableEvent ({ schema, scheduler }) {
+      const sql = `ALTER EVENT \`${schema}\`.\`${scheduler}\` DISABLE`;
+      return await this.raw(sql, { split: false });
+   }
+
+   /**
+    * SHOW COLLATION
+    *
+    * @returns {Array.<Object>} collations list
+    * @memberof SQLiteClient
+    */
+   async getCollations () {
+      return [];
+   }
+
+   /**
+    * SHOW VARIABLES
+    *
+    * @returns {Array.<Object>} variables list
+    * @memberof SQLiteClient
+    */
+   async getVariables () {
+      return [];
+   }
+
+   /**
+    * SHOW ENGINES
+    *
+    * @returns {Array.<Object>} engines list
+    * @memberof SQLiteClient
+    */
+   async getEngines () {
+      return {
+         name: 'SQLite',
+         support: 'YES',
+         comment: '',
+         isDefault: true
+      };
+   }
+
+   /**
+    * SHOW VARIABLES LIKE '%vers%'
+    *
+    * @returns {Array.<Object>} version parameters
+    * @memberof SQLiteClient
+    */
+   async getVersion () {
+      const os = require('os');
+      const sql = 'SELECT sqlite_version() AS version';
+      const { rows } = await this.raw(sql);
+
+      return {
+         number: rows[0].version,
+         name: 'SQLite',
+         arch: process.arch,
+         os: `${os.type()} ${os.release()}`
+      };
+   }
+
+   async getProcesses () {}
+
+   async killProcess () {}
+
+   /**
+    * CREATE TABLE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async createTable (params) {
+      const {
+         schema,
+         fields,
+         foreigns,
+         indexes,
+         options
+      } = params;
+      const newColumns = [];
+      const newIndexes = [];
+      const newForeigns = [];
+
+      let sql = `CREATE TABLE \`${schema}\`.\`${options.name}\``;
+
+      // ADD FIELDS
+      fields.forEach(field => {
+         const typeInfo = this._getTypeInfo(field.type);
+         const length = typeInfo.length ? field.enumValues || field.numLength || field.charLength || field.datePrecision : false;
+
+         newColumns.push(`\`${field.name}\` 
+            ${field.type.toUpperCase()}${length ? `(${length})` : ''} 
+            ${field.unsigned ? 'UNSIGNED' : ''} 
+            ${field.zerofill ? 'ZEROFILL' : ''}
+            ${field.nullable ? 'NULL' : 'NOT NULL'}
+            ${field.autoIncrement ? 'AUTO_INCREMENT' : ''}
+            ${field.default ? `DEFAULT ${field.default}` : ''}
+            ${field.comment ? `COMMENT '${field.comment}'` : ''}
+            ${field.collation ? `COLLATE ${field.collation}` : ''}
+            ${field.onUpdate ? `ON UPDATE ${field.onUpdate}` : ''}`);
+      });
+
+      // ADD INDEX
+      indexes.forEach(index => {
+         const fields = index.fields.map(field => `\`${field}\``).join(',');
+         let type = index.type;
+
+         if (type === 'PRIMARY')
+            newIndexes.push(`PRIMARY KEY (${fields})`);
+         else {
+            if (type === 'UNIQUE')
+               type = 'UNIQUE INDEX';
+
+            newIndexes.push(`${type} \`${index.name}\` (${fields})`);
+         }
+      });
+
+      // ADD FOREIGN KEYS
+      foreigns.forEach(foreign => {
+         newForeigns.push(`CONSTRAINT \`${foreign.constraintName}\` FOREIGN KEY (\`${foreign.field}\`) REFERENCES \`${foreign.refTable}\` (\`${foreign.refField}\`) ON UPDATE ${foreign.onUpdate} ON DELETE ${foreign.onDelete}`);
+      });
+
+      sql = `${sql} (${[...newColumns, ...newIndexes, ...newForeigns].join(', ')}) COMMENT='${options.comment}', COLLATE='${options.collation}', ENGINE=${options.engine}`;
+
+      return await this.raw(sql);
+   }
+
+   /**
+    * ALTER TABLE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async alterTable (params) {
+      const {
+         table,
+         schema,
+         additions,
+         deletions,
+         changes,
+         indexChanges,
+         foreignChanges,
+         options
+      } = params;
+
+      let sql = `ALTER TABLE \`${schema}\`.\`${table}\` `;
+      const alterColumns = [];
+
+      // OPTIONS
+      if ('comment' in options) alterColumns.push(`COMMENT='${options.comment}'`);
+      if ('engine' in options) alterColumns.push(`ENGINE=${options.engine}`);
+      if ('autoIncrement' in options) alterColumns.push(`AUTO_INCREMENT=${+options.autoIncrement}`);
+      if ('collation' in options) alterColumns.push(`COLLATE='${options.collation}'`);
+
+      // ADD FIELDS
+      additions.forEach(addition => {
+         const typeInfo = this._getTypeInfo(addition.type);
+         const length = typeInfo.length ? addition.enumValues || addition.numLength || addition.charLength || addition.datePrecision : false;
+
+         alterColumns.push(`ADD COLUMN \`${addition.name}\` 
+            ${addition.type.toUpperCase()}${length ? `(${length})` : ''} 
+            ${addition.unsigned ? 'UNSIGNED' : ''} 
+            ${addition.zerofill ? 'ZEROFILL' : ''}
+            ${addition.nullable ? 'NULL' : 'NOT NULL'}
+            ${addition.autoIncrement ? 'AUTO_INCREMENT' : ''}
+            ${addition.default ? `DEFAULT ${addition.default}` : ''}
+            ${addition.comment ? `COMMENT '${addition.comment}'` : ''}
+            ${addition.collation ? `COLLATE ${addition.collation}` : ''}
+            ${addition.onUpdate ? `ON UPDATE ${addition.onUpdate}` : ''}
+            ${addition.after ? `AFTER \`${addition.after}\`` : 'FIRST'}`);
+      });
+
+      // ADD INDEX
+      indexChanges.additions.forEach(addition => {
+         const fields = addition.fields.map(field => `\`${field}\``).join(',');
+         let type = addition.type;
+
+         if (type === 'PRIMARY')
+            alterColumns.push(`ADD PRIMARY KEY (${fields})`);
+         else {
+            if (type === 'UNIQUE')
+               type = 'UNIQUE INDEX';
+
+            alterColumns.push(`ADD ${type} \`${addition.name}\` (${fields})`);
+         }
+      });
+
+      // ADD FOREIGN KEYS
+      foreignChanges.additions.forEach(addition => {
+         alterColumns.push(`ADD CONSTRAINT \`${addition.constraintName}\` FOREIGN KEY (\`${addition.field}\`) REFERENCES \`${addition.refTable}\` (\`${addition.refField}\`) ON UPDATE ${addition.onUpdate} ON DELETE ${addition.onDelete}`);
+      });
+
+      // CHANGE FIELDS
+      changes.forEach(change => {
+         const typeInfo = this._getTypeInfo(change.type);
+         const length = typeInfo.length ? change.enumValues || change.numLength || change.charLength || change.datePrecision : false;
+
+         alterColumns.push(`CHANGE COLUMN \`${change.orgName}\` \`${change.name}\` 
+            ${change.type.toUpperCase()}${length ? `(${length})` : ''} 
+            ${change.unsigned ? 'UNSIGNED' : ''} 
+            ${change.zerofill ? 'ZEROFILL' : ''}
+            ${change.nullable ? 'NULL' : 'NOT NULL'}
+            ${change.autoIncrement ? 'AUTO_INCREMENT' : ''}
+            ${change.default ? `DEFAULT ${change.default}` : ''}
+            ${change.comment ? `COMMENT '${change.comment}'` : ''}
+            ${change.collation ? `COLLATE ${change.collation}` : ''}
+            ${change.onUpdate ? `ON UPDATE ${change.onUpdate}` : ''}
+            ${change.after ? `AFTER \`${change.after}\`` : 'FIRST'}`);
+      });
+
+      // CHANGE INDEX
+      indexChanges.changes.forEach(change => {
+         if (change.oldType === 'PRIMARY')
+            alterColumns.push('DROP PRIMARY KEY');
+         else
+            alterColumns.push(`DROP INDEX \`${change.oldName}\``);
+
+         const fields = change.fields.map(field => `\`${field}\``).join(',');
+         let type = change.type;
+
+         if (type === 'PRIMARY')
+            alterColumns.push(`ADD PRIMARY KEY (${fields})`);
+         else {
+            if (type === 'UNIQUE')
+               type = 'UNIQUE INDEX';
+
+            alterColumns.push(`ADD ${type} \`${change.name}\` (${fields})`);
+         }
+      });
+
+      // CHANGE FOREIGN KEYS
+      foreignChanges.changes.forEach(change => {
+         alterColumns.push(`DROP FOREIGN KEY \`${change.oldName}\``);
+         alterColumns.push(`ADD CONSTRAINT \`${change.constraintName}\` FOREIGN KEY (\`${change.field}\`) REFERENCES \`${change.refTable}\` (\`${change.refField}\`) ON UPDATE ${change.onUpdate} ON DELETE ${change.onDelete}`);
+      });
+
+      // DROP FIELDS
+      deletions.forEach(deletion => {
+         alterColumns.push(`DROP COLUMN \`${deletion.name}\``);
+      });
+
+      // DROP INDEX
+      indexChanges.deletions.forEach(deletion => {
+         if (deletion.type === 'PRIMARY')
+            alterColumns.push('DROP PRIMARY KEY');
+         else
+            alterColumns.push(`DROP INDEX \`${deletion.name}\``);
+      });
+
+      // DROP FOREIGN KEYS
+      foreignChanges.deletions.forEach(deletion => {
+         alterColumns.push(`DROP FOREIGN KEY \`${deletion.constraintName}\``);
+      });
+
+      sql += alterColumns.join(', ');
+
+      // RENAME
+      if (options.name) sql += `; RENAME TABLE \`${schema}\`.\`${table}\` TO \`${schema}\`.\`${options.name}\``;
+
+      return await this.raw(sql);
+   }
+
+   /**
+    * DUPLICATE TABLE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async duplicateTable (params) {
+      const sql = `CREATE TABLE \`${params.schema}\`.\`${params.table}_copy\` LIKE \`${params.schema}\`.\`${params.table}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * TRUNCATE TABLE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async truncateTable (params) {
+      const sql = `TRUNCATE TABLE \`${params.schema}\`.\`${params.table}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * DROP TABLE
+    *
+    * @returns {Array.<Object>} parameters
+    * @memberof SQLiteClient
+    */
+   async dropTable (params) {
+      const sql = `DROP TABLE \`${params.schema}\`.\`${params.table}\``;
+      return await this.raw(sql);
+   }
+
+   /**
+    * @returns {String} SQL string
+    * @memberof SQLiteClient
+    */
+   getSQL () {
+      // SELECT
+      const selectArray = this._query.select.reduce(this._reducer, []);
+      let selectRaw = '';
+
+      if (selectArray.length)
+         selectRaw = selectArray.length ? `SELECT ${selectArray.join(', ')} ` : 'SELECT * ';
+
+      // FROM
+      let fromRaw = '';
+
+      if (!this._query.update.length && !Object.keys(this._query.insert).length && !!this._query.from)
+         fromRaw = 'FROM';
+      else if (Object.keys(this._query.insert).length)
+         fromRaw = 'INTO';
+
+      fromRaw += this._query.from ? ` ${this._query.schema ? `\`${this._query.schema}\`.` : ''}\`${this._query.from}\` ` : '';
+
+      // WHERE
+      const whereArray = this._query.where.reduce(this._reducer, []);
+      const whereRaw = whereArray.length ? `WHERE ${whereArray.join(' AND ')} ` : '';
+
+      // UPDATE
+      const updateArray = this._query.update.reduce(this._reducer, []);
+      const updateRaw = updateArray.length ? `SET ${updateArray.join(', ')} ` : '';
+
+      // INSERT
+      let insertRaw = '';
+
+      if (this._query.insert.length) {
+         const fieldsList = Object.keys(this._query.insert[0]);
+         const rowsList = this._query.insert.map(el => `(${Object.values(el).join(', ')})`);
+
+         insertRaw = `(${fieldsList.join(', ')}) VALUES ${rowsList.join(', ')} `;
+      }
+
+      // GROUP BY
+      const groupByArray = this._query.groupBy.reduce(this._reducer, []);
+      const groupByRaw = groupByArray.length ? `GROUP BY ${groupByArray.join(', ')} ` : '';
+
+      // ORDER BY
+      const orderByArray = this._query.orderBy.reduce(this._reducer, []);
+      const orderByRaw = orderByArray.length ? `ORDER BY ${orderByArray.join(', ')} ` : '';
+
+      // LIMIT
+      const limitRaw = this._query.limit.length ? `LIMIT ${this._query.limit.join(', ')} ` : '';
+
+      // OFFSET
+      const offsetRaw = this._query.offset.length ? `OFFSET ${this._query.offset.join(', ')} ` : '';
+
+      return `${selectRaw}${updateRaw ? 'UPDATE' : ''}${insertRaw ? 'INSERT ' : ''}${this._query.delete ? 'DELETE ' : ''}${fromRaw}${updateRaw}${whereRaw}${groupByRaw}${orderByRaw}${limitRaw}${offsetRaw}${insertRaw}`;
+   }
+
+   /**
+    * @param {string} sql raw SQL query
+    * @param {object} args
+    * @param {boolean} args.nest
+    * @param {boolean} args.details
+    * @param {boolean} args.split
+    * @returns {Promise}
+    * @memberof SQLiteClient
+    */
+   async raw (sql, args) {
+      if (process.env.NODE_ENV === 'development') this._logger(sql);// TODO: replace BLOB content with a placeholder
+
+      args = {
+         nest: false,
+         details: false,
+         split: true,
+         comments: true,
+         ...args
+      };
+
+      if (!args.comments)
+         sql = sql.replace(/(\/\*(.|[\r\n])*?\*\/)|(--(.*|[\r\n]))/gm, '');// Remove comments
+
+      const resultsArr = [];
+      // let paramsArr = [];
+      const queries = args.split
+         ? sql.split(/((?:[^;'"]*(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*')[^;'"]*)+)|;/gm)
+            .filter(Boolean)
+            .map(q => q.trim())
+         : [sql];
+      const connection = this._connection;
+
+      for (const query of queries) {
+         if (!query) continue;
+         const timeStart = new Date();
+         let timeStop;
+         const keysArr = [];
+
+         const { rows, report, fields, keys, duration } = await new Promise((resolve, reject) => {
+            const stmt = connection.prepare(query);
+            const queryResult = stmt.all();
+            const fields = stmt.columns();
+
+            const remappedFields = fields
+               ? fields.map(field => {
+                  return {
+                     name: field.name,
+                     alias: field.name,
+                     orgName: field.column,
+                     schema: field.database,
+                     table: field.table,
+                     tableAlias: field.table,
+                     orgTable: field.table,
+                     type: field.type
+                  };
+               }).filter(Boolean)
+               : [];
+
+            timeStop = new Date();
+
+            resolve({
+               duration: timeStop - timeStart,
+               rows: Array.isArray(queryResult) ? queryResult.some(el => Array.isArray(el)) ? [] : queryResult : false,
+               report: !Array.isArray(queryResult) ? queryResult : false,
+               fields: remappedFields,
+               keys: keysArr
+            });
+         });
+
+         resultsArr.push({ rows, report, fields, keys, duration });
+      }
+
+      return resultsArr.length === 1 ? resultsArr[0] : resultsArr;
+   }
+}

From 94c899eb8288b41a5962ac3d24365227e1f9f485 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Mon, 15 Nov 2021 18:09:34 +0100
Subject: [PATCH 03/10] perf(SQLite): improvements in data visualization

---
 src/common/customizations/defaults.js         |  5 +-
 src/common/customizations/sqlite.js           |  3 +-
 src/main/libs/clients/SQLiteClient.js         | 47 +++++++++++--------
 .../components/WorkspaceExploreBarSchema.vue  |  2 +-
 src/renderer/components/WorkspaceTabQuery.vue | 17 ++++---
 src/renderer/components/WorkspaceTabTable.vue | 10 +++-
 src/renderer/scss/_data-types.scss            |  3 ++
 .../store/modules/workspaces.store.js         |  5 ++
 8 files changed, 62 insertions(+), 30 deletions(-)

diff --git a/src/common/customizations/defaults.js b/src/common/customizations/defaults.js
index 70b5295a..70c5ad67 100644
--- a/src/common/customizations/defaults.js
+++ b/src/common/customizations/defaults.js
@@ -37,6 +37,9 @@ module.exports = {
    databaseEdit: false,
    schemaEdit: false,
    tableSettings: false,
+   tableOptions: false,
+   tableArray: false,
+   tableRealCount: false,
    viewSettings: false,
    triggerSettings: false,
    triggerFunctionSettings: false,
@@ -49,13 +52,11 @@ module.exports = {
    unsigned: false,
    nullable: false,
    zerofill: false,
-   tableOptions: false,
    autoIncrement: false,
    comment: false,
    collation: false,
    definer: false,
    onUpdate: false,
-   tableArray: false,
    viewAlgorithm: false,
    viewSqlSecurity: false,
    viewUpdateOption: false,
diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
index 96e2a56f..ca736ad8 100644
--- a/src/common/customizations/sqlite.js
+++ b/src/common/customizations/sqlite.js
@@ -35,6 +35,8 @@ module.exports = {
    databaseEdit: false,
    schemaEdit: false,
    tableSettings: false,
+   tableArray: false,
+   tableRealCount: true,
    viewSettings: false,
    triggerSettings: false,
    triggerFunctionSettings: false,
@@ -53,7 +55,6 @@ module.exports = {
    collation: false,
    definer: false,
    onUpdate: false,
-   tableArray: false,
    viewAlgorithm: false,
    viewSqlSecurity: false,
    viewUpdateOption: false,
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 3b60d330..15209474 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -54,7 +54,7 @@ export class SQLiteClient extends AntaresCore {
       for (const db of filteredDatabases) {
          if (!schemas.has(db.name)) continue;
 
-         let { rows: tables } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';`);
+         let { rows: tables } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
          if (tables.length) {
             tables = tables.map(table => {
                table.Db = db.name;
@@ -77,17 +77,7 @@ export class SQLiteClient extends AntaresCore {
          if (schemas.has(db.name)) {
             // TABLES
             const remappedTables = tablesArr.filter(table => table.Db === db.name).map(table => {
-               let tableType;
-               switch (table.Comment) {
-                  case 'VIEW':
-                     tableType = 'view';
-                     break;
-                  default:
-                     tableType = 'table';
-                     break;
-               }
-
-               const tableSize = table.Data_length + table.Index_length;
+               const tableSize = 0;
                schemaSize += tableSize;
 
                return {
@@ -246,7 +236,7 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getTableApproximateCount ({ schema, table }) {
-      const { rows } = await this.raw(`SELECT table_rows "count" FROM information_schema.tables WHERE table_name = "${table}" AND table_schema = "${schema}"`);
+      const { rows } = await this.raw(`SELECT COUNT(*) AS count FROM "${schema}"."${table}"`);
 
       return rows.length ? rows[0].count : 0;
    }
@@ -1182,10 +1172,12 @@ export class SQLiteClient extends AntaresCore {
       else if (Object.keys(this._query.insert).length)
          fromRaw = 'INTO';
 
-      fromRaw += this._query.from ? ` ${this._query.schema ? `\`${this._query.schema}\`.` : ''}\`${this._query.from}\` ` : '';
+      fromRaw += this._query.from ? ` ${this._query.schema ? `"${this._query.schema}".` : ''}"${this._query.from}" ` : '';
 
       // WHERE
-      const whereArray = this._query.where.reduce(this._reducer, []);
+      const whereArray = this._query.where
+         .reduce(this._reducer, [])
+         ?.map(clausole => clausole.replace('= null', 'IS NULL'));
       const whereRaw = whereArray.length ? `WHERE ${whereArray.join(' AND ')} ` : '';
 
       // UPDATE
@@ -1258,9 +1250,26 @@ export class SQLiteClient extends AntaresCore {
          const keysArr = [];
 
          const { rows, report, fields, keys, duration } = await new Promise((resolve, reject) => {
+            let queryResult;
+            let affectedRows;
+            let fields;
+            const detectedTypes = {};
+
             const stmt = connection.prepare(query);
-            const queryResult = stmt.all();
-            const fields = stmt.columns();
+            if (stmt.reader) {
+               queryResult = stmt.all();
+               fields = stmt.columns();
+
+               if (queryResult.length) {
+                  fields.forEach(field => {
+                     detectedTypes[field.name] = typeof queryResult[0][field.name];
+                  });
+               }
+            }
+            else {
+               const info = queryResult = stmt.run();
+               affectedRows = info.changes;
+            }
 
             const remappedFields = fields
                ? fields.map(field => {
@@ -1272,7 +1281,7 @@ export class SQLiteClient extends AntaresCore {
                      table: field.table,
                      tableAlias: field.table,
                      orgTable: field.table,
-                     type: field.type
+                     type: field.type !== null ? field.type : detectedTypes[field.name]
                   };
                }).filter(Boolean)
                : [];
@@ -1282,7 +1291,7 @@ export class SQLiteClient extends AntaresCore {
             resolve({
                duration: timeStop - timeStart,
                rows: Array.isArray(queryResult) ? queryResult.some(el => Array.isArray(el)) ? [] : queryResult : false,
-               report: !Array.isArray(queryResult) ? queryResult : false,
+               report: affectedRows !== undefined ? { affectedRows } : null,
                fields: remappedFields,
                keys: keysArr
             });
diff --git a/src/renderer/components/WorkspaceExploreBarSchema.vue b/src/renderer/components/WorkspaceExploreBarSchema.vue
index 7d3c79fa..b744c45b 100644
--- a/src/renderer/components/WorkspaceExploreBarSchema.vue
+++ b/src/renderer/components/WorkspaceExploreBarSchema.vue
@@ -43,7 +43,7 @@
                      <span v-html="highlightWord(table.name)" />
                   </a>
                   <div
-                     v-if="table.type === 'table'"
+                     v-if="table.type === 'table' && table.size !== false"
                      class="table-size  tooltip tooltip-left mr-1"
                      :data-tooltip="formatBytes(table.size)"
                   >
diff --git a/src/renderer/components/WorkspaceTabQuery.vue b/src/renderer/components/WorkspaceTabQuery.vue
index bbb72cc8..aa93f5e2 100644
--- a/src/renderer/components/WorkspaceTabQuery.vue
+++ b/src/renderer/components/WorkspaceTabQuery.vue
@@ -93,7 +93,7 @@
                <div v-if="resultsCount">
                   {{ $t('word.results') }}: <b>{{ resultsCount.toLocaleString() }}</b>
                </div>
-               <div v-if="affectedCount">
+               <div v-if="affectedCount !== null">
                   {{ $t('message.affectedRows') }}: <b>{{ affectedCount }}</b>
                </div>
                <div class="input-group" :title="$t('word.schema')">
@@ -170,7 +170,7 @@ export default {
          selectedSchema: null,
          resultsCount: 0,
          durationsCount: 0,
-         affectedCount: 0,
+         affectedCount: null,
          editorHeight: 200,
          isHistoryOpen: false
       };
@@ -255,9 +255,14 @@ export default {
 
             if (status === 'success') {
                this.results = Array.isArray(response) ? response : [response];
-               this.resultsCount += this.results.reduce((acc, curr) => acc + (curr.rows ? curr.rows.length : 0), 0);
-               this.durationsCount += this.results.reduce((acc, curr) => acc + curr.duration, 0);
-               this.affectedCount += this.results.reduce((acc, curr) => acc + (curr.report ? curr.report.affectedRows : 0), 0);
+               this.resultsCount = this.results.reduce((acc, curr) => acc + (curr.rows ? curr.rows.length : 0), 0);
+               this.durationsCount = this.results.reduce((acc, curr) => acc + curr.duration, 0);
+               this.affectedCount = this.results
+                  .filter(result => result.report !== null)
+                  .reduce((acc, curr) => {
+                     if (acc === null) acc = 0;
+                     return acc + (curr.report ? curr.report.affectedRows : 0);
+                  }, null);
 
                this.updateTabContent({
                   uid: this.connection.uid,
@@ -285,7 +290,7 @@ export default {
          this.results = [];
          this.resultsCount = 0;
          this.durationsCount = 0;
-         this.affectedCount = 0;
+         this.affectedCount = null;
       },
       resize (e) {
          const el = this.$refs.queryEditor.$el;
diff --git a/src/renderer/components/WorkspaceTabTable.vue b/src/renderer/components/WorkspaceTabTable.vue
index 1fda6749..d8cac0a1 100644
--- a/src/renderer/components/WorkspaceTabTable.vue
+++ b/src/renderer/components/WorkspaceTabTable.vue
@@ -120,7 +120,12 @@
                   {{ $t('word.results') }}: <b>{{ results[0].rows.length | localeString }}</b>
                </div>
                <div v-if="hasApproximately || (page > 1 && approximateCount)">
-                  {{ $t('word.total') }}: <b :title="$t('word.approximately')">≈ {{ approximateCount | localeString }}</b>
+                  {{ $t('word.total') }}: <b
+                     :title="!customizations.tableRealCount ? $t('word.approximately') : ''"
+                  >
+                     <span v-if="!customizations.tableRealCount">≈</span>
+                     {{ approximateCount | localeString }}
+                  </b>
                </div>
                <div class="d-flex" :title="$t('word.schema')">
                   <i class="mdi mdi-18px mdi-database mr-1" /><b>{{ schema }}</b>
@@ -231,6 +236,9 @@ export default {
       workspace () {
          return this.getWorkspace(this.connection.uid);
       },
+      customizations () {
+         return this.workspace.customizations;
+      },
       isTable () {
          return !!this.workspace.breadcrumbs.table;
       },
diff --git a/src/renderer/scss/_data-types.scss b/src/renderer/scss/_data-types.scss
index 85f374ca..c82d6e60 100644
--- a/src/renderer/scss/_data-types.scss
+++ b/src/renderer/scss/_data-types.scss
@@ -17,10 +17,12 @@
   (
     "char": $string-color,
     "varchar": $string-color,
+    "longvarchar": $string-color,
     "text": $string-color,
     "tinytext": $string-color,
     "mediumtext": $string-color,
     "longtext": $string-color,
+    "string": $string-color,
     "json": $string-color,
     "name": $string-color,
     "character": $string-color,
@@ -50,6 +52,7 @@
     "oid": $number-color,
     "xid": $number-color,
     "money": $number-color,
+    "number": $number-color,
     "datetime": $date-color,
     "date": $date-color,
     "time": $date-color,
diff --git a/src/renderer/store/modules/workspaces.store.js b/src/renderer/store/modules/workspaces.store.js
index 39c07f5f..66eb9843 100644
--- a/src/renderer/store/modules/workspaces.store.js
+++ b/src/renderer/store/modules/workspaces.store.js
@@ -412,6 +412,11 @@ export default {
                      indexTypes = require('common/index-types/postgresql');
                      customizations = require('common/customizations/postgresql');
                      break;
+                  case 'sqlite':
+                     // dataTypes = require('common/data-types/sqlite');
+                     // indexTypes = require('common/index-types/sqlite');
+                     customizations = require('common/customizations/sqlite');
+                     break;
                }
 
                const { status, response: version } = await Schema.getVersion(connection.uid);

From fd321beece075d3ad23fdd8541f9beb5727045a5 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Tue, 16 Nov 2021 12:27:51 +0100
Subject: [PATCH 04/10] feat(SQLite): keys support

---
 src/main/libs/clients/SQLiteClient.js | 166 ++++++++++++++++++--------
 1 file changed, 113 insertions(+), 53 deletions(-)

diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 15209474..1283a673 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -286,20 +286,40 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getTableIndexes ({ schema, table }) {
-      const { rows } = await this.raw(`SHOW INDEXES FROM \`${table}\` FROM \`${schema}\``);
+      const remappedIndexes = [];
+      const { rows: primaryKeys } = await this.raw(`SELECT * FROM "${schema}".pragma_table_info('${table}') WHERE pk != 0`);
 
-      return rows.map(row => {
-         return {
-            unique: !row.Non_unique,
-            name: row.Key_name,
-            column: row.Column_name,
-            indexType: row.Index_type,
-            type: row.Key_name === 'PRIMARY' ? 'PRIMARY' : !row.Non_unique ? 'UNIQUE' : row.Index_type === 'FULLTEXT' ? 'FULLTEXT' : 'INDEX',
-            cardinality: row.Cardinality,
-            comment: row.Comment,
-            indexComment: row.Index_comment
-         };
-      });
+      for (const key of primaryKeys) {
+         remappedIndexes.push({
+            name: 'PRIMARY',
+            column: key.name,
+            indexType: null,
+            type: 'PRIMARY',
+            cardinality: null,
+            comment: '',
+            indexComment: ''
+         });
+      }
+
+      const { rows: indexes } = await this.raw(`SELECT * FROM "${schema}".pragma_index_list('${table}');`);
+
+      for (const index of indexes) {
+         const { rows: details } = await this.raw(`SELECT * FROM "${schema}".pragma_index_info('${index.name}');`);
+
+         for (const detail of details) {
+            remappedIndexes.push({
+               name: index.name,
+               column: detail.name,
+               indexType: null,
+               type: index.unique === 1 ? 'UNIQUE' : 'INDEX',
+               cardinality: null,
+               comment: '',
+               indexComment: ''
+            });
+         }
+      }
+
+      return remappedIndexes;
    }
 
    /**
@@ -1235,7 +1255,7 @@ export class SQLiteClient extends AntaresCore {
          sql = sql.replace(/(\/\*(.|[\r\n])*?\*\/)|(--(.*|[\r\n]))/gm, '');// Remove comments
 
       const resultsArr = [];
-      // let paramsArr = [];
+      let paramsArr = [];
       const queries = args.split
          ? sql.split(/((?:[^;'"]*(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*')[^;'"]*)+)|;/gm)
             .filter(Boolean)
@@ -1250,51 +1270,91 @@ export class SQLiteClient extends AntaresCore {
          const keysArr = [];
 
          const { rows, report, fields, keys, duration } = await new Promise((resolve, reject) => {
-            let queryResult;
-            let affectedRows;
-            let fields;
-            const detectedTypes = {};
+            (async () => {
+               let queryResult;
+               let affectedRows;
+               let fields;
+               const detectedTypes = {};
 
-            const stmt = connection.prepare(query);
-            if (stmt.reader) {
-               queryResult = stmt.all();
-               fields = stmt.columns();
+               const stmt = connection.prepare(query);
+               if (stmt.reader) {
+                  queryResult = stmt.all();
+                  fields = stmt.columns();
 
-               if (queryResult.length) {
-                  fields.forEach(field => {
-                     detectedTypes[field.name] = typeof queryResult[0][field.name];
-                  });
+                  if (queryResult.length) {
+                     fields.forEach(field => {
+                        detectedTypes[field.name] = typeof queryResult[0][field.name];
+                     });
+                  }
+               }
+               else {
+                  const info = queryResult = stmt.run();
+                  affectedRows = info.changes;
                }
-            }
-            else {
-               const info = queryResult = stmt.run();
-               affectedRows = info.changes;
-            }
 
-            const remappedFields = fields
-               ? fields.map(field => {
-                  return {
-                     name: field.name,
-                     alias: field.name,
-                     orgName: field.column,
-                     schema: field.database,
-                     table: field.table,
-                     tableAlias: field.table,
-                     orgTable: field.table,
-                     type: field.type !== null ? field.type : detectedTypes[field.name]
-                  };
-               }).filter(Boolean)
-               : [];
+               timeStop = new Date();
 
-            timeStop = new Date();
+               let remappedFields = fields
+                  ? fields.map(field => {
+                     return {
+                        name: field.name,
+                        alias: field.name,
+                        orgName: field.column,
+                        schema: field.database,
+                        table: field.table,
+                        tableAlias: field.table,
+                        orgTable: field.table,
+                        type: field.type !== null ? field.type : detectedTypes[field.name]
+                     };
+                  }).filter(Boolean)
+                  : [];
 
-            resolve({
-               duration: timeStop - timeStart,
-               rows: Array.isArray(queryResult) ? queryResult.some(el => Array.isArray(el)) ? [] : queryResult : false,
-               report: affectedRows !== undefined ? { affectedRows } : null,
-               fields: remappedFields,
-               keys: keysArr
-            });
+               if (args.details) {
+                  paramsArr = remappedFields.map(field => {
+                     return {
+                        table: field.table,
+                        schema: field.schema
+                     };
+                  }).filter((val, i, arr) => arr.findIndex(el => el.schema === val.schema && el.table === val.table) === i);
+
+                  for (const paramObj of paramsArr) {
+                     if (!paramObj.table || !paramObj.schema) continue;
+
+                     try {
+                        const indexes = await this.getTableIndexes(paramObj);
+
+                        remappedFields = remappedFields.map(field => {
+                        // const detailedField = columns.find(f => f.name === field.name);
+                           const fieldIndex = indexes.find(i => i.column === field.name);
+                           if (field.table === paramObj.table && field.schema === paramObj.schema) {
+                           // if (detailedField) {
+                           //    const length = detailedField.numPrecision || detailedField.charLength || detailedField.datePrecision || null;
+                           //    field = { ...field, ...detailedField, length };
+                           // }
+
+                              if (fieldIndex) {
+                                 const key = fieldIndex.type === 'PRIMARY' ? 'pri' : fieldIndex.type === 'UNIQUE' ? 'uni' : 'mul';
+                                 field = { ...field, key };
+                              };
+                           }
+
+                           return field;
+                        });
+                     }
+                     catch (err) {
+                        reject(err);
+                     }
+                  }
+               }
+
+               resolve({
+                  duration: timeStop - timeStart,
+                  rows: Array.isArray(queryResult) ? queryResult.some(el => Array.isArray(el)) ? [] : queryResult : false,
+                  report: affectedRows !== undefined ? { affectedRows } : null,
+                  fields: remappedFields,
+                  keys: keysArr
+               });
+            })();
          });
 
          resultsArr.push({ rows, report, fields, keys, duration });

From 604b3719204f7473ce4846624f08f8be9eec8b8f Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Tue, 16 Nov 2021 12:56:03 +0100
Subject: [PATCH 05/10] feat(SQLite): cell update in data tabs

---
 src/main/ipc-handlers/tables.js       | 10 ++++++++++
 src/main/libs/clients/SQLiteClient.js | 28 ++++++++++++++++-----------
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/main/ipc-handlers/tables.js b/src/main/ipc-handlers/tables.js
index 997dadb0..e0faf307 100644
--- a/src/main/ipc-handlers/tables.js
+++ b/src/main/ipc-handlers/tables.js
@@ -102,6 +102,9 @@ export default (connections) => {
                case 'pg':
                   escapedParam = `'${params.content.replaceAll('\'', '\'\'')}'`;
                   break;
+               case 'sqlite':
+                  escapedParam = `'${params.content.replaceAll('\'', '\'\'')}'`;
+                  break;
             }
          }
          else if (ARRAY.includes(params.type))
@@ -122,6 +125,10 @@ export default (connections) => {
                      fileBlob = fs.readFileSync(params.content);
                      escapedParam = `decode('${fileBlob.toString('hex')}', 'hex')`;
                      break;
+                  case 'sqlite':
+                     fileBlob = fs.readFileSync(params.content);
+                     escapedParam = `X'${fileBlob.toString('hex')}'`;
+                     break;
                }
                reload = true;
             }
@@ -134,6 +141,9 @@ export default (connections) => {
                   case 'pg':
                      escapedParam = 'decode(\'\', \'hex\')';
                      break;
+                  case 'sqlite':
+                     escapedParam = 'X\'\'';
+                     break;
                }
             }
          }
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 1283a673..44fd15f8 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -1276,20 +1276,26 @@ export class SQLiteClient extends AntaresCore {
                let fields;
                const detectedTypes = {};
 
-               const stmt = connection.prepare(query);
-               if (stmt.reader) {
-                  queryResult = stmt.all();
-                  fields = stmt.columns();
+               try {
+                  const stmt = connection.prepare(query);
 
-                  if (queryResult.length) {
-                     fields.forEach(field => {
-                        detectedTypes[field.name] = typeof queryResult[0][field.name];
-                     });
+                  if (stmt.reader) {
+                     queryResult = stmt.all();
+                     fields = stmt.columns();
+
+                     if (queryResult.length) {
+                        fields.forEach(field => {
+                           detectedTypes[field.name] = typeof queryResult[0][field.name];
+                        });
+                     }
+                  }
+                  else {
+                     const info = queryResult = stmt.run();
+                     affectedRows = info.changes;
                   }
                }
-               else {
-                  const info = queryResult = stmt.run();
-                  affectedRows = info.changes;
+               catch (err) {
+                  reject(err);
                }
 
                timeStop = new Date();

From 3fc227d2de53aae115226ad3c965bfb6e9f3eca6 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Tue, 16 Nov 2021 13:21:33 +0100
Subject: [PATCH 06/10] feat(SQLite): readonly mode

---
 src/common/customizations/defaults.js                    | 3 ++-
 src/common/customizations/sqlite.js                      | 3 ++-
 src/main/ipc-handlers/connection.js                      | 6 ++++--
 src/main/libs/clients/SQLiteClient.js                    | 3 ++-
 src/renderer/components/WorkspaceAddConnectionPanel.vue  | 9 +++++++++
 src/renderer/components/WorkspaceEditConnectionPanel.vue | 8 ++++++++
 src/renderer/i18n/en-US.js                               | 3 ++-
 7 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/common/customizations/defaults.js b/src/common/customizations/defaults.js
index 70c5ad67..dc06eb57 100644
--- a/src/common/customizations/defaults.js
+++ b/src/common/customizations/defaults.js
@@ -80,5 +80,6 @@ module.exports = {
    triggerFunctionSql: false,
    triggerFunctionlanguages: false,
    parametersLength: false,
-   languages: false
+   languages: false,
+   readOnlyMode: false
 };
diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
index ca736ad8..d16ee470 100644
--- a/src/common/customizations/sqlite.js
+++ b/src/common/customizations/sqlite.js
@@ -78,5 +78,6 @@ module.exports = {
    triggerFunctionSql: false,
    triggerFunctionlanguages: false,
    parametersLength: false,
-   languages: false
+   languages: false,
+   readOnlyMode: true
 };
diff --git a/src/main/ipc-handlers/connection.js b/src/main/ipc-handlers/connection.js
index 78d6278b..5ac0aac5 100644
--- a/src/main/ipc-handlers/connection.js
+++ b/src/main/ipc-handlers/connection.js
@@ -9,7 +9,8 @@ export default connections => {
          port: +conn.port,
          user: conn.user,
          password: conn.password,
-         application_name: 'Antares SQL'
+         application_name: 'Antares SQL',
+         readonly: conn.readonly
       };
 
       if (conn.database)
@@ -65,7 +66,8 @@ export default connections => {
          port: +conn.port,
          user: conn.user,
          password: conn.password,
-         application_name: 'Antares SQL'
+         application_name: 'Antares SQL',
+         readonly: conn.readonly
       };
 
       if (conn.database)
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 44fd15f8..b48163a5 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -21,7 +21,8 @@ export class SQLiteClient extends AntaresCore {
     */
    async connect () {
       this._connection = sqlite(this._params.databasePath, {
-         fileMustExist: true
+         fileMustExist: true,
+         readonly: this._params.readonly
       });
    }
 
diff --git a/src/renderer/components/WorkspaceAddConnectionPanel.vue b/src/renderer/components/WorkspaceAddConnectionPanel.vue
index ede77563..8d6b144c 100644
--- a/src/renderer/components/WorkspaceAddConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceAddConnectionPanel.vue
@@ -151,6 +151,14 @@
                            >
                         </div>
                      </div>
+                     <div v-if="customizations.readOnlyMode" class="form-group columns">
+                        <div class="column col-4 col-sm-12" />
+                        <div class="column col-8 col-sm-12">
+                           <label class="form-checkbox form-inline">
+                              <input v-model="connection.readonly" type="checkbox"><i class="form-icon" /> {{ $t('message.readOnlyMode') }}
+                           </label>
+                        </div>
+                     </div>
                      <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12" />
                         <div class="column col-8 col-sm-12">
@@ -392,6 +400,7 @@ export default {
             user: null,
             password: '',
             ask: false,
+            readonly: false,
             uid: uidGen('C'),
             ssl: false,
             cert: '',
diff --git a/src/renderer/components/WorkspaceEditConnectionPanel.vue b/src/renderer/components/WorkspaceEditConnectionPanel.vue
index 55e5253e..c62a02bf 100644
--- a/src/renderer/components/WorkspaceEditConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceEditConnectionPanel.vue
@@ -151,6 +151,14 @@
                            >
                         </div>
                      </div>
+                     <div v-if="customizations.readOnlyMode" class="form-group columns">
+                        <div class="column col-4 col-sm-12" />
+                        <div class="column col-8 col-sm-12">
+                           <label class="form-checkbox form-inline">
+                              <input v-model="localConnection.readonly" type="checkbox"><i class="form-icon" /> {{ $t('message.readOnlyMode') }}
+                           </label>
+                        </div>
+                     </div>
                      <div v-if="!customizations.fileConnection" class="form-group columns">
                         <div class="column col-4 col-sm-12" />
                         <div class="column col-8 col-sm-12">
diff --git a/src/renderer/i18n/en-US.js b/src/renderer/i18n/en-US.js
index de1f6d8b..daed3a73 100644
--- a/src/renderer/i18n/en-US.js
+++ b/src/renderer/i18n/en-US.js
@@ -250,7 +250,8 @@ module.exports = {
       searchForQueries: 'Search for queries',
       killProcess: 'Kill process',
       closeTab: 'Close tab',
-      goToDownloadPage: 'Go to download page'
+      goToDownloadPage: 'Go to download page',
+      readOnlyMode: 'Read-only mode'
    },
    faker: {
       address: 'Address',

From 3efeb45c460f178b794de72367f8d542fd8ddd56 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Thu, 18 Nov 2021 11:36:46 +0100
Subject: [PATCH 07/10] feat(SQLite): tables management

---
 src/common/customizations/defaults.js         |   2 +
 src/common/customizations/mysql.js            |   1 +
 src/common/customizations/postgresql.js       |   1 +
 src/common/customizations/sqlite.js           |  13 +-
 src/common/data-types/sqlite.js               | 137 +++
 src/common/index-types/sqlite.js              |   5 +
 src/main/libs/clients/MySQLClient.js          |  46 +-
 src/main/libs/clients/PostgreSQLClient.js     |  28 +-
 src/main/libs/clients/SQLiteClient.js         | 779 +++---------------
 .../components/WorkspaceExploreBar.vue        |   1 +
 .../WorkspaceExploreBarSchemaContext.vue      |   6 +-
 .../components/WorkspaceTabPropsTable.vue     |   6 +
 .../components/WorkspaceTabPropsTableRow.vue  |   5 +-
 .../store/modules/workspaces.store.js         |   4 +-
 14 files changed, 312 insertions(+), 722 deletions(-)
 create mode 100644 src/common/data-types/sqlite.js
 create mode 100644 src/common/index-types/sqlite.js

diff --git a/src/common/customizations/defaults.js b/src/common/customizations/defaults.js
index dc06eb57..e41ce30b 100644
--- a/src/common/customizations/defaults.js
+++ b/src/common/customizations/defaults.js
@@ -36,6 +36,7 @@ module.exports = {
    schedulerAdd: false,
    databaseEdit: false,
    schemaEdit: false,
+   schemaDrop: false,
    tableSettings: false,
    tableOptions: false,
    tableArray: false,
@@ -51,6 +52,7 @@ module.exports = {
    sortableFields: false,
    unsigned: false,
    nullable: false,
+   nullablePrimary: false,
    zerofill: false,
    autoIncrement: false,
    comment: false,
diff --git a/src/common/customizations/mysql.js b/src/common/customizations/mysql.js
index 0b6c683e..7496eb62 100644
--- a/src/common/customizations/mysql.js
+++ b/src/common/customizations/mysql.js
@@ -32,6 +32,7 @@ module.exports = {
    functionAdd: true,
    schedulerAdd: true,
    schemaEdit: true,
+   schemaDrop: true,
    tableSettings: true,
    viewSettings: true,
    triggerSettings: true,
diff --git a/src/common/customizations/postgresql.js b/src/common/customizations/postgresql.js
index 341aa538..078ce79e 100644
--- a/src/common/customizations/postgresql.js
+++ b/src/common/customizations/postgresql.js
@@ -28,6 +28,7 @@ module.exports = {
    triggerFunctionAdd: true,
    routineAdd: true,
    functionAdd: true,
+   schemaDrop: true,
    databaseEdit: false,
    tableSettings: true,
    viewSettings: true,
diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
index d16ee470..067fc2b3 100644
--- a/src/common/customizations/sqlite.js
+++ b/src/common/customizations/sqlite.js
@@ -25,7 +25,7 @@ module.exports = {
    // Settings
    elementsWrapper: '',
    stringsWrapper: '"',
-   tableAdd: false,
+   tableAdd: true,
    viewAdd: false,
    triggerAdd: false,
    triggerFunctionAdd: false,
@@ -34,7 +34,7 @@ module.exports = {
    schedulerAdd: false,
    databaseEdit: false,
    schemaEdit: false,
-   tableSettings: false,
+   tableSettings: true,
    tableArray: false,
    tableRealCount: true,
    viewSettings: false,
@@ -43,11 +43,12 @@ module.exports = {
    routineSettings: false,
    functionSettings: false,
    schedulerSettings: false,
-   indexes: false,
-   foreigns: false,
-   sortableFields: false,
+   indexes: true,
+   foreigns: true,
+   sortableFields: true,
    unsigned: false,
-   nullable: false,
+   nullable: true,
+   nullablePrimary: true,
    zerofill: false,
    tableOptions: false,
    autoIncrement: false,
diff --git a/src/common/data-types/sqlite.js b/src/common/data-types/sqlite.js
new file mode 100644
index 00000000..5cd6e8b0
--- /dev/null
+++ b/src/common/data-types/sqlite.js
@@ -0,0 +1,137 @@
+module.exports = [
+   {
+      group: 'integer',
+      types: [
+         {
+            name: 'INT',
+            length: true,
+            collation: false,
+            unsigned: true,
+            zerofill: true
+         },
+         {
+            name: 'INTEGER',
+            length: true,
+            collation: false,
+            unsigned: true,
+            zerofill: true
+         },
+         {
+            name: 'BIGINT',
+            length: true,
+            collation: false,
+            unsigned: true,
+            zerofill: true
+         },
+         {
+            name: 'NUMERIC',
+            length: true,
+            collation: false,
+            unsigned: true,
+            zerofill: true
+         },
+         {
+            name: 'BOOLEAN',
+            length: false,
+            collation: false,
+            unsigned: true,
+            zerofill: true
+         }
+      ]
+   },
+   {
+      group: 'float',
+      types: [
+         {
+            name: 'FLOAT',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         },
+         {
+            name: 'REAL',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         }
+      ]
+   },
+   {
+      group: 'string',
+      types: [
+         {
+            name: 'CHAR',
+            length: true,
+            collation: true,
+            unsigned: false,
+            zerofill: false
+         },
+         {
+            name: 'VARCHAR',
+            length: true,
+            collation: true,
+            unsigned: false,
+            zerofill: false
+         },
+         {
+            name: 'TEXT',
+            length: true,
+            collation: true,
+            unsigned: false,
+            zerofill: false
+         }
+      ]
+   },
+   {
+      group: 'binary',
+      types: [
+         {
+            name: 'BLOB',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         }
+      ]
+   },
+   {
+      group: 'time',
+      types: [
+         {
+            name: 'DATE',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         },
+         {
+            name: 'TIME',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         },
+         {
+            name: 'DATETIME',
+            length: true,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         }
+      ]
+   },
+   {
+      group: 'other',
+      types: [
+         {
+            name: 'NONE',
+            length: false,
+            collation: false,
+            unsigned: false,
+            zerofill: false
+         }
+      ]
+   }
+];
diff --git a/src/common/index-types/sqlite.js b/src/common/index-types/sqlite.js
new file mode 100644
index 00000000..edc2f2a3
--- /dev/null
+++ b/src/common/index-types/sqlite.js
@@ -0,0 +1,5 @@
+module.exports = [
+   'PRIMARY',
+   'INDEX',
+   'UNIQUE'
+];
diff --git a/src/main/libs/clients/MySQLClient.js b/src/main/libs/clients/MySQLClient.js
index 47757c88..7d10ce3e 100644
--- a/src/main/libs/clients/MySQLClient.js
+++ b/src/main/libs/clients/MySQLClient.js
@@ -571,7 +571,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE DATABASE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createSchema (params) {
@@ -581,7 +581,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER DATABASE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterSchema (params) {
@@ -591,7 +591,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP DATABASE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropSchema (params) {
@@ -631,7 +631,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropView (params) {
@@ -642,7 +642,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterView (params) {
@@ -663,7 +663,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createView (params) {
@@ -696,7 +696,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropTrigger (params) {
@@ -707,7 +707,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterTrigger (params) {
@@ -729,7 +729,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createTrigger (params) {
@@ -803,7 +803,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP PROCEDURE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropRoutine (params) {
@@ -814,7 +814,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER PROCEDURE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterRoutine (params) {
@@ -836,7 +836,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE PROCEDURE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createRoutine (params) {
@@ -930,7 +930,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP FUNCTION
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropFunction (params) {
@@ -941,7 +941,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER FUNCTION
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterFunction (params) {
@@ -963,7 +963,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE FUNCTION
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createFunction (params) {
@@ -1024,7 +1024,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP EVENT
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropEvent (params) {
@@ -1035,7 +1035,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER EVENT
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterEvent (params) {
@@ -1061,7 +1061,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE EVENT
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createEvent (params) {
@@ -1205,7 +1205,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * CREATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createTable (params) {
@@ -1267,7 +1267,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * ALTER TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterTable (params) {
@@ -1402,7 +1402,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DUPLICATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async duplicateTable (params) {
@@ -1413,7 +1413,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * TRUNCATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async truncateTable (params) {
@@ -1424,7 +1424,7 @@ export class MySQLClient extends AntaresCore {
    /**
     * DROP TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropTable (params) {
diff --git a/src/main/libs/clients/PostgreSQLClient.js b/src/main/libs/clients/PostgreSQLClient.js
index 760368d2..6a68948f 100644
--- a/src/main/libs/clients/PostgreSQLClient.js
+++ b/src/main/libs/clients/PostgreSQLClient.js
@@ -506,7 +506,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * CREATE SCHEMA
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async createSchema (params) {
@@ -516,7 +516,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * ALTER DATABASE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async alterSchema (params) {
@@ -526,7 +526,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * DROP DATABASE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof MySQLClient
     */
    async dropSchema (params) {
@@ -558,7 +558,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * DROP VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async dropView (params) {
@@ -569,7 +569,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * ALTER VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async alterView (params) {
@@ -585,7 +585,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * CREATE VIEW
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async createView (params) {
@@ -640,7 +640,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * DROP TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async dropTrigger (params) {
@@ -652,7 +652,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * ALTER TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async alterTrigger (params) {
@@ -674,7 +674,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * CREATE TRIGGER
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async createTrigger (params) {
@@ -1086,7 +1086,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * CREATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async createTable (params) {
@@ -1144,7 +1144,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * ALTER TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async alterTable (params) {
@@ -1290,7 +1290,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * DUPLICATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async duplicateTable (params) {
@@ -1301,7 +1301,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * TRUNCATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async truncateTable (params) {
@@ -1312,7 +1312,7 @@ export class PostgreSQLClient extends AntaresCore {
    /**
     * DROP TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof PostgreSQLClient
     */
    async dropTable (params) {
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index b48163a5..9a4b6daf 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -2,6 +2,7 @@
 import sqlite from 'better-sqlite3';
 import { AntaresCore } from '../AntaresCore';
 import dataTypes from 'common/data-types/mysql';
+import { NUMBER, FLOAT } from 'common/fieldTypes';
 
 export class SQLiteClient extends AntaresCore {
    constructor (args) {
@@ -136,95 +137,35 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getTableColumns ({ schema, table }) {
-      const { rows } = await this
-         .select('*')
-         .schema('information_schema')
-         .from('COLUMNS')
-         .where({ TABLE_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'` })
-         .orderBy({ ORDINAL_POSITION: 'ASC' })
-         .run();
+      const { rows: fields } = await this.raw(`SELECT * FROM "${schema}".pragma_table_info('${table}')`);
 
-      const { rows: fields } = await this.raw(`SHOW CREATE TABLE \`${schema}\`.\`${table}\``);
-
-      const remappedFields = fields.map(row => {
-         if (!row['Create Table']) return false;
-
-         let n = 0;
-         return row['Create Table']
-            .split('')
-            .reduce((acc, curr) => {
-               if (curr === ')') n--;
-               if (n !== 0) acc += curr;
-               if (curr === '(') n++;
-               return acc;
-            }, '')
-            .replaceAll('\n', '')
-            .split(',')
-            .map(f => {
-               try {
-                  const fieldArr = f.trim().split(' ');
-                  const nameAndType = fieldArr.slice(0, 2);
-                  if (nameAndType[0].charAt(0) !== '`') return false;
-
-                  const details = fieldArr.slice(2).join(' ');
-                  let defaultValue = null;
-                  if (details.includes('DEFAULT'))
-                     defaultValue = details.match(/(?<=DEFAULT ).*?$/gs)[0].split(' COMMENT')[0];
-                     // const defaultValueArr = defaultValue.split('');
-                     // if (defaultValueArr[0] === '\'') {
-                     //    defaultValueArr.shift();
-                     //    defaultValueArr.pop();
-                     //    defaultValue = defaultValueArr.join('');
-                     // }
-
-                  const typeAndLength = nameAndType[1].replace(')', '').split('(');
-
-                  return {
-                     name: nameAndType[0].replaceAll('`', ''),
-                     type: typeAndLength[0].toUpperCase(),
-                     length: typeAndLength[1] ? typeAndLength[1] : null,
-                     default: defaultValue
-                  };
-               }
-               catch (err) {
-                  return false;
-               }
+      return fields.map(field => {
+         const [type, length] = field.type.includes('(')
+            ? field.type.replace(')', '').split('(').map(el => {
+               if (!isNaN(el)) el = +el;
+               return el;
             })
-            .filter(Boolean)
-            .reduce((acc, curr) => {
-               acc[curr.name] = curr;
-               return acc;
-            }, {});
-      })[0];
-
-      return rows.map(field => {
-         let numLength = field.COLUMN_TYPE.match(/int\(([^)]+)\)/);
-         numLength = numLength ? +numLength.pop() : null;
-         const enumValues = /(enum|set)/.test(field.COLUMN_TYPE)
-            ? field.COLUMN_TYPE.match(/\(([^)]+)\)/)[0].slice(1, -1)
-            : null;
+            : [field.type, null];
 
          return {
-            name: field.COLUMN_NAME,
-            key: field.COLUMN_KEY.toLowerCase(),
-            type: remappedFields ? remappedFields[field.COLUMN_NAME].type : field.DATA_TYPE,
-            schema: field.TABLE_SCHEMA,
-            table: field.TABLE_NAME,
-            numPrecision: field.NUMERIC_PRECISION,
-            numLength,
-            enumValues,
-            datePrecision: field.DATETIME_PRECISION,
-            charLength: field.CHARACTER_MAXIMUM_LENGTH,
-            nullable: field.IS_NULLABLE.includes('YES'),
-            unsigned: field.COLUMN_TYPE.includes('unsigned'),
-            zerofill: field.COLUMN_TYPE.includes('zerofill'),
-            order: field.ORDINAL_POSITION,
-            default: remappedFields ? remappedFields[field.COLUMN_NAME].default : field.COLUMN_DEFAULT,
-            charset: field.CHARACTER_SET_NAME,
-            collation: field.COLLATION_NAME,
-            autoIncrement: field.EXTRA.includes('auto_increment'),
-            onUpdate: field.EXTRA.toLowerCase().includes('on update') ? field.EXTRA.replace('on update', '') : '',
-            comment: field.COLUMN_COMMENT
+            name: field.name,
+            key: null,
+            type,
+            schema: schema,
+            table: table,
+            numPrecision: [...NUMBER, ...FLOAT].includes(type) ? length : null,
+            datePrecision: null,
+            charLength: ![...NUMBER, ...FLOAT].includes(type) ? length : null,
+            nullable: !field.notnull,
+            unsigned: null,
+            zerofill: null,
+            order: field.cid + 1,
+            default: field.dflt_value,
+            charset: null,
+            collation: null,
+            autoIncrement: false,
+            onUpdate: null,
+            comment: ''
          };
       });
    }
@@ -250,33 +191,7 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getTableOptions ({ schema, table }) {
-      const { rows } = await this.raw(`SHOW TABLE STATUS FROM \`${schema}\` WHERE Name = '${table}'`);
-
-      if (rows.length) {
-         let tableType;
-         switch (rows[0].Comment) {
-            case 'VIEW':
-               tableType = 'view';
-               break;
-            default:
-               tableType = 'table';
-               break;
-         }
-
-         return {
-            name: rows[0].Name,
-            type: tableType,
-            rows: rows[0].Rows,
-            created: rows[0].Create_time,
-            updated: rows[0].Update_time,
-            engine: rows[0].Engine,
-            comment: rows[0].Comment,
-            size: rows[0].Data_length + rows[0].Index_length,
-            autoIncrement: rows[0].Auto_increment,
-            collation: rows[0].Collation
-         };
-      };
-      return {};
+      return { name: table };
    }
 
    /**
@@ -331,78 +246,27 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getKeyUsage ({ schema, table }) {
-      const { rows } = await this
-         .select('*')
-         .schema('information_schema')
-         .from('KEY_COLUMN_USAGE')
-         .where({ TABLE_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'`, REFERENCED_TABLE_NAME: 'IS NOT NULL' })
-         .run();
-
-      const { rows: extras } = await this
-         .select('*')
-         .schema('information_schema')
-         .from('REFERENTIAL_CONSTRAINTS')
-         .where({ CONSTRAINT_SCHEMA: `= '${schema}'`, TABLE_NAME: `= '${table}'`, REFERENCED_TABLE_NAME: 'IS NOT NULL' })
-         .run();
+      const { rows } = await this.raw(`SELECT * FROM "${schema}".pragma_foreign_key_list('${table}');`);
 
       return rows.map(field => {
-         const extra = extras.find(x => x.CONSTRAINT_NAME === field.CONSTRAINT_NAME);
          return {
-            schema: field.TABLE_SCHEMA,
-            table: field.TABLE_NAME,
-            field: field.COLUMN_NAME,
-            position: field.ORDINAL_POSITION,
-            constraintPosition: field.POSITION_IN_UNIQUE_CONSTRAINT,
-            constraintName: field.CONSTRAINT_NAME,
-            refSchema: field.REFERENCED_TABLE_SCHEMA,
-            refTable: field.REFERENCED_TABLE_NAME,
-            refField: field.REFERENCED_COLUMN_NAME,
-            onUpdate: extra.UPDATE_RULE,
-            onDelete: extra.DELETE_RULE
+            schema: schema,
+            table: table,
+            field: field.from,
+            position: field.id + 1,
+            constraintPosition: null,
+            constraintName: field.id,
+            refSchema: schema,
+            refTable: field.table,
+            refField: field.to,
+            onUpdate: field.on_update,
+            onDelete: field.on_delete
          };
       });
    }
 
    async getUsers () {}
 
-   /**
-    * CREATE DATABASE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async createSchema (params) {
-      return await this.raw(`CREATE DATABASE \`${params.name}\` COLLATE ${params.collation}`);
-   }
-
-   /**
-    * ALTER DATABASE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async alterSchema (params) {
-      return await this.raw(`ALTER DATABASE \`${params.name}\` COLLATE ${params.collation}`);
-   }
-
-   /**
-    * DROP DATABASE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async dropSchema (params) {
-      return await this.raw(`DROP DATABASE \`${params.database}\``);
-   }
-
-   /**
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async getDatabaseCollation (params) {
-      return await this.raw(`SELECT \`DEFAULT_COLLATION_NAME\` FROM \`information_schema\`.\`SCHEMATA\` WHERE \`SCHEMA_NAME\`='${params.database}'`);
-   }
-
    /**
     * SHOW CREATE VIEW
     *
@@ -534,357 +398,6 @@ export class SQLiteClient extends AntaresCore {
       return await this.raw(sql, { split: false });
    }
 
-   /**
-    * SHOW CREATE PROCEDURE
-    *
-    * @returns {Array.<Object>} view informations
-    * @memberof SQLiteClient
-    */
-   async getRoutineInformations ({ schema, routine }) {
-      const sql = `SHOW CREATE PROCEDURE \`${schema}\`.\`${routine}\``;
-      const results = await this.raw(sql);
-
-      return results.rows.map(async row => {
-         if (!row['Create Procedure']) {
-            return {
-               definer: null,
-               sql: '',
-               parameters: [],
-               name: row.Procedure,
-               comment: '',
-               security: 'DEFINER',
-               deterministic: false,
-               dataAccess: 'CONTAINS SQL'
-            };
-         }
-
-         const sql = `SELECT * 
-               FROM information_schema.parameters 
-               WHERE SPECIFIC_NAME = '${routine}'
-               AND SPECIFIC_SCHEMA = '${schema}'
-               ORDER BY ORDINAL_POSITION
-            `;
-
-         const results = await this.raw(sql);
-
-         const parameters = results.rows.map(row => {
-            return {
-               name: row.PARAMETER_NAME,
-               type: row.DATA_TYPE.toUpperCase(),
-               length: row.NUMERIC_PRECISION || row.DATETIME_PRECISION || row.CHARACTER_MAXIMUM_LENGTH || '',
-               context: row.PARAMETER_MODE
-            };
-         });
-
-         let dataAccess = 'CONTAINS SQL';
-         if (row['Create Procedure'].includes('NO SQL'))
-            dataAccess = 'NO SQL';
-         if (row['Create Procedure'].includes('READS SQL DATA'))
-            dataAccess = 'READS SQL DATA';
-         if (row['Create Procedure'].includes('MODIFIES SQL DATA'))
-            dataAccess = 'MODIFIES SQL DATA';
-
-         return {
-            definer: row['Create Procedure'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
-            sql: row['Create Procedure'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
-            parameters: parameters || [],
-            name: row.Procedure,
-            comment: row['Create Procedure'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Procedure'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
-            security: row['Create Procedure'].includes('SQL SECURITY INVOKER') ? 'INVOKER' : 'DEFINER',
-            deterministic: row['Create Procedure'].includes('DETERMINISTIC'),
-            dataAccess
-         };
-      })[0];
-   }
-
-   /**
-    * DROP PROCEDURE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async dropRoutine (params) {
-      const sql = `DROP PROCEDURE \`${params.schema}\`.\`${params.routine}\``;
-      return await this.raw(sql);
-   }
-
-   /**
-    * ALTER PROCEDURE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async alterRoutine (params) {
-      const { routine } = params;
-      const tempProcedure = Object.assign({}, routine);
-      tempProcedure.name = `Antares_${tempProcedure.name}_tmp`;
-
-      try {
-         await this.createRoutine(tempProcedure);
-         await this.dropRoutine({ schema: routine.schema, routine: tempProcedure.name });
-         await this.dropRoutine({ schema: routine.schema, routine: routine.oldName });
-         await this.createRoutine(routine);
-      }
-      catch (err) {
-         return Promise.reject(err);
-      }
-   }
-
-   /**
-    * CREATE PROCEDURE
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async createRoutine (params) {
-      const parameters = 'parameters' in params
-         ? params.parameters.reduce((acc, curr) => {
-            acc.push(`${curr.context} \`${curr.name}\` ${curr.type}${curr.length ? `(${curr.length})` : ''}`);
-            return acc;
-         }, []).join(',')
-         : '';
-
-      const sql = `CREATE ${params.definer ? `DEFINER=${params.definer} ` : ''}PROCEDURE \`${params.schema}\`.\`${params.name}\`(${parameters})
-         LANGUAGE SQL
-         ${params.deterministic ? 'DETERMINISTIC' : 'NOT DETERMINISTIC'}
-         ${params.dataAccess}
-         SQL SECURITY ${params.security}
-         COMMENT '${params.comment}'
-         ${params.sql}`;
-
-      return await this.raw(sql, { split: false });
-   }
-
-   /**
-    * SHOW CREATE FUNCTION
-    *
-    * @returns {Array.<Object>} view informations
-    * @memberof SQLiteClient
-    */
-   async getFunctionInformations ({ schema, func }) {
-      const sql = `SHOW CREATE FUNCTION \`${schema}\`.\`${func}\``;
-      const results = await this.raw(sql);
-
-      return results.rows.map(async row => {
-         if (!row['Create Function']) {
-            return {
-               definer: null,
-               sql: '',
-               parameters: [],
-               name: row.Procedure,
-               comment: '',
-               security: 'DEFINER',
-               deterministic: false,
-               dataAccess: 'CONTAINS SQL',
-               returns: 'INT',
-               returnsLength: null
-            };
-         }
-
-         const sql = `SELECT * 
-            FROM information_schema.parameters 
-            WHERE SPECIFIC_NAME = '${func}'
-            AND SPECIFIC_SCHEMA = '${schema}'
-            ORDER BY ORDINAL_POSITION
-         `;
-
-         const results = await this.raw(sql);
-
-         const parameters = results.rows.filter(row => row.PARAMETER_MODE).map(row => {
-            return {
-               name: row.PARAMETER_NAME,
-               type: row.DATA_TYPE.toUpperCase(),
-               length: row.NUMERIC_PRECISION || row.DATETIME_PRECISION || row.CHARACTER_MAXIMUM_LENGTH || '',
-               context: row.PARAMETER_MODE
-            };
-         });
-
-         let dataAccess = 'CONTAINS SQL';
-         if (row['Create Function'].includes('NO SQL'))
-            dataAccess = 'NO SQL';
-         if (row['Create Function'].includes('READS SQL DATA'))
-            dataAccess = 'READS SQL DATA';
-         if (row['Create Function'].includes('MODIFIES SQL DATA'))
-            dataAccess = 'MODIFIES SQL DATA';
-
-         const output = row['Create Function'].match(/(?<=RETURNS ).*?(?=\s)/gs).length ? row['Create Function'].match(/(?<=RETURNS ).*?(?=\s)/gs)[0].replace(')', '').split('(') : ['', null];
-
-         return {
-            definer: row['Create Function'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
-            sql: row['Create Function'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
-            parameters: parameters || [],
-            name: row.Function,
-            comment: row['Create Function'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Function'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
-            security: row['Create Function'].includes('SQL SECURITY INVOKER') ? 'INVOKER' : 'DEFINER',
-            deterministic: row['Create Function'].includes('DETERMINISTIC'),
-            dataAccess,
-            returns: output[0].toUpperCase(),
-            returnsLength: +output[1]
-         };
-      })[0];
-   }
-
-   /**
-    * DROP FUNCTION
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async dropFunction (params) {
-      const sql = `DROP FUNCTION \`${params.schema}\`.\`${params.func}\``;
-      return await this.raw(sql);
-   }
-
-   /**
-    * ALTER FUNCTION
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async alterFunction (params) {
-      const { func } = params;
-      const tempProcedure = Object.assign({}, func);
-      tempProcedure.name = `Antares_${tempProcedure.name}_tmp`;
-
-      try {
-         await this.createFunction(tempProcedure);
-         await this.dropFunction({ schema: func.schema, func: tempProcedure.name });
-         await this.dropFunction({ schema: func.schema, func: func.oldName });
-         await this.createFunction(func);
-      }
-      catch (err) {
-         return Promise.reject(err);
-      }
-   }
-
-   /**
-    * CREATE FUNCTION
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async createFunction (params) {
-      const parameters = 'parameters' in params
-         ? params.parameters.reduce((acc, curr) => {
-            acc.push(`\`${curr.name}\` ${curr.type}${curr.length ? `(${curr.length})` : ''}`);
-            return acc;
-         }, []).join(',')
-         : '';
-
-      const body = params.returns ? params.sql : 'BEGIN\n  RETURN 0;\nEND';
-
-      const sql = `CREATE ${params.definer ? `DEFINER=${params.definer} ` : ''}FUNCTION \`${params.schema}\`.\`${params.name}\`(${parameters}) RETURNS ${params.returns || 'SMALLINT'}${params.returnsLength ? `(${params.returnsLength})` : ''}
-         LANGUAGE SQL
-         ${params.deterministic ? 'DETERMINISTIC' : 'NOT DETERMINISTIC'}
-         ${params.dataAccess}
-         SQL SECURITY ${params.security}
-         COMMENT '${params.comment}'
-         ${body}`;
-
-      return await this.raw(sql, { split: false });
-   }
-
-   /**
-    * SHOW CREATE EVENT
-    *
-    * @returns {Array.<Object>} view informations
-    * @memberof SQLiteClient
-    */
-   async getEventInformations ({ schema, scheduler }) {
-      const sql = `SHOW CREATE EVENT \`${schema}\`.\`${scheduler}\``;
-      const results = await this.raw(sql);
-
-      return results.rows.map(row => {
-         const schedule = row['Create Event'];
-         const execution = schedule.includes('EVERY') ? 'EVERY' : 'ONCE';
-         const every = execution === 'EVERY' ? row['Create Event'].match(/(?<=EVERY )(\s*([^\s]+)){0,2}/gs)[0].replaceAll('\'', '').split(' ') : [];
-         const starts = execution === 'EVERY' && schedule.includes('STARTS') ? schedule.match(/(?<=STARTS ').*?(?='\s)/gs)[0] : '';
-         const ends = execution === 'EVERY' && schedule.includes('ENDS') ? schedule.match(/(?<=ENDS ').*?(?='\s)/gs)[0] : '';
-         const at = execution === 'ONCE' && schedule.includes('AT') ? schedule.match(/(?<=AT ').*?(?='\s)/gs)[0] : '';
-
-         return {
-            definer: row['Create Event'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
-            sql: row['Create Event'].match(/(?<=DO )(.*)/gs)[0],
-            name: row.Event,
-            comment: row['Create Event'].match(/(?<=COMMENT ').*?(?=')/gs) ? row['Create Event'].match(/(?<=COMMENT ').*?(?=')/gs)[0] : '',
-            state: row['Create Event'].includes('ENABLE') ? 'ENABLE' : row['Create Event'].includes('DISABLE ON SLAVE') ? 'DISABLE ON SLAVE' : 'DISABLE',
-            preserve: row['Create Event'].includes('ON COMPLETION PRESERVE'),
-            execution,
-            every,
-            starts,
-            ends,
-            at
-         };
-      })[0];
-   }
-
-   /**
-    * DROP EVENT
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async dropEvent (params) {
-      const sql = `DROP EVENT \`${params.schema}\`.\`${params.scheduler}\``;
-      return await this.raw(sql);
-   }
-
-   /**
-    * ALTER EVENT
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async alterEvent (params) {
-      const { scheduler } = params;
-
-      if (scheduler.execution === 'EVERY' && scheduler.every[0].includes('-'))
-         scheduler.every[0] = `'${scheduler.every[0]}'`;
-
-      const sql = `ALTER ${scheduler.definer ? ` DEFINER=${scheduler.definer}` : ''} EVENT \`${scheduler.schema}\`.\`${scheduler.oldName}\` 
-      ON SCHEDULE
-         ${scheduler.execution === 'EVERY'
-      ? `EVERY ${scheduler.every.join(' ')}${scheduler.starts ? ` STARTS '${scheduler.starts}'` : ''}${scheduler.ends ? ` ENDS '${scheduler.ends}'` : ''}`
-      : `AT '${scheduler.at}'`}
-      ON COMPLETION${!scheduler.preserve ? ' NOT' : ''} PRESERVE
-      ${scheduler.name !== scheduler.oldName ? `RENAME TO \`${scheduler.schema}\`.\`${scheduler.name}\`` : ''}
-      ${scheduler.state}
-      COMMENT '${scheduler.comment}'
-      DO ${scheduler.sql}`;
-
-      return await this.raw(sql, { split: false });
-   }
-
-   /**
-    * CREATE EVENT
-    *
-    * @returns {Array.<Object>} parameters
-    * @memberof SQLiteClient
-    */
-   async createEvent (params) {
-      const sql = `CREATE ${params.definer ? ` DEFINER=${params.definer}` : ''} EVENT \`${params.schema}\`.\`${params.name}\` 
-      ON SCHEDULE
-         ${params.execution === 'EVERY'
-      ? `EVERY ${params.every.join(' ')}${params.starts ? ` STARTS '${params.starts}'` : ''}${params.ends ? ` ENDS '${params.ends}'` : ''}`
-      : `AT '${params.at}'`}
-      ON COMPLETION${!params.preserve ? ' NOT' : ''} PRESERVE
-      ${params.state}
-      COMMENT '${params.comment}'
-      DO ${params.sql}`;
-
-      return await this.raw(sql, { split: false });
-   }
-
-   async enableEvent ({ schema, scheduler }) {
-      const sql = `ALTER EVENT \`${schema}\`.\`${scheduler}\` ENABLE`;
-      return await this.raw(sql, { split: false });
-   }
-
-   async disableEvent ({ schema, scheduler }) {
-      const sql = `ALTER EVENT \`${schema}\`.\`${scheduler}\` DISABLE`;
-      return await this.raw(sql, { split: false });
-   }
-
    /**
     * SHOW COLLATION
     *
@@ -946,7 +459,7 @@ export class SQLiteClient extends AntaresCore {
    /**
     * CREATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof SQLiteClient
     */
    async createTable (params) {
@@ -959,48 +472,43 @@ export class SQLiteClient extends AntaresCore {
       } = params;
       const newColumns = [];
       const newIndexes = [];
+      const manageIndexes = [];
       const newForeigns = [];
 
-      let sql = `CREATE TABLE \`${schema}\`.\`${options.name}\``;
+      let sql = `CREATE TABLE "${schema}"."${options.name}"`;
 
       // ADD FIELDS
       fields.forEach(field => {
          const typeInfo = this._getTypeInfo(field.type);
-         const length = typeInfo.length ? field.enumValues || field.numLength || field.charLength || field.datePrecision : false;
+         const length = typeInfo?.length ? field.enumValues || field.numLength || field.charLength || field.datePrecision : false;
 
-         newColumns.push(`\`${field.name}\` 
-            ${field.type.toUpperCase()}${length ? `(${length})` : ''} 
+         newColumns.push(`"${field.name}" 
+            ${field.type.toUpperCase()}${length && length !== true ? `(${length})` : ''} 
             ${field.unsigned ? 'UNSIGNED' : ''} 
-            ${field.zerofill ? 'ZEROFILL' : ''}
             ${field.nullable ? 'NULL' : 'NOT NULL'}
             ${field.autoIncrement ? 'AUTO_INCREMENT' : ''}
             ${field.default ? `DEFAULT ${field.default}` : ''}
-            ${field.comment ? `COMMENT '${field.comment}'` : ''}
-            ${field.collation ? `COLLATE ${field.collation}` : ''}
             ${field.onUpdate ? `ON UPDATE ${field.onUpdate}` : ''}`);
       });
 
       // ADD INDEX
       indexes.forEach(index => {
-         const fields = index.fields.map(field => `\`${field}\``).join(',');
-         let type = index.type;
+         const fields = index.fields.map(field => `"${field}"`).join(',');
+         const type = index.type;
 
          if (type === 'PRIMARY')
             newIndexes.push(`PRIMARY KEY (${fields})`);
-         else {
-            if (type === 'UNIQUE')
-               type = 'UNIQUE INDEX';
-
-            newIndexes.push(`${type} \`${index.name}\` (${fields})`);
-         }
+         else
+            manageIndexes.push(`CREATE ${type === 'UNIQUE' ? type : ''} INDEX "${index.name}" ON "${options.name}" (${fields})`);
       });
 
       // ADD FOREIGN KEYS
       foreigns.forEach(foreign => {
-         newForeigns.push(`CONSTRAINT \`${foreign.constraintName}\` FOREIGN KEY (\`${foreign.field}\`) REFERENCES \`${foreign.refTable}\` (\`${foreign.refField}\`) ON UPDATE ${foreign.onUpdate} ON DELETE ${foreign.onDelete}`);
+         newForeigns.push(`CONSTRAINT "${foreign.constraintName}" FOREIGN KEY ("${foreign.field}") REFERENCES "${foreign.refTable}" ("${foreign.refField}") ON UPDATE ${foreign.onUpdate} ON DELETE ${foreign.onDelete}`);
       });
 
-      sql = `${sql} (${[...newColumns, ...newIndexes, ...newForeigns].join(', ')}) COMMENT='${options.comment}', COLLATE='${options.collation}', ENGINE=${options.engine}`;
+      sql = `${sql} (${[...newColumns, ...newIndexes, ...newForeigns].join(', ')})`;
+      if (manageIndexes.length) sql = `${sql}; ${manageIndexes.join(';')}`;
 
       return await this.raw(sql);
    }
@@ -1008,168 +516,87 @@ export class SQLiteClient extends AntaresCore {
    /**
     * ALTER TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof SQLiteClient
     */
    async alterTable (params) {
-      const {
-         table,
-         schema,
-         additions,
-         deletions,
-         changes,
-         indexChanges,
-         foreignChanges,
-         options
-      } = params;
+      try {
+         await this.raw('BEGIN TRANSACTION');
+         await this.raw('PRAGMA foreign_keys = 0');
 
-      let sql = `ALTER TABLE \`${schema}\`.\`${table}\` `;
-      const alterColumns = [];
+         const tmpName = `Antares_${params.table}_tmp`;
+         await this.raw(`CREATE TABLE "${tmpName}" AS SELECT * FROM "${params.table}"`);
+         await this.dropTable(params);
 
-      // OPTIONS
-      if ('comment' in options) alterColumns.push(`COMMENT='${options.comment}'`);
-      if ('engine' in options) alterColumns.push(`ENGINE=${options.engine}`);
-      if ('autoIncrement' in options) alterColumns.push(`AUTO_INCREMENT=${+options.autoIncrement}`);
-      if ('collation' in options) alterColumns.push(`COLLATE='${options.collation}'`);
+         const createTableParams = {
+            schema: params.schema,
+            fields: params.tableStructure.fields,
+            foreigns: params.tableStructure.foreigns,
+            indexes: params.tableStructure.indexes.filter(index => !index.name.includes('sqlite_autoindex')),
+            options: { name: params.tableStructure.name }
+         };
+         await this.createTable(createTableParams);
+         const insertFields = createTableParams.fields
+            .filter(field => {
+               return (
+                  params.additions.every(add => add.name !== field.name) &&
+                  params.deletions.every(del => del.name !== field.name)
+               );
+            })
+            .reduce((acc, curr) => {
+               acc.push(`"${curr.name}"`);
+               return acc;
+            }, []);
 
-      // ADD FIELDS
-      additions.forEach(addition => {
-         const typeInfo = this._getTypeInfo(addition.type);
-         const length = typeInfo.length ? addition.enumValues || addition.numLength || addition.charLength || addition.datePrecision : false;
+         const selectFields = insertFields.map(field => {
+            const renamedField = params.changes.find(change => `"${change.name}"` === field);
+            if (renamedField)
+               return `"${renamedField.orgName}"`;
+            return field;
+         });
 
-         alterColumns.push(`ADD COLUMN \`${addition.name}\` 
-            ${addition.type.toUpperCase()}${length ? `(${length})` : ''} 
-            ${addition.unsigned ? 'UNSIGNED' : ''} 
-            ${addition.zerofill ? 'ZEROFILL' : ''}
-            ${addition.nullable ? 'NULL' : 'NOT NULL'}
-            ${addition.autoIncrement ? 'AUTO_INCREMENT' : ''}
-            ${addition.default ? `DEFAULT ${addition.default}` : ''}
-            ${addition.comment ? `COMMENT '${addition.comment}'` : ''}
-            ${addition.collation ? `COLLATE ${addition.collation}` : ''}
-            ${addition.onUpdate ? `ON UPDATE ${addition.onUpdate}` : ''}
-            ${addition.after ? `AFTER \`${addition.after}\`` : 'FIRST'}`);
-      });
+         await this.raw(`INSERT INTO "${createTableParams.options.name}" (${insertFields.join(',')}) SELECT ${selectFields.join(',')} FROM "${tmpName}"`);
 
-      // ADD INDEX
-      indexChanges.additions.forEach(addition => {
-         const fields = addition.fields.map(field => `\`${field}\``).join(',');
-         let type = addition.type;
-
-         if (type === 'PRIMARY')
-            alterColumns.push(`ADD PRIMARY KEY (${fields})`);
-         else {
-            if (type === 'UNIQUE')
-               type = 'UNIQUE INDEX';
-
-            alterColumns.push(`ADD ${type} \`${addition.name}\` (${fields})`);
-         }
-      });
-
-      // ADD FOREIGN KEYS
-      foreignChanges.additions.forEach(addition => {
-         alterColumns.push(`ADD CONSTRAINT \`${addition.constraintName}\` FOREIGN KEY (\`${addition.field}\`) REFERENCES \`${addition.refTable}\` (\`${addition.refField}\`) ON UPDATE ${addition.onUpdate} ON DELETE ${addition.onDelete}`);
-      });
-
-      // CHANGE FIELDS
-      changes.forEach(change => {
-         const typeInfo = this._getTypeInfo(change.type);
-         const length = typeInfo.length ? change.enumValues || change.numLength || change.charLength || change.datePrecision : false;
-
-         alterColumns.push(`CHANGE COLUMN \`${change.orgName}\` \`${change.name}\` 
-            ${change.type.toUpperCase()}${length ? `(${length})` : ''} 
-            ${change.unsigned ? 'UNSIGNED' : ''} 
-            ${change.zerofill ? 'ZEROFILL' : ''}
-            ${change.nullable ? 'NULL' : 'NOT NULL'}
-            ${change.autoIncrement ? 'AUTO_INCREMENT' : ''}
-            ${change.default ? `DEFAULT ${change.default}` : ''}
-            ${change.comment ? `COMMENT '${change.comment}'` : ''}
-            ${change.collation ? `COLLATE ${change.collation}` : ''}
-            ${change.onUpdate ? `ON UPDATE ${change.onUpdate}` : ''}
-            ${change.after ? `AFTER \`${change.after}\`` : 'FIRST'}`);
-      });
-
-      // CHANGE INDEX
-      indexChanges.changes.forEach(change => {
-         if (change.oldType === 'PRIMARY')
-            alterColumns.push('DROP PRIMARY KEY');
-         else
-            alterColumns.push(`DROP INDEX \`${change.oldName}\``);
-
-         const fields = change.fields.map(field => `\`${field}\``).join(',');
-         let type = change.type;
-
-         if (type === 'PRIMARY')
-            alterColumns.push(`ADD PRIMARY KEY (${fields})`);
-         else {
-            if (type === 'UNIQUE')
-               type = 'UNIQUE INDEX';
-
-            alterColumns.push(`ADD ${type} \`${change.name}\` (${fields})`);
-         }
-      });
-
-      // CHANGE FOREIGN KEYS
-      foreignChanges.changes.forEach(change => {
-         alterColumns.push(`DROP FOREIGN KEY \`${change.oldName}\``);
-         alterColumns.push(`ADD CONSTRAINT \`${change.constraintName}\` FOREIGN KEY (\`${change.field}\`) REFERENCES \`${change.refTable}\` (\`${change.refField}\`) ON UPDATE ${change.onUpdate} ON DELETE ${change.onDelete}`);
-      });
-
-      // DROP FIELDS
-      deletions.forEach(deletion => {
-         alterColumns.push(`DROP COLUMN \`${deletion.name}\``);
-      });
-
-      // DROP INDEX
-      indexChanges.deletions.forEach(deletion => {
-         if (deletion.type === 'PRIMARY')
-            alterColumns.push('DROP PRIMARY KEY');
-         else
-            alterColumns.push(`DROP INDEX \`${deletion.name}\``);
-      });
-
-      // DROP FOREIGN KEYS
-      foreignChanges.deletions.forEach(deletion => {
-         alterColumns.push(`DROP FOREIGN KEY \`${deletion.constraintName}\``);
-      });
-
-      sql += alterColumns.join(', ');
-
-      // RENAME
-      if (options.name) sql += `; RENAME TABLE \`${schema}\`.\`${table}\` TO \`${schema}\`.\`${options.name}\``;
-
-      return await this.raw(sql);
+         await this.dropTable({ schema: params.schema, table: tmpName });
+         await this.raw('PRAGMA foreign_keys = 1');
+         await this.raw('COMMIT');
+      }
+      catch (err) {
+         await this.raw('ROLLBACK');
+         return Promise.reject(err);
+      }
    }
 
    /**
     * DUPLICATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof SQLiteClient
     */
-   async duplicateTable (params) {
-      const sql = `CREATE TABLE \`${params.schema}\`.\`${params.table}_copy\` LIKE \`${params.schema}\`.\`${params.table}\``;
+   async duplicateTable (params) { // TODO: retrive table informations and create a copy
+      const sql = `CREATE TABLE "${params.schema}"."${params.table}_copy" AS SELECT * FROM "${params.schema}"."${params.table}"`;
       return await this.raw(sql);
    }
 
    /**
     * TRUNCATE TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof SQLiteClient
     */
    async truncateTable (params) {
-      const sql = `TRUNCATE TABLE \`${params.schema}\`.\`${params.table}\``;
+      const sql = `DELETE FROM "${params.schema}"."${params.table}"`;
       return await this.raw(sql);
    }
 
    /**
     * DROP TABLE
     *
-    * @returns {Array.<Object>} parameters
+    * @returns {Promise<null>}
     * @memberof SQLiteClient
     */
    async dropTable (params) {
-      const sql = `DROP TABLE \`${params.schema}\`.\`${params.table}\``;
+      const sql = `DROP TABLE "${params.schema}"."${params.table}"`;
       return await this.raw(sql);
    }
 
@@ -1303,6 +730,10 @@ export class SQLiteClient extends AntaresCore {
 
                let remappedFields = fields
                   ? fields.map(field => {
+                     const parsedType = field.type?.includes('(')
+                        ? field.type.split('(')[0]
+                        : field.type;
+
                      return {
                         name: field.name,
                         alias: field.name,
@@ -1311,7 +742,7 @@ export class SQLiteClient extends AntaresCore {
                         table: field.table,
                         tableAlias: field.table,
                         orgTable: field.table,
-                        type: field.type !== null ? field.type : detectedTypes[field.name]
+                        type: field.type !== null ? parsedType : detectedTypes[field.name]
                      };
                   }).filter(Boolean)
                   : [];
diff --git a/src/renderer/components/WorkspaceExploreBar.vue b/src/renderer/components/WorkspaceExploreBar.vue
index e6378fc7..856e69f8 100644
--- a/src/renderer/components/WorkspaceExploreBar.vue
+++ b/src/renderer/components/WorkspaceExploreBar.vue
@@ -13,6 +13,7 @@
             <span class="workspace-explorebar-title">{{ connectionName }}</span>
             <span v-if="workspace.connectionStatus === 'connected'" class="workspace-explorebar-tools">
                <i
+                  v-if="customizations.schemas"
                   class="mdi mdi-18px mdi-database-plus c-hand mr-2"
                   :title="$t('message.createNewSchema')"
                   @click="showNewDBModal"
diff --git a/src/renderer/components/WorkspaceExploreBarSchemaContext.vue b/src/renderer/components/WorkspaceExploreBarSchemaContext.vue
index ea056c86..812a7a67 100644
--- a/src/renderer/components/WorkspaceExploreBarSchemaContext.vue
+++ b/src/renderer/components/WorkspaceExploreBarSchemaContext.vue
@@ -65,7 +65,11 @@
       >
          <span class="d-flex"><i class="mdi mdi-18px mdi-database-edit text-light pr-1" /> {{ $t('word.edit') }}</span>
       </div>
-      <div class="context-element" @click="showDeleteModal">
+      <div
+         v-if="workspace.customizations.schemaDrop"
+         class="context-element"
+         @click="showDeleteModal"
+      >
          <span class="d-flex"><i class="mdi mdi-18px mdi-database-remove text-light pr-1" /> {{ $t('word.delete') }}</span>
       </div>
 
diff --git a/src/renderer/components/WorkspaceTabPropsTable.vue b/src/renderer/components/WorkspaceTabPropsTable.vue
index 3e392d61..de79a340 100644
--- a/src/renderer/components/WorkspaceTabPropsTable.vue
+++ b/src/renderer/components/WorkspaceTabPropsTable.vue
@@ -506,6 +506,12 @@ export default {
             uid: this.connection.uid,
             schema: this.schema,
             table: this.table,
+            tableStructure: {
+               name: this.localOptions.name,
+               fields: this.localFields,
+               foreigns: this.localKeyUsage,
+               indexes: this.localIndexes
+            },
             additions,
             changes,
             deletions,
diff --git a/src/renderer/components/WorkspaceTabPropsTableRow.vue b/src/renderer/components/WorkspaceTabPropsTableRow.vue
index a3590e36..ba42468d 100644
--- a/src/renderer/components/WorkspaceTabPropsTableRow.vue
+++ b/src/renderer/components/WorkspaceTabPropsTableRow.vue
@@ -367,7 +367,8 @@ export default {
          getWorkspace: 'workspaces/getWorkspace'
       }),
       localLength () {
-         return this.localRow.numLength || this.localRow.charLength || this.localRow.datePrecision || this.localRow.numPrecision || 0;
+         const localLength = this.localRow.numLength || this.localRow.charLength || this.localRow.datePrecision || this.localRow.numPrecision || 0;
+         return localLength === true ? null : localLength;
       },
       fieldType () {
          const fieldType = this.dataTypes.reduce((acc, group) => [...acc, ...group.types], []).filter(type =>
@@ -391,7 +392,7 @@ export default {
          return this.indexes.some(index => ['PRIMARY', 'UNIQUE'].includes(index.type));
       },
       isNullable () {
-         return !this.indexes.some(index => ['PRIMARY'].includes(index.type));
+         return this.customizations.nullablePrimary || !this.indexes.some(index => ['PRIMARY'].includes(index.type));
       },
       isInDataTypes () {
          let typeNames = [];
diff --git a/src/renderer/store/modules/workspaces.store.js b/src/renderer/store/modules/workspaces.store.js
index 66eb9843..c36e220b 100644
--- a/src/renderer/store/modules/workspaces.store.js
+++ b/src/renderer/store/modules/workspaces.store.js
@@ -413,8 +413,8 @@ export default {
                      customizations = require('common/customizations/postgresql');
                      break;
                   case 'sqlite':
-                     // dataTypes = require('common/data-types/sqlite');
-                     // indexTypes = require('common/index-types/sqlite');
+                     dataTypes = require('common/data-types/sqlite');
+                     indexTypes = require('common/index-types/sqlite');
                      customizations = require('common/customizations/sqlite');
                      break;
                }

From 93b4a7063beeb5a7001cb06a74f05b23105212f5 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Thu, 18 Nov 2021 19:43:08 +0100
Subject: [PATCH 08/10] perf(SQLite): improvements in field length detection

---
 src/common/data-types/sqlite.js       |  2 +-
 src/main/libs/clients/SQLiteClient.js | 25 +++++++++++++++++++------
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/src/common/data-types/sqlite.js b/src/common/data-types/sqlite.js
index 5cd6e8b0..c7ac6b32 100644
--- a/src/common/data-types/sqlite.js
+++ b/src/common/data-types/sqlite.js
@@ -101,7 +101,7 @@ module.exports = [
       types: [
          {
             name: 'DATE',
-            length: true,
+            length: false,
             collation: false,
             unsigned: false,
             zerofill: false
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 9a4b6daf..392ea496 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -2,7 +2,7 @@
 import sqlite from 'better-sqlite3';
 import { AntaresCore } from '../AntaresCore';
 import dataTypes from 'common/data-types/mysql';
-import { NUMBER, FLOAT } from 'common/fieldTypes';
+import { NUMBER, FLOAT, TIME, DATETIME } from 'common/fieldTypes';
 
 export class SQLiteClient extends AntaresCore {
    constructor (args) {
@@ -150,7 +150,7 @@ export class SQLiteClient extends AntaresCore {
          return {
             name: field.name,
             key: null,
-            type,
+            type: type.trim(),
             schema: schema,
             table: table,
             numPrecision: [...NUMBER, ...FLOAT].includes(type) ? length : null,
@@ -730,9 +730,21 @@ export class SQLiteClient extends AntaresCore {
 
                let remappedFields = fields
                   ? fields.map(field => {
-                     const parsedType = field.type?.includes('(')
-                        ? field.type.split('(')[0]
-                        : field.type;
+                     let [parsedType, length] = field.type?.includes('(')
+                        ? field.type.replace(')', '').split('(').map(el => {
+                           if (!isNaN(el))
+                              el = +el;
+                           else
+                              el = el.trim();
+                           return el;
+                        })
+                        : [field.type, null];
+
+                     if ([...TIME, ...DATETIME].includes(parsedType)) {
+                        const firstNotNull = queryResult.find(res => res[field.name] !== null);
+                        if (firstNotNull[field.name].includes('.'))
+                           length = firstNotNull[field.name].split('.').pop().length;
+                     }
 
                      return {
                         name: field.name,
@@ -742,7 +754,8 @@ export class SQLiteClient extends AntaresCore {
                         table: field.table,
                         tableAlias: field.table,
                         orgTable: field.table,
-                        type: field.type !== null ? parsedType : detectedTypes[field.name]
+                        type: field.type !== null ? parsedType : detectedTypes[field.name],
+                        length
                      };
                   }).filter(Boolean)
                   : [];

From 7671c585f5f8049bd863db190d4fc60d8f0c6c66 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Fri, 19 Nov 2021 13:13:35 +0100
Subject: [PATCH 09/10] feat(SQLite): views management

---
 src/common/customizations/sqlite.js   |  4 +--
 src/main/libs/clients/SQLiteClient.js | 36 ++++++++++++---------------
 src/main/main.js                      |  8 +++---
 3 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
index 067fc2b3..a3f2e6e9 100644
--- a/src/common/customizations/sqlite.js
+++ b/src/common/customizations/sqlite.js
@@ -26,7 +26,7 @@ module.exports = {
    elementsWrapper: '',
    stringsWrapper: '"',
    tableAdd: true,
-   viewAdd: false,
+   viewAdd: true,
    triggerAdd: false,
    triggerFunctionAdd: false,
    routineAdd: false,
@@ -37,7 +37,7 @@ module.exports = {
    tableSettings: true,
    tableArray: false,
    tableRealCount: true,
-   viewSettings: false,
+   viewSettings: true,
    triggerSettings: false,
    triggerFunctionSettings: false,
    routineSettings: false,
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 392ea496..4b2ca6e8 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -56,7 +56,13 @@ export class SQLiteClient extends AntaresCore {
       for (const db of filteredDatabases) {
          if (!schemas.has(db.name)) continue;
 
-         let { rows: tables } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+         let { rows: tables } = await this.raw(`
+            SELECT * 
+            FROM "${db.name}".sqlite_master 
+            WHERE type IN ('table', 'view') 
+            AND name NOT LIKE 'sqlite_%' 
+            ORDER BY name
+         `);
          if (tables.length) {
             tables = tables.map(table => {
                table.Db = db.name;
@@ -274,17 +280,13 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getViewInformations ({ schema, view }) {
-      const sql = `SHOW CREATE VIEW \`${schema}\`.\`${view}\``;
+      const sql = `SELECT "sql" FROM "${schema}".sqlite_master WHERE "type"='view' AND name='${view}'`;
       const results = await this.raw(sql);
 
       return results.rows.map(row => {
          return {
-            algorithm: row['Create View'].match(/(?<=CREATE ALGORITHM=).*?(?=\s)/gs)[0],
-            definer: row['Create View'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
-            security: row['Create View'].match(/(?<=SQL SECURITY ).*?(?=\s)/gs)[0],
-            updateOption: row['Create View'].match(/(?<=WITH ).*?(?=\s)/gs) ? row['Create View'].match(/(?<=WITH ).*?(?=\s)/gs)[0] : '',
-            sql: row['Create View'].match(/(?<=AS ).*?$/gs)[0],
-            name: row.View
+            sql: row.sql.match(/(?<=AS ).*?$/gs)[0],
+            name: view
          };
       })[0];
    }
@@ -296,7 +298,7 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async dropView (params) {
-      const sql = `DROP VIEW \`${params.schema}\`.\`${params.view}\``;
+      const sql = `DROP VIEW "${params.schema}"."${params.view}"`;
       return await this.raw(sql);
    }
 
@@ -308,17 +310,11 @@ export class SQLiteClient extends AntaresCore {
     */
    async alterView (params) {
       const { view } = params;
-      let sql = `
-         USE \`${view.schema}\`; 
-         ALTER ALGORITHM = ${view.algorithm}${view.definer ? ` DEFINER=${view.definer}` : ''} 
-         SQL SECURITY ${view.security} 
-         VIEW \`${view.schema}\`.\`${view.oldName}\` AS ${view.sql} ${view.updateOption ? `WITH ${view.updateOption} CHECK OPTION` : ''}
-      `;
 
-      if (view.name !== view.oldName)
-         sql += `; RENAME TABLE \`${view.schema}\`.\`${view.oldName}\` TO \`${view.schema}\`.\`${view.name}\``;
-
-      return await this.raw(sql);
+      return await Promise.all([
+         this.dropView({ schema: view.schema, view: view.oldName }),
+         this.createView(view)
+      ]);
    }
 
    /**
@@ -328,7 +324,7 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async createView (params) {
-      const sql = `CREATE ALGORITHM = ${params.algorithm} ${params.definer ? `DEFINER=${params.definer} ` : ''}SQL SECURITY ${params.security} VIEW \`${params.schema}\`.\`${params.name}\` AS ${params.sql} ${params.updateOption ? `WITH ${params.updateOption} CHECK OPTION` : ''}`;
+      const sql = `CREATE VIEW "${params.schema}"."${params.name}" AS ${params.sql}`;
       return await this.raw(sql);
    }
 
diff --git a/src/main/main.js b/src/main/main.js
index dc742bfa..639d3c39 100644
--- a/src/main/main.js
+++ b/src/main/main.js
@@ -107,14 +107,14 @@ else {
       mainWindow = await createMainWindow();
       createAppMenu();
 
-      if (isDevelopment)
-         mainWindow.webContents.openDevTools();
+      // if (isDevelopment)
+      //    mainWindow.webContents.openDevTools();
 
-      process.on('uncaughtException', (error) => {
+      process.on('uncaughtException', error => {
          mainWindow.webContents.send('unhandled-exception', error);
       });
 
-      process.on('unhandledRejection', (error) => {
+      process.on('unhandledRejection', error => {
          mainWindow.webContents.send('unhandled-exception', error);
       });
    });

From f40e9c592eeffd204aba21a0a0767a0c523fca49 Mon Sep 17 00:00:00 2001
From: Fabio Di Stasio <fabio286@gmail.com>
Date: Fri, 19 Nov 2021 15:36:07 +0100
Subject: [PATCH 10/10] feat(SQLite): triggers management

---
 src/common/customizations/sqlite.js   | 71 +++------------------------
 src/main/libs/clients/SQLiteClient.js | 38 ++++++--------
 2 files changed, 23 insertions(+), 86 deletions(-)

diff --git a/src/common/customizations/sqlite.js b/src/common/customizations/sqlite.js
index a3f2e6e9..d72c5103 100644
--- a/src/common/customizations/sqlite.js
+++ b/src/common/customizations/sqlite.js
@@ -1,84 +1,27 @@
 module.exports = {
-   // Defaults
-   defaultPort: null,
-   defaultUser: null,
-   defaultDatabase: null,
    // Core
-   database: false,
-   collations: false,
-   engines: false,
-   connectionSchema: false,
    fileConnection: true,
-   // Tools
-   processesList: false,
-   usersManagement: false,
-   variables: false,
    // Structure
-   schemas: false,
-   tables: false,
-   views: false,
-   triggers: false,
-   triggerFunctions: false,
-   routines: false,
-   functions: false,
-   schedulers: false,
+   schemas: true,
+   tables: true,
+   views: true,
+   triggers: true,
    // Settings
    elementsWrapper: '',
    stringsWrapper: '"',
    tableAdd: true,
    viewAdd: true,
-   triggerAdd: false,
-   triggerFunctionAdd: false,
-   routineAdd: false,
-   functionAdd: false,
-   schedulerAdd: false,
-   databaseEdit: false,
+   triggerAdd: true,
    schemaEdit: false,
    tableSettings: true,
-   tableArray: false,
    tableRealCount: true,
    viewSettings: true,
-   triggerSettings: false,
-   triggerFunctionSettings: false,
-   routineSettings: false,
-   functionSettings: false,
-   schedulerSettings: false,
+   triggerSettings: true,
    indexes: true,
    foreigns: true,
    sortableFields: true,
-   unsigned: false,
    nullable: true,
    nullablePrimary: true,
-   zerofill: false,
-   tableOptions: false,
-   autoIncrement: false,
-   comment: false,
-   collation: false,
-   definer: false,
-   onUpdate: false,
-   viewAlgorithm: false,
-   viewSqlSecurity: false,
-   viewUpdateOption: false,
-   procedureDeterministic: false,
-   procedureDataAccess: false,
-   procedureSql: false,
-   procedureContext: false,
-   procedureLanguage: false,
-   functionDeterministic: false,
-   functionDataAccess: false,
-   functionSql: false,
-   functionContext: false,
-   functionLanguage: false,
-   triggerSql: false,
-   triggerStatementInCreation: false,
-   triggerMultipleEvents: false,
-   triggerTableInName: false,
-   triggerUpdateColumns: false,
-   triggerOnlyRename: false,
-   triggerEnableDisable: false,
-   triggerFunctionSql: false,
-   triggerFunctionlanguages: false,
-   parametersLength: false,
-   languages: false,
+   triggerSql: 'BEGIN\r\n\r\nEND',
    readOnlyMode: true
 };
diff --git a/src/main/libs/clients/SQLiteClient.js b/src/main/libs/clients/SQLiteClient.js
index 4b2ca6e8..d7d6bfcb 100644
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -71,7 +71,7 @@ export class SQLiteClient extends AntaresCore {
             tablesArr.push(...tables);
          }
 
-         let { rows: triggers } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='trigger' AND name NOT LIKE 'sqlite_%'`);
+         let { rows: triggers } = await this.raw(`SELECT * FROM "${db.name}".sqlite_master WHERE type='trigger'`);
          if (triggers.length) {
             triggers = triggers.map(trigger => {
                trigger.Db = db.name;
@@ -99,15 +99,8 @@ export class SQLiteClient extends AntaresCore {
             // TRIGGERS
             const remappedTriggers = triggersArr.filter(trigger => trigger.Db === db.name).map(trigger => {
                return {
-                  name: trigger.Trigger,
-                  statement: trigger.Statement,
-                  timing: trigger.Timing,
-                  definer: trigger.Definer,
-                  event: trigger.Event,
-                  table: trigger.Table,
-                  sqlMode: trigger.sql_mode,
-                  created: trigger.Created,
-                  charset: trigger.character_set_client
+                  name: trigger.name,
+                  table: trigger.tbl_name
                };
             });
 
@@ -310,11 +303,13 @@ export class SQLiteClient extends AntaresCore {
     */
    async alterView (params) {
       const { view } = params;
-
-      return await Promise.all([
-         this.dropView({ schema: view.schema, view: view.oldName }),
-         this.createView(view)
-      ]);
+      try {
+         await this.dropView({ schema: view.schema, view: view.oldName });
+         await this.createView(view);
+      }
+      catch (err) {
+         return Promise.reject(err);
+      }
    }
 
    /**
@@ -335,17 +330,16 @@ export class SQLiteClient extends AntaresCore {
     * @memberof SQLiteClient
     */
    async getTriggerInformations ({ schema, trigger }) {
-      const sql = `SHOW CREATE TRIGGER \`${schema}\`.\`${trigger}\``;
+      const sql = `SELECT "sql" FROM "${schema}".sqlite_master WHERE "type"='trigger' AND name='${trigger}'`;
       const results = await this.raw(sql);
 
       return results.rows.map(row => {
          return {
-            definer: row['SQL Original Statement'].match(/(?<=DEFINER=).*?(?=\s)/gs)[0],
-            sql: row['SQL Original Statement'].match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
-            name: row.Trigger,
-            table: row['SQL Original Statement'].match(/(?<=ON `).*?(?=`)/gs)[0],
-            activation: row['SQL Original Statement'].match(/(BEFORE|AFTER)/gs)[0],
-            event: row['SQL Original Statement'].match(/(INSERT|UPDATE|DELETE)/gs)[0]
+            sql: row.sql.match(/(BEGIN|begin)(.*)(END|end)/gs)[0],
+            name: trigger,
+            table: row.sql.match(/(?<=ON `).*?(?=`)/gs)[0],
+            activation: row.sql.match(/(BEFORE|AFTER)/gs)[0],
+            event: row.sql.match(/(INSERT|UPDATE|DELETE)/gs)[0]
          };
       })[0];
    }