chore(release): 0.5.0

Merge pull request #129 from toriphes/feat/db-import-export
feat(MySQL): db import export
2025-06-05 21:59:22 +02:00 · 2022-03-12 14:25:04 +01:00 · 2022-03-12 14:17:48 +01:00 · 2022-03-12 10:37:40 +01:00 · 2022-03-12 10:01:22 +01:00 · 2022-03-12 09:52:40 +01:00
61 changed files with 2869 additions and 235 deletions
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -138,6 +138,15 @@
      "contributions": [
        "translation"
      ]
+    },
+    {
+      "login": "raliqala",
+      "name": "Topollo",
+      "avatar_url": "https://avatars.githubusercontent.com/u/30502407?v=4",
+      "profile": "https://github.com/raliqala",
+      "contributions": [
+        "code"
+      ]
    }
  ],
  "contributorsPerLine": 7,
--- a/.github/workflows/build-win.yml
+++ b/.github/workflows/build-win.yml
@@ -8,7 +8,7 @@ jobs:

    strategy:
      matrix:
-        os: [windows-latest]
+        os: [windows-2019]

    steps:
      - name: Check out Git repository
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ thumbs.db
 NOTES.md
 *.txt
 package-lock.json
+*.heapsnapshot
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -2,8 +2,8 @@
  "version": "0.2.0",
  "configurations": [
    {
-      "cwd": "${workspaceFolder}",
      "name": "Electron: Main",
+      "cwd": "${workspaceFolder}",
      "port": 9222,
      "protocol": "inspector",
      "request": "attach",
@@ -18,7 +18,17 @@
      "sourceMaps": true,
      "type": "chrome",
      "webRoot": "${workspaceFolder}"
-    }
+    },
+    {
+      "name": "Electron: Worker",
+      "cwd": "${workspaceFolder}",
+      "port": 9224,
+      "protocol": "inspector",
+      "request": "attach",
+      "sourceMaps": true,
+      "type": "node",
+      "timeout": 1000000
+    },
  ],
  "compounds": [
      {
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,66 @@

 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

+## [0.5.0](https://github.com/Fabio286/antares/compare/v0.4.4...v0.5.0) (2022-03-12)
+
+
+### Features
+
+* delete dump file when the export is canceled ([d25c62b](https://github.com/Fabio286/antares/commit/d25c62b4da9480e040d0bfac8b76732a4c69a5f1))
+* initial db export implementation ([0de2321](https://github.com/Fabio286/antares/commit/0de232192076d1de827424c593ac9dff63903531))
+* initial mysql import support ([4e9f8d1](https://github.com/Fabio286/antares/commit/4e9f8d16ee3c204d5f0c2bed081206f8b38207a6))
+* mysql export for trigger, views, schedulers, functions and routines ([b2a5b40](https://github.com/Fabio286/antares/commit/b2a5b40c03d56bced5a7968c3454f36060e56dd0))
+* **MySQL:** enhance export characters escaping ([3be826d](https://github.com/Fabio286/antares/commit/3be826df4b02ff0df0aa922d96755b31b7155784))
+* **MySQL:** support to multi spatial fields export ([4be55f3](https://github.com/Fabio286/antares/commit/4be55f3fe9bb48324b780734762f2ff6da2ccb61))
+* **PostgreSQL:** :sparkles: Postgress connection string feature for local and server connection string ([6305752](https://github.com/Fabio286/antares/commit/6305752ad117cc29c04bce3ce3df321f743cdc44))
+* **PostgreSQL:** :sparkles: Postgress connection string feature for local and server connection string ([f4a63ea](https://github.com/Fabio286/antares/commit/f4a63eae2aca2a84647a5027137614950aef1eac))
+* **UI:** auto-refresh schema at the end of the import process ([abf2b92](https://github.com/Fabio286/antares/commit/abf2b92e6e66b6668e698c5addf4e3c00ae5157b))
+* **UI:** better real-time import stats ([a6f5645](https://github.com/Fabio286/antares/commit/a6f5645a226454cc2c415311ac321ba3d4db4454))
+* **UI:** toggle tables checkbox by column on export modal ([1c4d5b0](https://github.com/Fabio286/antares/commit/1c4d5b05b3f94b3e7bef930aa7f89bdaa596c0b9))
+
+
+### Bug Fixes
+
+* **MySQL:** exception exporting empty procedures/functions ([ee415da](https://github.com/Fabio286/antares/commit/ee415da127d6d0de95aac901a2a01af863736344))
+* **MySQL:** export crash with large databases ([8cf738b](https://github.com/Fabio286/antares/commit/8cf738bac85698fddd0504eef7844279e8c11f44))
+* **MySQL:** missing functions and procedures definer escapes on exporter ([f0351e5](https://github.com/Fabio286/antares/commit/f0351e5b94830f9f52256096c2601b0ca9cd811d))
+* **MySQL:** missing initial delimiter for exported procedures ([1a9fc37](https://github.com/Fabio286/antares/commit/1a9fc3728580f789727256d7893ca4bb90c16a50))
+* **MySQL:** procedures exportation ([4276586](https://github.com/Fabio286/antares/commit/4276586e1141500401ff1ab570b29e485f459987))
+* sql parser hangs during import ([7a6bd8b](https://github.com/Fabio286/antares/commit/7a6bd8bdbd69e3b5fe265d0bb0be844699dd77c2))
+* wrong schema and table size on explore bar ([4479a96](https://github.com/Fabio286/antares/commit/4479a9600b5e59ef1bcf9135d661b4d7900a4bde))
+* wrong soft sort algorithm for numeric fields, closes [#199](https://github.com/Fabio286/antares/issues/199) ([763be85](https://github.com/Fabio286/antares/commit/763be8532d2b61d0b4d45e72343f6a2e5fee1db9))
+
+
+### Improvements
+
+* avoid to load schema elements if already loaded in export modal ([d9d3bf2](https://github.com/Fabio286/antares/commit/d9d3bf2bc9d39ce8eec5dffbecbf767fbcf47782))
+* **MySQL:** import performance improvement ([f444746](https://github.com/Fabio286/antares/commit/f444746f465ed0e8bd2e4c007faf17e167814278))
+* **MySQL:** import tasks managed with async queue ([bbe13f2](https://github.com/Fabio286/antares/commit/bbe13f27dc29f997898f8c13f36b5d582770b21d))
+* **MySQL:** improved several field types support on exporter ([1990d9a](https://github.com/Fabio286/antares/commit/1990d9a3d441f0e2075ac7e893d5b166275c48c0))
+* **MySQL:** prevent memory leak on large dump import ([f3759b6](https://github.com/Fabio286/antares/commit/f3759b65411a40d92b98208176cdf8e6dd8230ce))
+* **PostgreSQL:** :zap: Postgres connection update, better error handling and connection string accommodation. ([330a80f](https://github.com/Fabio286/antares/commit/330a80fe70b81f466f5e883029f42087b4b5c411))
+* split the export select query to avoid running out of memory ([409ed54](https://github.com/Fabio286/antares/commit/409ed54608ad402b63fcc26a6e724bc447ba89d2))
+* use fork() for the export process ([748d449](https://github.com/Fabio286/antares/commit/748d44977e76c6c8d6344df52e8e3ccfab84f670))
+* use fork() for the import process ([573ac6d](https://github.com/Fabio286/antares/commit/573ac6d42ef833f250d102e5b30ae6cf5877f330))
+
+### [0.4.4](https://github.com/Fabio286/antares/compare/v0.4.3...v0.4.4) (2022-02-27)
+
+
+### Features
+
+* execution notification for ROLLBACK and COMMIT ([76743e8](https://github.com/Fabio286/antares/commit/76743e8f7c02b824cb21540bfbcbe66ba43de8fa))
+* **MySQL:** manual commit mode ([4ed2f9a](https://github.com/Fabio286/antares/commit/4ed2f9a93937b4293436a64318b7d6ae3a0d93c2))
+* **PostgreSQL:** manual commit mode ([d81e091](https://github.com/Fabio286/antares/commit/d81e0911ab82fb75745ab11e67e867a00d8ac273))
+* reminder for uncommitted changes closing a tab ([5bfff64](https://github.com/Fabio286/antares/commit/5bfff649e92f6fe5aba4b16aa4c8d5a5a70b31b2))
+* **SQLite:** manual commit mode ([7dcd444](https://github.com/Fabio286/antares/commit/7dcd4441c49fafc0f47e12c2129708fe1092e1a4))
+
+
+### Bug Fixes
+
+* bigint support, closes [#197](https://github.com/Fabio286/antares/issues/197) ([b703955](https://github.com/Fabio286/antares/commit/b7039553ccaac4fd59e521530c4a053922854130))
+* **MySQL:** default value not displayed for DECIMAL fields ([fa3f3e1](https://github.com/Fabio286/antares/commit/fa3f3e1fd8101f19f18df71e90d60fd37cdddaee))
+* zero-padded bit fields beyond length ([265f28b](https://github.com/Fabio286/antares/commit/265f28b4d94cde4608a1d6d3d306824134808ec2))
+
 ### [0.4.3](https://github.com/Fabio286/antares/compare/v0.4.2...v0.4.3) (2022-01-30)


--- a/README.md
+++ b/README.md
@@ -31,10 +31,9 @@ We are actively working on it, hoping to provide new cool features, improvements
 - Query suggestions and auto complete.
 - Query history: search through the last 1000 queries.
 - SSH tunnel support.
+- Manual commit mode.
 - Dark and light theme.
 - Editor themes.
- Scratchpad.
- Secure password storage.

 ## Philosophy

@@ -133,6 +132,9 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
    <td align="center"><a href="https://github.com/wenj91"><img src="https://avatars.githubusercontent.com/u/12549338?v=4?s=100" width="100px;" alt=""/><br /><sub><b>文杰</b></sub></a><br /><a href="https://github.com/Fabio286/antares/commits?author=wenj91" title="Code">💻</a></td>
    <td align="center"><a href="https://github.com/goYou"><img src="https://avatars.githubusercontent.com/u/62732795?v=4?s=100" width="100px;" alt=""/><br /><sub><b>goYou</b></sub></a><br /><a href="#translation-goYou" title="Translation">🌍</a></td>
  </tr>
+  <tr>
+    <td align="center"><a href="https://github.com/raliqala"><img src="https://avatars.githubusercontent.com/u/30502407?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Topollo</b></sub></a><br /><a href="https://github.com/Fabio286/antares/commits?author=raliqala" title="Code">💻</a></td>
+  </tr>
 </table>

 <!-- markdownlint-restore -->
--- a/package.json
+++ b/package.json
@@ -1,20 +1,21 @@
 {
  "name": "antares",
  "productName": "Antares",
-  "version": "0.4.3",
+  "version": "0.5.0",
  "description": "A modern, fast and productivity driven SQL client with a focus in UX.",
  "license": "MIT",
  "repository": "https://github.com/Fabio286/antares.git",
  "scripts": {
    "debug": "npm run rebuild:electron && npm run debug-runner",
    "debug-runner": "node scripts/devRunner.js --remote-debug",
-    "compile": "npm run compile:main && npm run compile:renderer",
+    "compile": "npm run compile:main && npm run compile:workers && npm run compile:renderer",
    "compile:main": "webpack --mode=production --config webpack.main.config.js",
+    "compile:workers": "webpack --mode=production --config webpack.workers.config.js",
    "compile:renderer": "webpack --mode=production --config webpack.renderer.config.js",
    "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",
+    "rebuild:electron": "rimraf ./dist &&  npm run postinstall",
    "release": "standard-version",
    "release:pre": "npm run release -- --prerelease alpha",
    "postinstall": "electron-builder install-app-deps",
@@ -109,7 +110,7 @@
    "@turf/helpers": "^6.5.0",
    "@vscode/vscode-languagedetection": "^1.0.21",
    "ace-builds": "^1.4.13",
-    "better-sqlite3": "^7.4.4",
+    "better-sqlite3": "^7.5.0",
    "electron-log": "^4.4.1",
    "electron-store": "^8.0.1",
    "electron-updater": "^4.6.1",
@@ -136,10 +137,9 @@
    "all-contributors-cli": "^6.20.0",
    "babel-loader": "^8.2.3",
    "chalk": "^4.1.2",
-    "clean-webpack-plugin": "^4.0.0",
    "cross-env": "^7.0.2",
    "css-loader": "^6.5.0",
-    "electron": "^16.0.8",
+    "electron": "^17.0.1",
    "electron-builder": "^22.14.11",
    "electron-devtools-installer": "^3.2.0",
    "eslint": "^7.32.0",
@@ -154,6 +154,7 @@
    "node-loader": "^2.0.0",
    "playwright": "^1.18.1",
    "progress-webpack-plugin": "^1.0.12",
+    "rimraf": "^3.0.2",
    "sass": "^1.42.1",
    "sass-loader": "^12.3.0",
    "standard-version": "^9.3.1",
--- a/scripts/devRunner.js
+++ b/scripts/devRunner.js
@@ -12,7 +12,7 @@ const { spawn } = require('child_process');

 const mainConfig = require('../webpack.main.config');
 const rendererConfig = require('../webpack.renderer.config');
-// const workersConfig = require('../webpack.workers.config');
+const workersConfig = require('../webpack.workers.config');

 let electronProcess = null;
 let manualRestart = null;
@@ -64,7 +64,7 @@ async function restartElectron () {
 }

 function startMain () {
-   const webpackSetup = webpack(mainConfig);
+   const webpackSetup = webpack([mainConfig, workersConfig]);

   webpackSetup.compilers.forEach((compiler) => {
      const { name } = compiler;
--- a/src/common/FakerMethods.js
+++ b/src/common/FakerMethods.js
@@ -134,7 +134,7 @@ export default class {
         { name: 'phoneNumberFormat', group: 'phone', types: ['string'] },
         { name: 'phoneFormats', group: 'phone', types: ['string'] },

-         { name: 'number', group: 'random', types: ['string', 'number'], params: ['min', 'max'] },
+         { name: 'number', group: 'datatype', types: ['string', 'number'], params: ['min', 'max'] },
         { name: 'float', group: 'random', types: ['string', 'float'], params: ['min', 'max'] },
         { name: 'arrayElement', group: 'random', types: ['string'] },
         { name: 'arrayElements', group: 'random', types: ['string'] },
--- a/src/common/customizations/defaults.js
+++ b/src/common/customizations/defaults.js
@@ -38,6 +38,8 @@ module.exports = {
   databaseEdit: false,
   schemaEdit: false,
   schemaDrop: false,
+   schemaExport: false,
+   schemaImport: false,
   tableSettings: false,
   tableOptions: false,
   tableArray: false,
--- a/src/common/customizations/mysql.js
+++ b/src/common/customizations/mysql.js
@@ -34,6 +34,8 @@ module.exports = {
   schedulerAdd: true,
   schemaEdit: true,
   schemaDrop: true,
+   schemaExport: true,
+   schemaImport: true,
   tableSettings: true,
   viewSettings: true,
   triggerSettings: true,
--- a/src/common/customizations/postgresql.js
+++ b/src/common/customizations/postgresql.js
@@ -32,6 +32,8 @@ module.exports = {
   functionAdd: true,
   schemaDrop: true,
   databaseEdit: false,
+   schemaExport: false,
+   schemaImport: false,
   tableSettings: true,
   viewSettings: true,
   triggerSettings: true,
--- a/src/common/data-types/mysql.js
+++ b/src/common/data-types/mysql.js
@@ -121,7 +121,7 @@ module.exports = [
         {
            name: 'JSON',
            length: false,
-            collation: true,
+            collation: false,
            unsigned: false,
            zerofill: false
         }
--- a/src/common/fieldTypes.js
+++ b/src/common/fieldTypes.js
@@ -41,6 +41,7 @@ export const NUMBER = [

 export const FLOAT = [
   'FLOAT',
+   'DECIMAL',
   'DOUBLE',
   'REAL',
   'DOUBLE PRECISION',
--- a/src/common/libs/hexToBinary.js
+++ b/src/common/libs/hexToBinary.js
@@ -33,7 +33,7 @@ const lookup = {
 */
 export default function hexToBinary (hex) {
   let binary = '';
-   for (let i = 0, len = hex.length; i < len; i++)
+   for (let i = 0; i < hex.length; i++)
      binary += lookup[hex[i]];

   return binary;
--- a/src/common/libs/mimeFromHex.js
+++ b/src/common/libs/mimeFromHex.js
@@ -23,7 +23,7 @@ export function mimeFromHex (hex) {
            case '425A68':
               return { ext: 'bz2', mime: 'application/x-bzip2' };
            default:
-               switch (hex) { // 4 bites
+               switch (hex) { // 4 bytes
                  case '89504E47':
                     return { ext: 'png', mime: 'image/png' };
                  case '47494638':
--- a/src/common/libs/sqlParser.js
+++ b/src/common/libs/sqlParser.js
@@ -0,0 +1,93 @@
+import { Transform } from 'stream';
+
+export default class SqlParser extends Transform {
+   constructor (opts) {
+      opts = {
+         delimiter: ';',
+         encoding: 'utf8',
+         writableObjectMode: true,
+         readableObjectMode: true,
+         ...opts
+      };
+      super(opts);
+      this._buffer = '';
+      this._lastChar = '';
+      this._last9Chars = '';
+      this.encoding = opts.encoding;
+      this.delimiter = opts.delimiter;
+
+      this.isEscape = false;
+      this.currentQuote = null;
+      this.isDelimiter = false;
+   }
+
+   _transform (chunk, encoding, next) {
+      for (const char of chunk.toString(this.encoding)) {
+         this.checkEscape();
+         this._buffer += char;
+         this._lastChar = char;
+         this._last9Chars += char.trim().toLocaleLowerCase();
+
+         if (this._last9Chars.length > 9)
+            this._last9Chars = this._last9Chars.slice(-9);
+
+         this.checkNewDelimiter(char);
+         this.checkQuote(char);
+         const query = this.getQuery();
+
+         if (query)
+            this.push(query);
+      }
+      next();
+   }
+
+   checkEscape () {
+      if (this._buffer.length > 0) {
+         this.isEscape = this._lastChar === '\\'
+            ? !this.isEscape
+            : false;
+      }
+   }
+
+   checkNewDelimiter (char) {
+      if (this.currentQuote === null && this._last9Chars === 'delimiter') {
+         this.isDelimiter = true;
+         this._buffer = '';
+      }
+      else {
+         const isNewLine = char === '\n' || char === '\r';
+         if (isNewLine && this.isDelimiter) {
+            this.isDelimiter = false;
+            this.delimiter = this._buffer.trim();
+            this._buffer = '';
+         }
+      }
+   }
+
+   checkQuote (char) {
+      const isQuote = !this.isEscape && (char === '\'' || char === '"');
+      if (isQuote && this.currentQuote === char)
+         this.currentQuote = null;
+
+      else if (isQuote && this.currentQuote === null)
+         this.currentQuote = char;
+   }
+
+   getQuery () {
+      if (this.isDelimiter)
+         return false;
+
+      let query = false;
+      let demiliterFound = false;
+      if (this.currentQuote === null && this._buffer.length >= this.delimiter.length)
+         demiliterFound = this._last9Chars.slice(-this.delimiter.length) === this.delimiter;
+
+      if (demiliterFound) {
+         const parsedStr = this._buffer.trim();
+         query = parsedStr.slice(0, parsedStr.length - this.delimiter.length);
+         this._buffer = '';
+      }
+
+      return query;
+   }
+}
--- a/src/main/ipc-handlers/application.js
+++ b/src/main/ipc-handlers/application.js
@@ -1,4 +1,4 @@
-import { app, ipcMain } from 'electron';
+import { app, ipcMain, dialog } from 'electron';

 export default () => {
   ipcMain.on('close-app', () => {
@@ -9,4 +9,12 @@ export default () => {
      const key = false;
      event.returnValue = key;
   });
+
+   ipcMain.handle('showOpenDialog', (event, options) => {
+      return dialog.showOpenDialog(options);
+   });
+
+   ipcMain.handle('get-download-dir-path', () => {
+      return app.getPath('downloads');
+   });
 };
--- a/src/main/ipc-handlers/connection.js
+++ b/src/main/ipc-handlers/connection.js
@@ -40,7 +40,7 @@ export default connections => {
      }

      try {
-         const connection = await ClientsFactory.getConnection({
+         const connection = await ClientsFactory.getClient({
            client: conn.client,
            params
         });
@@ -100,7 +100,7 @@ export default connections => {
      }

      try {
-         const connection = ClientsFactory.getConnection({
+         const connection = ClientsFactory.getClient({
            client: conn.client,
            params,
            poolSize: 5
--- a/src/main/ipc-handlers/schema.js
+++ b/src/main/ipc-handlers/schema.js
@@ -1,7 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+import { fork } from 'child_process';
+import { ipcMain, dialog } from 'electron';

-import { ipcMain } from 'electron';
+// @TODO:  need some factories
+const isDevelopment = process.env.NODE_ENV !== 'production';

 export default connections => {
+   let exporter = null;
+   let importer = null;
+
   ipcMain.handle('create-schema', async (event, params) => {
      try {
         await connections[params.uid].createSchema(params);
@@ -37,9 +45,16 @@ export default connections => {

   ipcMain.handle('get-schema-collation', async (event, params) => {
      try {
-         const collation = await connections[params.uid].getDatabaseCollation(params);
+         const collation = await connections[params.uid].getDatabaseCollation(
+            params
+         );

-         return { status: 'success', response: collation.rows.length ? collation.rows[0].DEFAULT_COLLATION_NAME : '' };
+         return {
+            status: 'success',
+            response: collation.rows.length
+               ? collation.rows[0].DEFAULT_COLLATION_NAME
+               : ''
+         };
      }
      catch (err) {
         return { status: 'error', response: err.toString() };
@@ -48,7 +63,9 @@ export default connections => {

   ipcMain.handle('get-structure', async (event, params) => {
      try {
-         const structure = await connections[params.uid].getStructure(params.schemas);
+         const structure = await connections[params.uid].getStructure(
+            params.schemas
+         );

         return { status: 'success', response: structure };
      }
@@ -135,7 +152,7 @@ export default connections => {
      }
   });

-   ipcMain.handle('raw-query', async (event, { uid, query, schema, tabUid }) => {
+   ipcMain.handle('raw-query', async (event, { uid, query, schema, tabUid, autocommit }) => {
      if (!query) return;

      try {
@@ -144,6 +161,7 @@ export default connections => {
            details: true,
            schema,
            tabUid,
+            autocommit,
            comments: false
         });

@@ -154,6 +172,169 @@ export default connections => {
      }
   });

+   ipcMain.handle('export', (event, { uid, type, tables, ...rest }) => {
+      if (exporter !== null) return;
+
+      return new Promise((resolve, reject) => {
+         (async () => {
+            if (fs.existsSync(rest.outputFile)) { // If file exists ask for replace
+               const result = await dialog.showMessageBox({
+                  type: 'warning',
+                  message: `File ${rest.outputFile} already exists. Do you want to replace it?`,
+                  detail: 'A file with the same name already exists in the target folder. Replacing it will overwrite its current contents.',
+                  buttons: ['Cancel', 'Replace'],
+                  defaultId: 0,
+                  cancelId: 0
+               });
+
+               if (result.response !== 1) {
+                  resolve({
+                     type: 'error',
+                     response: 'Operation aborted'
+                  });
+                  return;
+               }
+            }
+
+            // Init exporter process
+            exporter = fork(isDevelopment ? './dist/exporter.js' : path.resolve(__dirname, './exporter.js'), [], {
+               execArgv: isDevelopment ? ['--inspect=9224'] : undefined
+            });
+            exporter.send({
+               type: 'init',
+               client: {
+                  name: type,
+                  config: await connections[uid].getDbConfig()
+               },
+               tables,
+               options: rest
+            });
+
+            // Exporter message listener
+            exporter.on('message', ({ type, payload }) => {
+               switch (type) {
+                  case 'export-progress':
+                     event.sender.send('export-progress', payload);
+                     break;
+                  case 'end':
+                     setTimeout(() => { // Ensures that writing process has finished
+                        exporter.kill();
+                        exporter = null;
+                     }, 2000);
+                     resolve({ status: 'success', response: payload });
+                     break;
+                  case 'cancel':
+                     exporter.kill();
+                     exporter = null;
+                     resolve({ status: 'error', response: 'Operation cancelled' });
+                     break;
+                  case 'error':
+                     exporter.kill();
+                     exporter = null;
+                     resolve({ status: 'error', response: payload });
+                     break;
+               }
+            });
+
+            exporter.on('exit', code => {
+               exporter = null;
+               resolve({ status: 'error', response: `Operation ended with code: ${code}` });
+            });
+         })();
+      });
+   });
+
+   ipcMain.handle('abort-export', async event => {
+      let willAbort = false;
+
+      if (exporter) {
+         const result = await dialog.showMessageBox({
+            type: 'warning',
+            message: 'Are you sure you want to abort the export',
+            buttons: ['Cancel', 'Abort'],
+            defaultId: 0,
+            cancelId: 0
+         });
+
+         if (result.response === 1) {
+            willAbort = true;
+            exporter.send({ type: 'cancel' });
+         }
+      }
+
+      return { status: 'success', response: { willAbort } };
+   });
+
+   ipcMain.handle('import-sql', async (event, options) => {
+      if (importer !== null) return;
+
+      return new Promise((resolve, reject) => {
+         (async () => {
+            const dbConfig = await connections[options.uid].getDbConfig();
+
+            // Init importer process
+            importer = fork(isDevelopment ? './dist/importer.js' : path.resolve(__dirname, './importer.js'), [], {
+               execArgv: isDevelopment ? ['--inspect=9224'] : undefined
+            });
+            importer.send({
+               type: 'init',
+               dbConfig,
+               options
+            });
+
+            // Importer message listener
+            importer.on('message', ({ type, payload }) => {
+               switch (type) {
+                  case 'import-progress':
+                     event.sender.send('import-progress', payload);
+                     break;
+                  case 'query-error':
+                     event.sender.send('query-error', payload);
+                     break;
+                  case 'end':
+                     setTimeout(() => { // Ensures that writing process has finished
+                        importer?.kill();
+                        importer = null;
+                     }, 2000);
+                     resolve({ status: 'success', response: payload });
+                     break;
+                  case 'cancel':
+                     importer.kill();
+                     importer = null;
+                     resolve({ status: 'error', response: 'Operation cancelled' });
+                     break;
+                  case 'error':
+                     importer.kill();
+                     importer = null;
+                     resolve({ status: 'error', response: payload });
+                     break;
+               }
+            });
+         })();
+      });
+   });
+
+   ipcMain.handle('abort-import-sql', async event => {
+      let willAbort = false;
+
+      if (importer) {
+         const result = await dialog.showMessageBox({
+            type: 'warning',
+            message: 'Are you sure you want to abort the import',
+            buttons: ['Cancel', 'Abort'],
+            defaultId: 0,
+            cancelId: 0
+         });
+
+         if (result.response === 1) {
+            willAbort = true;
+            importer.send({ type: 'cancel' });
+         }
+      }
+
+      return { status: 'success', response: { willAbort } };
+   });
+
   ipcMain.handle('kill-tab-query', async (event, { uid, tabUid }) => {
      if (!tabUid) return;

@@ -165,4 +346,40 @@ export default connections => {
         return { status: 'error', response: err.toString() };
      }
   });
+
+   ipcMain.handle('commit-tab', async (event, { uid, tabUid }) => {
+      if (!tabUid) return;
+
+      try {
+         await connections[uid].commitTab(tabUid);
+         return { status: 'success' };
+      }
+      catch (err) {
+         return { status: 'error', response: err.toString() };
+      }
+   });
+
+   ipcMain.handle('rollback-tab', async (event, { uid, tabUid }) => {
+      if (!tabUid) return;
+
+      try {
+         await connections[uid].rollbackTab(tabUid);
+         return { status: 'success' };
+      }
+      catch (err) {
+         return { status: 'error', response: err.toString() };
+      }
+   });
+
+   ipcMain.handle('destroy-connection-to-commit', async (event, { uid, tabUid }) => {
+      if (!tabUid) return;
+
+      try {
+         await connections[uid].destroyConnectionToCommit(tabUid);
+         return { status: 'success' };
+      }
+      catch (err) {
+         return { status: 'error', response: err.toString() };
+      }
+   });
 };
--- a/src/main/ipc-handlers/tables.js
+++ b/src/main/ipc-handlers/tables.js
@@ -149,7 +149,7 @@ export default (connections) => {
               }
            }
         }
-         else if ([...BIT].includes(params.type)) {
+         else if (BIT.includes(params.type)) {
            escapedParam = `b'${sqlEscaper(params.content)}'`;
            reload = true;
         }
--- a/src/main/libs/AntaresCore.js
+++ b/src/main/libs/AntaresCore.js
@@ -1,4 +1,10 @@
 'use strict';
+const queryLogger = sql => {
+   // Remove comments, newlines and multiple spaces
+   const escapedSql = sql.replace(/(\/\*(.|[\r\n])*?\*\/)|(--(.*|[\r\n]))/gm, '').replace(/\s\s+/g, ' ');
+   console.log(escapedSql);
+};
+
 /**
 * As Simple As Possible Query Builder Core
 *
@@ -17,7 +23,7 @@ export class AntaresCore {
      this._poolSize = args.poolSize || false;
      this._connection = null;
      this._ssh = null;
-      this._logger = args.logger || console.log;
+      this._logger = args.logger || queryLogger;

      this._queryDefaults = {
         schema: '',
--- a/src/main/libs/ClientsFactory.js
+++ b/src/main/libs/ClientsFactory.js
@@ -2,13 +2,6 @@
 import { MySQLClient } from './clients/MySQLClient';
 import { PostgreSQLClient } from './clients/PostgreSQLClient';
 import { SQLiteClient } from './clients/SQLiteClient';
-
-const queryLogger = sql => {
-   // Remove comments, newlines and multiple spaces
-   const escapedSql = sql.replace(/(\/\*(.|[\r\n])*?\*\/)|(--(.*|[\r\n]))/gm, '').replace(/\s\s+/g, ' ');
-   console.log(escapedSql);
-};
-
 export class ClientsFactory {
   /**
    * Returns a database connection based on received args.
@@ -29,9 +22,7 @@ export class ClientsFactory {
    * @returns Database Connection
    * @memberof ClientsFactory
    */
-   static getConnection (args) {
-      args.logger = queryLogger;
-
+   static getClient (args) {
      switch (args.client) {
         case 'mysql':
         case 'maria':
--- a/src/main/libs/clients/MySQLClient.js
+++ b/src/main/libs/clients/MySQLClient.js
@@ -10,6 +10,7 @@ export class MySQLClient extends AntaresCore {

      this._schema = null;
      this._runningConnections = new Map();
+      this._connectionsToCommit = new Map();

      this.types = {
         0: 'DECIMAL',
@@ -100,10 +101,32 @@ export class MySQLClient extends AntaresCore {
         .filter(_type => _type.name === type.toUpperCase())[0];
   }

+   _reducer (acc, curr) {
+      const type = typeof curr;
+
+      switch (type) {
+         case 'number':
+         case 'string':
+            return [...acc, curr];
+         case 'object':
+            if (Array.isArray(curr))
+               return [...acc, ...curr];
+            else {
+               const clausoles = [];
+               for (const key in curr)
+                  clausoles.push(`\`${key}\` ${curr[key]}`);
+
+               return clausoles;
+            }
+      }
+   }
+
   /**
+    *
+    * @returns dbConfig
    * @memberof MySQLClient
    */
-   async connect () {
+   async getDbConfig () {
      delete this._params.application_name;

      const dbConfig = {
@@ -111,7 +134,9 @@ export class MySQLClient extends AntaresCore {
         port: this._params.port,
         user: this._params.user,
         password: this._params.password,
-         ssl: null
+         ssl: null,
+         supportBigNumbers: true,
+         bigNumberStrings: true
      };

      if (this._params.schema?.length) dbConfig.database = this._params.schema;
@@ -134,22 +159,56 @@ export class MySQLClient extends AntaresCore {
         }
      }

-      if (!this._poolSize) {
-         this._connection = await mysql.createConnection(dbConfig);
+      return dbConfig;
+   }
+
+   /**
+    * @memberof MySQLClient
+    */
+   async connect () {
+      if (!this._poolSize)
+         this._connection = await this.getConnection();
+      else
+         this._connection = await this.getConnectionPool();
+   }
+
+   /**
+    * @memberof MySQLClient
+    */
+   destroy () {
+      this._connection.end();
+      if (this._ssh) this._ssh.close();
+   }
+
+   async getConnection () {
+      const dbConfig = await this.getDbConfig();
+      const connection = await mysql.createConnection({
+         ...dbConfig,
+         typeCast: (field, next) => {
+            if (field.type === 'DATETIME')
+               return field.string();
+            else
+               return next();
+         }
+      });

      // ANSI_QUOTES check
-         const res = await this.getVariable('sql_mode', 'global');
-         const sqlMode = res?.value.split(',');
+      const [res] = await connection.query('SHOW GLOBAL VARIABLES LIKE \'%sql_mode%\'');
+      const sqlMode = res[0]?.Variable_name?.split(',');
      const hasAnsiQuotes = sqlMode.includes('ANSI_QUOTES');

      if (this._params.readonly)
-            await this.raw('SET SESSION TRANSACTION READ ONLY');
+         await connection.query('SET SESSION TRANSACTION READ ONLY');

      if (hasAnsiQuotes)
-            await this.raw(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);
+         await connection.query(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);
+
+      return connection;
   }
-      else {
-         this._connection = mysql.createPool({
+
+   async getConnectionPool () {
+      const dbConfig = await this.getDbConfig();
+      const connection = mysql.createPool({
         ...dbConfig,
         connectionLimit: this._poolSize,
         typeCast: (field, next) => {
@@ -161,29 +220,22 @@ export class MySQLClient extends AntaresCore {
      });

      // ANSI_QUOTES check
-         const res = await this.getVariable('sql_mode', 'global');
-         const sqlMode = res?.value.split(',');
+      const [res] = await connection.query('SHOW GLOBAL VARIABLES LIKE \'%sql_mode%\'');
+      const sqlMode = res[0]?.Variable_name?.split(',');
      const hasAnsiQuotes = sqlMode.includes('ANSI_QUOTES');

      if (hasAnsiQuotes)
-            await this._connection.query(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);
+         await connection.query(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);

-         this._connection.on('connection', connection => {
+      connection.on('connection', conn => {
         if (this._params.readonly)
-               connection.query('SET SESSION TRANSACTION READ ONLY');
+            conn.query('SET SESSION TRANSACTION READ ONLY');

         if (hasAnsiQuotes)
-               connection.query(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);
+            conn.query(`SET SESSION sql_mode = "${sqlMode.filter(m => m !== 'ANSI_QUOTES').join(',')}"`);
      });
-      }
-   }

-   /**
-    * @memberof MySQLClient
-    */
-   destroy () {
-      this._connection.end();
-      if (this._ssh) this._ssh.close();
+      return connection;
   }

   /**
@@ -254,7 +306,7 @@ export class MySQLClient extends AntaresCore {
                     break;
               }

-               const tableSize = table.Data_length + table.Index_length;
+               const tableSize = Number(table.Data_length) + Number(table.Index_length);
               schemaSize += tableSize;

               return {
@@ -395,7 +447,7 @@ export class MySQLClient extends AntaresCore {
               return acc;
            }, '')
            .replaceAll('\n', '')
-            .split(',')
+            .split(/,\s?(?![^(]*\))/)
            .map(f => {
               try {
                  const fieldArr = f.trim().split(' ');
@@ -440,6 +492,10 @@ export class MySQLClient extends AntaresCore {
            ? field.COLUMN_TYPE.match(/\(([^)]+)\)/)[0].slice(1, -1)
            : null;

+         const defaultValue = (remappedFields && remappedFields[field.COLUMN_NAME])
+            ? remappedFields[field.COLUMN_NAME].default
+            : field.COLUMN_DEFAULT;
+
         return {
            name: field.COLUMN_NAME,
            key: field.COLUMN_KEY.toLowerCase(),
@@ -458,10 +514,11 @@ export class MySQLClient extends AntaresCore {
            unsigned: field.COLUMN_TYPE.includes('unsigned'),
            zerofill: field.COLUMN_TYPE.includes('zerofill'),
            order: field.ORDINAL_POSITION,
-            default: (remappedFields && remappedFields[field.COLUMN_NAME]) ? remappedFields[field.COLUMN_NAME].default : field.COLUMN_DEFAULT,
+            default: defaultValue,
            charset: field.CHARACTER_SET_NAME,
            collation: field.COLLATION_NAME,
            autoIncrement: field.EXTRA.includes('auto_increment'),
+            generated: field.EXTRA.toLowerCase().includes('generated'),
            onUpdate: field.EXTRA.toLowerCase().includes('on update')
               ? field.EXTRA.substr(field.EXTRA.indexOf('on update') + 9, field.EXTRA.length).trim()
               : '',
@@ -1272,6 +1329,36 @@ export class MySQLClient extends AntaresCore {
         return await this.killProcess(id);
   }

+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async commitTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection)
+         return await connection.query('COMMIT');
+   }
+
+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async rollbackTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection)
+         return await connection.query('ROLLBACK');
+   }
+
+   destroyConnectionToCommit (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         connection.destroy();
+         this._connectionsToCommit.delete(tabUid);
+      }
+   }
+
   /**
    * CREATE TABLE
    *
@@ -1536,7 +1623,7 @@ export class MySQLClient extends AntaresCore {
      let insertRaw = '';

      if (this._query.insert.length) {
-         const fieldsList = Object.keys(this._query.insert[0]);
+         const fieldsList = Object.keys(this._query.insert[0]).map(col => '`' + col + '`');
         const rowsList = this._query.insert.map(el => `(${Object.values(el).join(', ')})`);

         insertRaw = `(${fieldsList.join(', ')}) VALUES ${rowsList.join(', ')} `;
@@ -1576,6 +1663,7 @@ export class MySQLClient extends AntaresCore {
         details: false,
         split: true,
         comments: true,
+         autocommit: true,
         ...args
      };

@@ -1590,8 +1678,21 @@ export class MySQLClient extends AntaresCore {
            .filter(Boolean)
            .map(q => q.trim())
         : [sql];
+
+      let connection;
      const isPool = typeof this._connection.getConnection === 'function';
-      const connection = isPool ? await this._connection.getConnection() : this._connection;
+
+      if (!args.autocommit && args.tabUid) { // autocommit OFF
+         if (this._connectionsToCommit.has(args.tabUid))
+            connection = this._connectionsToCommit.get(args.tabUid);
+         else {
+            connection = await this.getConnection();
+            await connection.query('SET SESSION autocommit=0');
+            this._connectionsToCommit.set(args.tabUid, connection);
+         }
+      }
+      else// autocommit ON
+         connection = isPool ? await this._connection.getConnection() : this._connection;

      if (args.tabUid && isPool)
         this._runningConnections.set(args.tabUid, connection.connection.connectionId);
@@ -1656,7 +1757,7 @@ export class MySQLClient extends AntaresCore {
                           });
                        }
                        catch (err) {
-                           if (isPool) {
+                           if (isPool && args.autocommit) {
                              connection.release();
                              this._runningConnections.delete(args.tabUid);
                           }
@@ -1668,7 +1769,7 @@ export class MySQLClient extends AntaresCore {
                           keysArr = keysArr ? [...keysArr, ...response] : response;
                        }
                        catch (err) {
-                           if (isPool) {
+                           if (isPool && args.autocommit) {
                              connection.release();
                              this._runningConnections.delete(args.tabUid);
                           }
@@ -1686,7 +1787,7 @@ export class MySQLClient extends AntaresCore {
                  keys: keysArr
               });
            }).catch((err) => {
-               if (isPool) {
+               if (isPool && args.autocommit) {
                  connection.release();
                  this._runningConnections.delete(args.tabUid);
               }
@@ -1697,7 +1798,7 @@ export class MySQLClient extends AntaresCore {
         resultsArr.push({ rows, report, fields, keys, duration });
      }

-      if (isPool) {
+      if (isPool && args.autocommit) {
         connection.release();
         this._runningConnections.delete(args.tabUid);
      }
--- a/src/main/libs/clients/PostgreSQLClient.js
+++ b/src/main/libs/clients/PostgreSQLClient.js
@@ -9,7 +9,6 @@ function pgToString (value) {
   return value.toString();
 }

-types.setTypeParser(20, a => parseInt(a));// bigint string to number
 types.setTypeParser(1082, pgToString); // date
 types.setTypeParser(1083, pgToString); // time
 types.setTypeParser(1114, pgToString); // timestamp
@@ -22,6 +21,7 @@ export class PostgreSQLClient extends AntaresCore {

      this._schema = null;
      this._runningConnections = new Map();
+      this._connectionsToCommit = new Map();

      this.types = {};
      for (const key in types.builtins)
@@ -71,9 +71,11 @@ export class PostgreSQLClient extends AntaresCore {
   }

   /**
+    *
+    * @returns dbConfig
    * @memberof PostgreSQLClient
    */
-   async connect () {
+   async getDbConfig () {
      const dbConfig = {
         host: this._params.host,
         port: this._params.port,
@@ -102,24 +104,43 @@ export class PostgreSQLClient extends AntaresCore {
         }
      }

-      if (!this._poolSize) {
+      return dbConfig;
+   }
+
+   /**
+    * @memberof PostgreSQLClient
+    */
+   async connect () {
+      if (!this._poolSize)
+         this._connection = await this.getConnection();
+      else
+         this._connection = await this.getConnectionPool();
+   }
+
+   async getConnection () {
+      const dbConfig = await this.getDbConfig();
      const client = new Client(dbConfig);
      await client.connect();
-         this._connection = client;
+      const connection = client;

      if (this._params.readonly)
-            await this.raw('SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY');
+         await connection.query('SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY');
+
+      return connection;
   }
-      else {
+
+   async getConnectionPool () {
+      const dbConfig = await this.getDbConfig();
      const pool = new Pool({ ...dbConfig, max: this._poolSize });
-         this._connection = pool;
+      const connection = pool;

      if (this._params.readonly) {
-            this._connection.on('connect', connection => {
-               connection.query('SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY');
+         connection.on('connect', conn => {
+            conn.query('SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY');
         });
      }
-      }
+
+      return connection;
   }

   /**
@@ -217,7 +238,7 @@ export class PostgreSQLClient extends AntaresCore {
         if (schemas.has(db.database)) {
            // TABLES
            const remappedTables = tablesArr.filter(table => table.Db === db.database).map(table => {
-               const tableSize = +table.data_length + table.index_length;
+               const tableSize = Number(table.data_length) + Number(table.index_length);
               schemaSize += tableSize;

               return {
@@ -1118,6 +1139,40 @@ export class PostgreSQLClient extends AntaresCore {
         return await this.raw(`SELECT pg_cancel_backend(${id})`);
   }

+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async commitTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         await connection.query('COMMIT');
+         return this.destroyConnectionToCommit(tabUid);
+      }
+   }
+
+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async rollbackTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         await connection.query('ROLLBACK');
+         return this.destroyConnectionToCommit(tabUid);
+      }
+   }
+
+   destroyConnectionToCommit (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         connection.end();
+         this._connectionsToCommit.delete(tabUid);
+      }
+   }
+
   /**
    * CREATE TABLE
    *
@@ -1429,6 +1484,7 @@ export class PostgreSQLClient extends AntaresCore {
         details: false,
         split: true,
         comments: true,
+         autocommit: true,
         ...args
      };

@@ -1443,8 +1499,20 @@ export class PostgreSQLClient extends AntaresCore {
            .map(q => q.trim())
         : [sql];

+      let connection;
      const isPool = this._connection instanceof Pool;
-      const connection = isPool ? await this._connection.connect() : this._connection;
+
+      if (!args.autocommit && args.tabUid) { // autocommit OFF
+         if (this._connectionsToCommit.has(args.tabUid))
+            connection = this._connectionsToCommit.get(args.tabUid);
+         else {
+            connection = await this.getConnection();
+            await connection.query('START TRANSACTION');
+            this._connectionsToCommit.set(args.tabUid, connection);
+         }
+      }
+      else// autocommit ON
+         connection = isPool ? await this._connection.connect() : this._connection;

      if (args.tabUid && isPool)
         this._runningConnections.set(args.tabUid, connection.processID);
@@ -1554,7 +1622,7 @@ export class PostgreSQLClient extends AntaresCore {
                              });
                           }
                           catch (err) {
-                              if (isPool) {
+                              if (isPool && args.autocommit) {
                                 connection.release();
                                 this._runningConnections.delete(args.tabUid);
                              }
@@ -1566,7 +1634,7 @@ export class PostgreSQLClient extends AntaresCore {
                              keysArr = keysArr ? [...keysArr, ...response] : response;
                           }
                           catch (err) {
-                              if (isPool) {
+                              if (isPool && args.autocommit) {
                                 connection.release();
                                 this._runningConnections.delete(args.tabUid);
                              }
@@ -1585,7 +1653,7 @@ export class PostgreSQLClient extends AntaresCore {
                  });
               }
               catch (err) {
-                  if (isPool) {
+                  if (isPool && args.autocommit) {
                     connection.release();
                     this._runningConnections.delete(args.tabUid);
                  }
@@ -1597,7 +1665,7 @@ export class PostgreSQLClient extends AntaresCore {
         resultsArr.push({ rows, report, fields, keys, duration });
      }

-      if (isPool) {
+      if (isPool && args.autocommit) {
         connection.release();
         this._runningConnections.delete(args.tabUid);
      }
--- a/src/main/libs/clients/SQLiteClient.js
+++ b/src/main/libs/clients/SQLiteClient.js
@@ -9,6 +9,7 @@ export class SQLiteClient extends AntaresCore {
      super(args);

      this._schema = null;
+      this._connectionsToCommit = new Map();
   }

   _getTypeInfo (type) {
@@ -21,7 +22,11 @@ export class SQLiteClient extends AntaresCore {
    * @memberof SQLiteClient
    */
   async connect () {
-      this._connection = sqlite(this._params.databasePath, {
+      this._connection = this.getConnection();
+   }
+
+   getConnection () {
+      return sqlite(this._params.databasePath, {
         fileMustExist: true,
         readonly: this._params.readonly
      });
@@ -158,7 +163,7 @@ export class SQLiteClient extends AntaresCore {
            nullable: !field.notnull,
            unsigned: null,
            zerofill: null,
-            order: field.cid + 1,
+            order: typeof field.cid === 'string' ? +field.cid + 1 : field.cid + 1,
            default: field.dflt_value,
            charset: null,
            collation: null,
@@ -446,6 +451,40 @@ export class SQLiteClient extends AntaresCore {

   async killProcess () {}

+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async commitTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         connection.prepare('COMMIT').run();
+         return this.destroyConnectionToCommit(tabUid);
+      }
+   }
+
+   /**
+    *
+    * @param {string} tabUid
+    * @returns {Promise<null>}
+    */
+   async rollbackTab (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         connection.prepare('ROLLBACK').run();
+         return this.destroyConnectionToCommit(tabUid);
+      }
+   }
+
+   destroyConnectionToCommit (tabUid) {
+      const connection = this._connectionsToCommit.get(tabUid);
+      if (connection) {
+         connection.close();
+         this._connectionsToCommit.delete(tabUid);
+      }
+   }
+
   /**
    * CREATE TABLE
    *
@@ -666,6 +705,7 @@ export class SQLiteClient extends AntaresCore {
         details: false,
         split: true,
         comments: true,
+         autocommit: true,
         ...args
      };

@@ -679,7 +719,20 @@ export class SQLiteClient extends AntaresCore {
            .filter(Boolean)
            .map(q => q.trim())
         : [sql];
-      const connection = this._connection;
+
+      let connection;
+
+      if (!args.autocommit && args.tabUid) { // autocommit OFF
+         if (this._connectionsToCommit.has(args.tabUid))
+            connection = this._connectionsToCommit.get(args.tabUid);
+         else {
+            connection = this.getConnection();
+            connection.prepare('BEGIN TRANSACTION').run();
+            this._connectionsToCommit.set(args.tabUid, connection);
+         }
+      }
+      else// autocommit ON
+         connection = this._connection;

      for (const query of queries) {
         if (!query) continue;
--- a/src/main/libs/exporters/BaseExporter.js
+++ b/src/main/libs/exporters/BaseExporter.js
@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import EventEmitter from 'events';
+
+export class BaseExporter extends EventEmitter {
+   constructor (tables, options) {
+      super();
+      this._tables = tables;
+      this._options = options;
+      this._isCancelled = false;
+      this._outputStream = fs.createWriteStream(this._options.outputFile, {
+         flags: 'w'
+      });
+      this._state = {};
+
+      this._outputStream.once('error', err => {
+         this._isCancelled = true;
+         this.emit('error', err);
+      });
+   }
+
+   async run () {
+      try {
+         this.emit('start', this);
+         await this.dump();
+      }
+      catch (err) {
+         this.emit('error', err);
+         throw err;
+      }
+      finally {
+         this._outputStream.end();
+         this.emit('end');
+      }
+   }
+
+   get isCancelled () {
+      return this._isCancelled;
+   }
+
+   get outputFile () {
+      return this._options.outputFile;
+   }
+
+   outputFileExists () {
+      return fs.existsSync(this._options.outputFile);
+   }
+
+   cancel () {
+      this._isCancelled = true;
+      this.emit('cancel');
+      this.emitUpdate({ op: 'cancelling' });
+   }
+
+   emitUpdate (state) {
+      this.emit('progress', { ...this._state, ...state });
+   }
+
+   writeString (data) {
+      if (this._isCancelled) return;
+
+      try {
+         fs.accessSync(this._options.outputFile);
+      }
+      catch (err) {
+         this._isCancelled = true;
+
+         const fileName = path.basename(this._options.outputFile);
+         this.emit('error', `The file ${fileName} is not accessible`);
+      }
+      this._outputStream.write(data);
+   }
+
+   dump () {
+      throw new Error('Exporter must implement the "dump" method');
+   }
+}
--- a/src/main/libs/exporters/sql/MysqlExporter.js
+++ b/src/main/libs/exporters/sql/MysqlExporter.js
@@ -0,0 +1,412 @@
+import { SqlExporter } from './SqlExporter';
+import { BLOB, BIT, DATE, DATETIME, FLOAT, SPATIAL, IS_MULTI_SPATIAL, NUMBER } from 'common/fieldTypes';
+import hexToBinary from 'common/libs/hexToBinary';
+import { getArrayDepth } from 'common/libs/getArrayDepth';
+import moment from 'moment';
+import { lineString, point, polygon } from '@turf/helpers';
+
+export default class MysqlExporter extends SqlExporter {
+   async getSqlHeader () {
+      let dump = await super.getSqlHeader();
+      dump += `
+
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+SET NAMES utf8mb4;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;`;
+
+      return dump;
+   }
+
+   async getFooter () {
+      const footer = await super.getFooter();
+
+      return `/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+
+${footer}
+`;
+   }
+
+   async getCreateTable (tableName) {
+      const { rows } = await this._client.raw(
+         `SHOW CREATE TABLE \`${this.schemaName}\`.\`${tableName}\``
+      );
+
+      if (rows.length !== 1) return '';
+
+      const col = 'Create View' in rows[0] ? 'Create View' : 'Create Table';
+
+      return rows[0][col] + ';';
+   }
+
+   getDropTable (tableName) {
+      return `DROP TABLE IF EXISTS \`${tableName}\`;`;
+   }
+
+   async * getTableInsert (tableName) {
+      let rowCount = 0;
+      let sqlStr = '';
+
+      const countResults = await this._client.raw(`SELECT COUNT(1) as count FROM \`${this.schemaName}\`.\`${tableName}\``);
+      if (countResults.rows.length === 1) rowCount = countResults.rows[0].count;
+
+      if (rowCount > 0) {
+         let queryLength = 0;
+         let rowsWritten = 0;
+         let rowIndex = 0;
+         const { sqlInsertDivider, sqlInsertAfter } = this._options;
+         const columns = await this._client.getTableColumns({
+            table: tableName,
+            schema: this.schemaName
+         });
+
+         const notGeneratedColumns = columns.filter(col => !col.generated);
+         const columnNames = notGeneratedColumns.map(col => '`' + col.name + '`');
+         const insertStmt = `INSERT INTO \`${tableName}\` (${columnNames.join(
+            ', '
+         )}) VALUES`;
+
+         sqlStr += `LOCK TABLES \`${tableName}\` WRITE;\n`;
+         sqlStr += `/*!40000 ALTER TABLE \`${tableName}\` DISABLE KEYS */;`;
+         sqlStr += '\n\n';
+         yield sqlStr;
+
+         yield insertStmt;
+
+         const stream = await this._queryStream(
+            `SELECT ${columnNames.join(', ')} FROM \`${this.schemaName}\`.\`${tableName}\``
+         );
+
+         for await (const row of stream) {
+            if (this.isCancelled) {
+               stream.destroy();
+               yield null;
+               return;
+            }
+
+            let sqlInsertString = '';
+
+            if (
+               (sqlInsertDivider === 'bytes' && queryLength >= sqlInsertAfter * 1024) ||
+               (sqlInsertDivider === 'rows' && rowsWritten === sqlInsertAfter)
+            ) {
+               sqlInsertString += `;\n${insertStmt}\n\t(`;
+               queryLength = 0;
+               rowsWritten = 0;
+            }
+            else if (parseInt(rowIndex) === 0) sqlInsertString += '\n\t(';
+            else sqlInsertString += ',\n\t(';
+
+            for (const i in notGeneratedColumns) {
+               const column = notGeneratedColumns[i];
+               const val = row[column.name];
+
+               if (val === null) sqlInsertString += 'NULL';
+               else if (DATE.includes(column.type)) {
+                  sqlInsertString += moment(val).isValid()
+                     ? this.escapeAndQuote(moment(val).format('YYYY-MM-DD'))
+                     : val;
+               }
+               else if (DATETIME.includes(column.type)) {
+                  let datePrecision = '';
+                  for (let i = 0; i < column.precision; i++)
+                     datePrecision += i === 0 ? '.S' : 'S';
+
+                  sqlInsertString += moment(val).isValid()
+                     ? this.escapeAndQuote(moment(val).format(`YYYY-MM-DD HH:mm:ss${datePrecision}`))
+                     : this.escapeAndQuote(val);
+               }
+               else if (BIT.includes(column.type))
+                  sqlInsertString += `b'${hexToBinary(Buffer.from(val).toString('hex'))}'`;
+               else if (BLOB.includes(column.type))
+                  sqlInsertString += `X'${val.toString('hex').toUpperCase()}'`;
+               else if (NUMBER.includes(column.type))
+                  sqlInsertString += val;
+               else if (FLOAT.includes(column.type))
+                  sqlInsertString += parseFloat(val);
+               else if (SPATIAL.includes(column.type)) {
+                  let geoJson;
+                  if (IS_MULTI_SPATIAL.includes(column.type)) {
+                     const features = [];
+                     for (const element of val)
+                        features.push(this.getMarkers(element));
+
+                     geoJson = {
+                        type: 'FeatureCollection',
+                        features
+                     };
+                  }
+                  else
+                     geoJson = this._getGeoJSON(val);
+
+                  sqlInsertString += `ST_GeomFromGeoJSON('${JSON.stringify(geoJson)}')`;
+               }
+               else if (val === '') sqlInsertString += '\'\'';
+               else {
+                  sqlInsertString += typeof val === 'string'
+                     ? this.escapeAndQuote(val)
+                     : typeof val === 'object'
+                        ? this.escapeAndQuote(JSON.stringify(val))
+                        : val;
+               }
+
+               if (parseInt(i) !== notGeneratedColumns.length - 1)
+                  sqlInsertString += ', ';
+            }
+
+            sqlInsertString += ')';
+
+            queryLength += sqlInsertString.length;
+            rowsWritten++;
+            rowIndex++;
+            yield sqlInsertString;
+         }
+
+         sqlStr = ';\n\n';
+         sqlStr += `/*!40000 ALTER TABLE \`${tableName}\` ENABLE KEYS */;\n`;
+         sqlStr += 'UNLOCK TABLES;';
+
+         yield sqlStr;
+      }
+   }
+
+   async getViews () {
+      const { rows: views } = await this._client.raw(
+         `SHOW TABLE STATUS FROM \`${this.schemaName}\` WHERE Comment = 'VIEW'`
+      );
+      let sqlString = '';
+
+      for (const view of views) {
+         sqlString += `DROP VIEW IF EXISTS \`${view.Name}\`;\n`;
+         const viewSyntax = await this.getCreateTable(view.Name);
+         sqlString += viewSyntax.replaceAll('`' + this.schemaName + '`.', '');
+         sqlString += '\n';
+      }
+
+      return sqlString;
+   }
+
+   async getTriggers () {
+      const { rows: triggers } = await this._client.raw(
+         `SHOW TRIGGERS FROM \`${this.schemaName}\``
+      );
+      const generatedTables = this._tables
+         .filter(t => t.includeStructure)
+         .map(t => t.table);
+
+      let sqlString = '';
+
+      for (const trigger of triggers) {
+         const {
+            Trigger: name,
+            Timing: timing,
+            Event: event,
+            Table: table,
+            Statement: statement,
+            sql_mode: sqlMode
+         } = trigger;
+
+         if (!generatedTables.includes(table)) continue;
+
+         const definer = this.getEscapedDefiner(trigger.Definer);
+         sqlString += '/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;;\n';
+         sqlString += `/*!50003 SET SQL_MODE="${sqlMode}" */;\n`;
+         sqlString += 'DELIMITER ;;\n';
+         sqlString += '/*!50003 CREATE*/ ';
+         sqlString += `/*!50017 DEFINER=${definer}*/ `;
+         sqlString += `/*!50003 TRIGGER \`${name}\` ${timing} ${event} ON \`${table}\` FOR EACH ROW ${statement}*/;;\n`;
+         sqlString += 'DELIMITER ;\n';
+         sqlString += '/*!50003 SET SQL_MODE=@OLD_SQL_MODE */;\n\n';
+      }
+
+      return sqlString;
+   }
+
+   async getSchedulers () {
+      const { rows: schedulers } = await this._client.raw(
+         `SELECT *, EVENT_SCHEMA AS \`Db\`, EVENT_NAME AS \`Name\` FROM information_schema.\`EVENTS\` WHERE EVENT_SCHEMA = '${this.schemaName}'`
+      );
+      let sqlString = '';
+
+      for (const scheduler of schedulers) {
+         const {
+            EVENT_NAME: name,
+            SQL_MODE: sqlMode,
+            EVENT_TYPE: type,
+            INTERVAL_VALUE: intervalValue,
+            INTERVAL_FIELD: intervalField,
+            STARTS: starts,
+            ENDS: ends,
+            EXECUTE_AT: at,
+            ON_COMPLETION: onCompletion,
+            STATUS: status,
+            EVENT_DEFINITION: definition
+         } = scheduler;
+
+         const definer = this.getEscapedDefiner(scheduler.DEFINER);
+         const comment = this.escapeAndQuote(scheduler.EVENT_COMMENT);
+
+         sqlString += `/*!50106 DROP EVENT IF EXISTS \`${name}\` */;\n`;
+         sqlString += '/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;;\n';
+         sqlString += `/*!50003 SET SQL_MODE='${sqlMode}' */;\n`;
+         sqlString += 'DELIMITER ;;\n';
+         sqlString += '/*!50106 CREATE*/ ';
+         sqlString += `/*!50117 DEFINER=${definer}*/ `;
+         sqlString += `/*!50106 EVENT \`${name}\` ON SCHEDULE `;
+         if (type === 'RECURRING') {
+            sqlString += `EVERY ${intervalValue} ${intervalField} STARTS '${starts}' `;
+
+            if (ends) sqlString += `ENDS '${ends}' `;
+         }
+         else sqlString += `AT '${at}' `;
+         sqlString += `ON COMPLETION ${onCompletion} ${
+            status === 'disabled' ? 'DISABLE' : 'ENABLE'
+         } COMMENT ${comment || '\'\''} DO ${definition}*/;;\n`;
+         sqlString += 'DELIMITER ;\n';
+         sqlString += '/*!50003 SET SQL_MODE=@OLD_SQL_MODE*/;;\n';
+      }
+
+      return sqlString;
+   }
+
+   async getFunctions () {
+      const { rows: functions } = await this._client.raw(
+         `SHOW FUNCTION STATUS WHERE \`Db\` = '${this.schemaName}';`
+      );
+
+      let sqlString = '';
+
+      for (const func of functions) {
+         const definer = this.getEscapedDefiner(func.Definer);
+         sqlString += await this.getRoutineSyntax(
+            func.Name,
+            func.Type,
+            definer
+         );
+      }
+
+      return sqlString;
+   }
+
+   async getRoutines () {
+      const { rows: routines } = await this._client.raw(
+         `SHOW PROCEDURE STATUS WHERE \`Db\` = '${this.schemaName}';`
+      );
+
+      let sqlString = '';
+
+      for (const routine of routines) {
+         const definer = this.getEscapedDefiner(routine.Definer);
+
+         sqlString += await this.getRoutineSyntax(
+            routine.Name,
+            routine.Type,
+            definer
+         );
+      }
+
+      return sqlString;
+   }
+
+   async getRoutineSyntax (name, type, definer) {
+      const { rows: routines } = await this._client.raw(
+         `SHOW CREATE ${type} \`${this.schemaName}\`.\`${name}\``
+      );
+
+      if (routines.length === 0) return '';
+
+      const routine = routines[0];
+
+      const fieldName = `Create ${type === 'PROCEDURE' ? 'Procedure' : 'Function'}`;
+      const sqlMode = routine.sql_mode;
+      const createProcedure = routine[fieldName];
+      let sqlString = '';
+
+      if (createProcedure) { // If procedure body not empty
+         const startOffset = createProcedure.indexOf(type);
+         const procedureBody = createProcedure.substring(startOffset);
+
+         sqlString += `/*!50003 DROP ${type} IF EXISTS ${name}*/;;\n`;
+         sqlString += '/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/;;\n';
+         sqlString += `/*!50003 SET SQL_MODE="${sqlMode}"*/;;\n`;
+         sqlString += 'DELIMITER ;;\n';
+         sqlString += `/*!50003 CREATE*/ /*!50020 DEFINER=${definer}*/ /*!50003 ${procedureBody}*/;;\n`;
+         sqlString += 'DELIMITER ;\n';
+         sqlString += '/*!50003 SET SQL_MODE=@OLD_SQL_MODE*/;\n';
+      }
+
+      return sqlString;
+   }
+
+   async _queryStream (sql) {
+      if (process.env.NODE_ENV === 'development') console.log('EXPORTER:', sql);
+      const isPool = typeof this._client._connection.getConnection === 'function';
+      const connection = isPool ? await this._client._connection.getConnection() : this._client._connection;
+      const stream = connection.connection.query(sql).stream();
+      const dispose = () => connection.destroy();
+
+      stream.on('end', dispose);
+      stream.on('error', dispose);
+      stream.on('close', dispose);
+      return stream;
+   }
+
+   getEscapedDefiner (definer) {
+      return definer
+         .split('@')
+         .map(part => '`' + part + '`')
+         .join('@');
+   }
+
+   escapeAndQuote (val) {
+      // eslint-disable-next-line no-control-regex
+      const CHARS_TO_ESCAPE = /[\0\b\t\n\r\x1a"'\\]/g;
+      const CHARS_ESCAPE_MAP = {
+         '\0': '\\0',
+         '\b': '\\b',
+         '\t': '\\t',
+         '\n': '\\n',
+         '\r': '\\r',
+         '\x1a': '\\Z',
+         '"': '\\"',
+         '\'': '\\\'',
+         '\\': '\\\\'
+      };
+      let chunkIndex = CHARS_TO_ESCAPE.lastIndex = 0;
+      let escapedVal = '';
+      let match;
+
+      while ((match = CHARS_TO_ESCAPE.exec(val))) {
+         escapedVal += val.slice(chunkIndex, match.index) + CHARS_ESCAPE_MAP[match[0]];
+         chunkIndex = CHARS_TO_ESCAPE.lastIndex;
+      }
+
+      if (chunkIndex === 0)
+         return `'${val}'`;
+
+      if (chunkIndex < val.length)
+         return `'${escapedVal + val.slice(chunkIndex)}'`;
+
+      return `'${escapedVal}'`;
+   }
+
+   _getGeoJSON (val) {
+      if (Array.isArray(val)) {
+         if (getArrayDepth(val) === 1)
+            return lineString(val.reduce((acc, curr) => [...acc, [curr.x, curr.y]], []));
+         else
+            return polygon(val.map(arr => arr.reduce((acc, curr) => [...acc, [curr.x, curr.y]], [])));
+      }
+      else
+         return point([val.x, val.y]);
+   }
+}
--- a/src/main/libs/exporters/sql/SqlExporter.js
+++ b/src/main/libs/exporters/sql/SqlExporter.js
@@ -0,0 +1,162 @@
+import moment from 'moment';
+import { BaseExporter } from '../BaseExporter';
+
+export class SqlExporter extends BaseExporter {
+   constructor (client, tables, options) {
+      super(tables, options);
+      this._client = client;
+      this._commentChar = '#';
+   }
+
+   get schemaName () {
+      return this._options.schema;
+   }
+
+   get host () {
+      return this._client._params.host;
+   }
+
+   async getServerVersion () {
+      const version = await this._client.getVersion();
+      return `${version.name} ${version.number}`;
+   }
+
+   async dump () {
+      const { includes } = this._options;
+      const extraItems = Object.keys(includes).filter(key => includes[key]);
+      const totalTableToProcess = this._tables.filter(
+         t => t.includeStructure || t.includeContent || t.includeDropStatement
+      ).length;
+      const processingItemCount = totalTableToProcess + extraItems.length;
+
+      const exportState = {
+         totalItems: processingItemCount,
+         currentItemIndex: 0,
+         currentItem: '',
+         op: ''
+      };
+
+      const header = await this.getSqlHeader();
+      this.writeString(header);
+      this.writeString('\n\n\n');
+
+      for (const item of this._tables) {
+         // user abort operation
+         if (this.isCancelled) return;
+
+         // skip item if not set to output any detail for them
+         if (
+            !item.includeStructure &&
+            !item.includeContent &&
+            !item.includeDropStatement
+         )
+            continue;
+
+         exportState.currentItemIndex++;
+         exportState.currentItem = item.table;
+         exportState.op = 'FETCH';
+
+         this.emitUpdate(exportState);
+
+         const tableHeader = this.buildComment(
+            `Dump of table ${item.table}\n------------------------------------------------------------`
+         );
+         this.writeString(tableHeader);
+         this.writeString('\n\n');
+
+         if (item.includeDropStatement) {
+            const dropTableSyntax = this.getDropTable(item.table);
+            this.writeString(dropTableSyntax);
+            this.writeString('\n\n');
+         }
+
+         if (item.includeStructure) {
+            const createTableSyntax = await this.getCreateTable(item.table);
+            this.writeString(createTableSyntax);
+            this.writeString('\n\n');
+         }
+
+         if (item.includeContent) {
+            exportState.op = 'WRITE';
+            this.emitUpdate(exportState);
+            for await (const sqlStr of this.getTableInsert(item.table)) {
+               if (this.isCancelled) return;
+               this.writeString(sqlStr);
+            }
+
+            this.writeString('\n\n');
+         }
+
+         this.writeString('\n\n');
+      }
+
+      for (const item of extraItems) {
+         const processingMethod = `get${item.charAt(0).toUpperCase() + item.slice(1)}`;
+         exportState.currentItemIndex++;
+         exportState.currentItem = item;
+         exportState.op = 'PROCESSING';
+         this.emitUpdate(exportState);
+
+         if (this[processingMethod]) {
+            const data = await this[processingMethod]();
+            if (data !== '') {
+               const header =
+                  this.buildComment(
+                     `Dump of ${item}\n------------------------------------------------------------`
+                  ) + '\n\n';
+
+               this.writeString(header);
+               this.writeString(data);
+               this.writeString('\n\n');
+            }
+         }
+      }
+
+      const footer = await this.getFooter();
+      this.writeString(footer);
+   }
+
+   buildComment (text) {
+      return text
+         .split('\n')
+         .map(txt => `${this._commentChar} ${txt}`)
+         .join('\n');
+   }
+
+   async getSqlHeader () {
+      const serverVersion = await this.getServerVersion();
+      const header = `************************************************************
+Antares - SQL Client
+Version ${process.env.PACKAGE_VERSION}
+
+https://antares-sql.app/
+https://github.com/Fabio286/antares
+
+Host: ${this.host} (${serverVersion})
+Database: ${this.schemaName}
+Generation time: ${moment().format()}
+************************************************************`;
+
+      return this.buildComment(header);
+   }
+
+   async getFooter () {
+      return this.buildComment(`Dump completed on ${moment().format()}`);
+   }
+
+   getCreateTable (tableName) {
+      throw new Error(
+         'Sql Exporter must implement the "getCreateTable" method'
+      );
+   }
+
+   getDropTable (tableName) {
+      throw new Error('Sql Exporter must implement the "getDropTable" method');
+   }
+
+   getTableInsert (tableName) {
+      throw new Error(
+         'Sql Exporter must implement the "getTableInsert" method'
+      );
+   }
+}
--- a/src/main/libs/importers/BaseImporter.js
+++ b/src/main/libs/importers/BaseImporter.js
@@ -0,0 +1,53 @@
+import fs from 'fs';
+import EventEmitter from 'events';
+
+export class BaseImporter extends EventEmitter {
+   constructor (options) {
+      super();
+      this._options = options;
+      this._isCancelled = false;
+      this._fileHandler = fs.createReadStream(this._options.file, {
+         flags: 'r',
+         highWaterMark: 4 * 1024
+      });
+      this._state = {};
+
+      this._fileHandler.once('error', err => {
+         this._isCancelled = true;
+         this.emit('error', err);
+      });
+   }
+
+   async run () {
+      try {
+         this.emit('start', this);
+         await this.import();
+      }
+      catch (err) {
+         this.emit('error', err);
+         throw err;
+      }
+      finally {
+         this._fileHandler.close();
+         this.emit('end');
+      }
+   }
+
+   get isCancelled () {
+      return this._isCancelled;
+   }
+
+   cancel () {
+      this._isCancelled = true;
+      this.emit('cancel');
+      this.emitUpdate({ op: 'cancelling' });
+   }
+
+   emitUpdate (state) {
+      this.emit('progress', { ...this._state, ...state });
+   }
+
+   import () {
+      throw new Error('Exporter must implement the "import" method');
+   }
+}
--- a/src/main/libs/importers/sql/MysqlImporter.js
+++ b/src/main/libs/importers/sql/MysqlImporter.js
@@ -0,0 +1,85 @@
+import fs from 'fs/promises';
+import SqlParser from '../../../../common/libs/sqlParser';
+import { BaseImporter } from '../BaseImporter';
+
+export default class MysqlImporter extends BaseImporter {
+   constructor (client, options) {
+      super(options);
+      this._client = client;
+   }
+
+   async import () {
+      try {
+         const { size: totalFileSize } = await fs.stat(this._options.file);
+         const parser = new SqlParser();
+         let readPosition = 0;
+         let queryCount = 0;
+
+         this.emitUpdate({
+            fileSize: totalFileSize,
+            readPosition: 0,
+            percentage: 0,
+            queryCount: 0
+         });
+
+         // 1. detect file encoding
+         // 2. set fh encoding
+         // 3. detect sql mode
+         // 4. restore sql mode in case of exception
+
+         return new Promise((resolve, reject) => {
+            this._fileHandler.pipe(parser);
+
+            parser.on('error', reject);
+
+            parser.on('close', async () => {
+               console.log('TOTAL QUERIES', queryCount);
+               console.log('import end');
+               resolve();
+            });
+
+            parser.on('data', async (query) => {
+               queryCount++;
+               parser.pause();
+
+               try {
+                  await this._client.query(query);
+               }
+               catch (error) {
+                  this.emit('query-error', {
+                     sql: query,
+                     message: error.sqlMessage,
+                     sqlSnippet: error.sql,
+                     time: new Date().getTime()
+                  });
+               }
+
+               this.emitUpdate({
+                  queryCount,
+                  readPosition,
+                  percentage: readPosition / totalFileSize * 100
+               });
+               this._fileHandler.pipe(parser);
+               parser.resume();
+            });
+
+            parser.on('pause', () => {
+               this._fileHandler.unpipe(parser);
+               this._fileHandler.readableFlowing = false;
+            });
+
+            this._fileHandler.on('data', (chunk) => {
+               readPosition += chunk.length;
+            });
+
+            this._fileHandler.on('error', (err) => {
+               console.log(err);
+               reject(err);
+            });
+         });
+      }
+      catch (err) {
+         console.log(err);
+      }
+   }
+}
--- a/src/main/main.js
+++ b/src/main/main.js
@@ -13,7 +13,6 @@ Store.initRenderer();

 const isDevelopment = process.env.NODE_ENV !== 'production';
 const isMacOS = process.platform === 'darwin';
-const isWindows = process.platform === 'win32';
 const gotTheLock = app.requestSingleInstanceLock();

 process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = 'true';
@@ -33,7 +32,6 @@ async function createMainWindow () {
      minHeight: 550,
      title: 'Antares SQL',
      autoHideMenuBar: true,
-      show: !isWindows, // Temporary workaround to https://github.com/electron/electron/issues/30024
      icon: nativeImage.createFromDataURL(icon.default),
      webPreferences: {
         nodeIntegration: true,
@@ -115,9 +113,6 @@ else {
      mainWindow = await createMainWindow();
      createAppMenu();

-      if (isWindows) // Temporary workaround to https://github.com/electron/electron/issues/30024
-         mainWindow.show();
-
      // if (isDevelopment)
      //    mainWindow.webContents.openDevTools();

--- a/src/main/workers/exporter.js
+++ b/src/main/workers/exporter.js
@@ -0,0 +1,60 @@
+import { ClientsFactory } from '../libs/ClientsFactory';
+import MysqlExporter from '../libs/exporters/sql/MysqlExporter.js';
+import fs from 'fs';
+let exporter;
+
+process.on('message', async ({ type, client, tables, options }) => {
+   if (type === 'init') {
+      const connection = await ClientsFactory.getClient({
+         client: client.name,
+         params: client.config,
+         poolSize: 5
+      });
+      await connection.connect();
+
+      switch (client.name) {
+         case 'mysql':
+         case 'maria':
+            exporter = new MysqlExporter(connection, tables, options);
+            break;
+         default:
+            process.send({
+               type: 'error',
+               payload: `"${client.name}" exporter not aviable`
+            });
+            return;
+      }
+
+      exporter.once('error', err => {
+         console.error(err);
+         process.send({
+            type: 'error',
+            payload: err.toString()
+         });
+      });
+
+      exporter.once('end', () => {
+         process.send({
+            type: 'end',
+            payload: { cancelled: exporter.isCancelled }
+         });
+         connection.destroy();
+      });
+
+      exporter.once('cancel', () => {
+         fs.unlinkSync(exporter.outputFile);
+         process.send({ type: 'cancel' });
+      });
+
+      exporter.on('progress', state => {
+         process.send({
+            type: 'export-progress',
+            payload: state
+         });
+      });
+
+      exporter.run();
+   }
+   else if (type === 'cancel')
+      exporter.cancel();
+});
--- a/src/main/workers/importer.js
+++ b/src/main/workers/importer.js
@@ -0,0 +1,68 @@
+import { ClientsFactory } from '../libs/ClientsFactory';
+import MysqlImporter from '../libs/importers/sql/MysqlImporter';
+let importer;
+
+process.on('message', async ({ type, dbConfig, options }) => {
+   if (type === 'init') {
+      const connection = await ClientsFactory.getClient({
+         client: options.type,
+         params: {
+            ...dbConfig,
+            schema: options.schema
+         },
+         poolSize: 1
+      });
+
+      const pool = await connection.getConnectionPool();
+
+      switch (options.type) {
+         case 'mysql':
+         case 'maria':
+            importer = new MysqlImporter(pool, options);
+            break;
+         default:
+            process.send({
+               type: 'error',
+               payload: `"${options.type}" importer not aviable`
+            });
+            return;
+      }
+
+      importer.once('error', err => {
+         console.error(err);
+         process.send({
+            type: 'error',
+            payload: err.toString()
+         });
+      });
+
+      importer.once('end', () => {
+         process.send({
+            type: 'end',
+            payload: { cancelled: importer.isCancelled }
+         });
+      });
+
+      importer.once('cancel', () => {
+         process.send({ type: 'cancel' });
+      });
+
+      importer.on('progress', state => {
+         process.send({
+            type: 'import-progress',
+            payload: state
+         });
+      });
+
+      importer.on('query-error', state => {
+         process.send({
+            type: 'query-error',
+            payload: state
+         });
+      });
+
+      importer.run();
+   }
+   else if (type === 'cancel')
+      importer.cancel();
+});
--- a/src/renderer/components/BaseConfirmModal.vue
+++ b/src/renderer/components/BaseConfirmModal.vue
@@ -110,5 +110,4 @@ export default {
 .modal.modal-sm .modal-container {
  padding: 0;
 }
-
 </style>
--- a/src/renderer/components/ForeignKeySelect.vue
+++ b/src/renderer/components/ForeignKeySelect.vue
@@ -7,7 +7,7 @@
      @blur="$emit('blur')"
   >
      <option v-if="!isValidDefault" :value="value">
-         {{ value }} - {{ $t('message.invalidDefault') }}
+         {{ value === null ? 'NULL' : value }}
      </option>
      <option
         v-for="row in foreignList"
--- a/src/renderer/components/ModalExportSchema.vue
+++ b/src/renderer/components/ModalExportSchema.vue
@@ -0,0 +1,491 @@
+<template>
+   <div class="modal active">
+      <a class="modal-overlay" @click.stop="closeModal" />
+      <div class="modal-container p-0">
+         <div class="modal-header pl-2">
+            <div class="modal-title h6">
+               <div class="d-flex">
+                  <i class="mdi mdi-24px mdi-database-arrow-down mr-1" />
+                  <span class="cut-text">{{ $t('message.exportSchema') }}</span>
+               </div>
+            </div>
+            <a class="btn btn-clear c-hand" @click.stop="closeModal" />
+         </div>
+         <div class="modal-body pb-0">
+            <div class="container">
+               <div class="columns">
+                  <div class="col-3">
+                     <label class="form-label">{{ $t('message.directoryPath') }}</label>
+                  </div>
+                  <div class="col-9">
+                     <fieldset class="input-group">
+                        <input
+                           v-model="basePath"
+                           class="form-input"
+                           type="text"
+                           required
+                           readonly
+                           :placeholder="$t('message.schemaName')"
+                        >
+                        <button
+                           type="button"
+                           class="btn btn-primary input-group-btn"
+                           @click.prevent="openPathDialog"
+                        >
+                           {{ $t('word.change') }}
+                        </button>
+                     </fieldset>
+                  </div>
+               </div>
+            </div>
+
+            <div class="columns export-options">
+               <div class="column col-8 left">
+                  <div class="columns mb-2">
+                     <div class="column col-auto d-flex text-italic ">
+                        <i class="mdi mdi-file-document-outline mr-2" />
+                        {{ filename }}
+                     </div>
+
+                     <div class="column col-auto col-ml-auto ">
+                        <button
+                           class="btn btn-dark btn-sm"
+                           :title="$t('word.refresh')"
+                           @click="refresh"
+                        >
+                           <i class="mdi mdi-database-refresh" />
+                        </button>
+                        <button
+                           class="btn btn-dark btn-sm"
+                           :title="$t('message.uncheckAllTables')"
+                           :disabled="isRefreshing"
+                           @click="uncheckAllTables"
+                        >
+                           <i class="mdi mdi-file-tree-outline" />
+                        </button>
+                        <button
+                           class="btn btn-dark btn-sm"
+                           :title="$t('message.checkAllTables')"
+                           :disabled="isRefreshing"
+                           @click="checkAllTables"
+                        >
+                           <i class="mdi mdi-file-tree" />
+                        </button>
+                     </div>
+                  </div>
+                  <div class="workspace-query-results">
+                     <div ref="table" class="table table-hover">
+                        <div class="thead">
+                           <div class="tr text-center">
+                              <div class="th no-border" style="width: 50%;" />
+                              <div class="th no-border">
+                                 <label
+                                    class="form-checkbox m-0 px-2 form-inline"
+                                    @click.prevent="toggleAllTablesOption('includeStructure')"
+                                 >
+                                    <input
+                                       type="checkbox"
+                                       :indeterminate.prop="includeStructureStatus === 2"
+                                       :checked.prop="!!includeStructureStatus"
+                                    >
+                                    <i class="form-icon" />
+                                 </label>
+                              </div>
+                              <div class="th no-border">
+                                 <label
+                                    class="form-checkbox m-0 px-2 form-inline"
+                                    @click.prevent="toggleAllTablesOption('includeContent')"
+                                 >
+                                    <input
+                                       type="checkbox"
+                                       :indeterminate.prop="includeContentStatus === 2"
+                                       :checked.prop="!!includeContentStatus"
+                                    >
+                                    <i class="form-icon" />
+                                 </label>
+                              </div>
+                              <div class="th no-border">
+                                 <label
+                                    class="form-checkbox m-0 px-2 form-inline"
+                                    @click.prevent="toggleAllTablesOption('includeDropStatement')"
+                                 >
+                                    <input
+                                       type="checkbox"
+                                       :indeterminate.prop="includeDropStatementStatus === 2"
+                                       :checked.prop="!!includeDropStatementStatus"
+                                    >
+                                    <i class="form-icon" />
+                                 </label>
+                              </div>
+                           </div>
+                           <div class="tr">
+                              <div class="th" style="width: 50%;">
+                                 <div class="table-column-title">
+                                    <span>{{ $t('word.table') }}</span>
+                                 </div>
+                              </div>
+                              <div class="th text-center">
+                                 <div class="table-column-title">
+                                    <span>{{ $t('word.structure') }}</span>
+                                 </div>
+                              </div>
+                              <div class="th text-center">
+                                 <div class="table-column-title">
+                                    <span>{{ $t('word.content') }}</span>
+                                 </div>
+                              </div>
+                              <div class="th text-center">
+                                 <div class="table-column-title">
+                                    <span>{{ $t('word.drop') }}</span>
+                                 </div>
+                              </div>
+                           </div>
+                        </div>
+
+                        <div class="tbody">
+                           <div
+                              v-for="item in tables"
+                              :key="item.name"
+                              class="tr"
+                           >
+                              <div class="td">
+                                 {{ item.table }}
+                              </div>
+                              <div class="td text-center">
+                                 <label class="form-checkbox m-0 px-2 form-inline">
+                                    <input
+                                       v-model="item.includeStructure"
+                                       type="checkbox"
+                                    ><i class="form-icon" />
+                                 </label>
+                              </div>
+                              <div class="td text-center">
+                                 <label class="form-checkbox m-0 px-2 form-inline">
+                                    <input
+                                       v-model="item.includeContent"
+                                       type="checkbox"
+                                    ><i class="form-icon" />
+                                 </label>
+                              </div>
+                              <div class="td text-center">
+                                 <label class="form-checkbox m-0 px-2 form-inline">
+                                    <input
+                                       v-model="item.includeDropStatement"
+                                       type="checkbox"
+                                    ><i class="form-icon" />
+                                 </label>
+                              </div>
+                           </div>
+                        </div>
+                     </div>
+                  </div>
+               </div>
+               <div class="column col-4">
+                  <h4>
+                     {{ $t('word.options') }}
+                  </h4>
+                  <span>{{ $t('word.includes') }}:</span>
+
+                  <label
+                     v-for="(_, key) in options.includes"
+                     :key="key"
+                     class="form-checkbox"
+                  >
+                     <input v-model="options.includes[key]" type="checkbox"><i class="form-icon" /> {{ $t(`word.${key}`) }}
+                  </label>
+
+                  <div class="mt-4 mb-2">
+                     {{ $t('message.newInserStmtEvery') }}:
+                  </div>
+                  <div class="columns">
+                     <div class="column col-6">
+                        <input
+                           v-model.number="options.sqlInsertAfter"
+                           type="number"
+                           class="form-input"
+                           value="250"
+                        >
+                     </div>
+                     <div class="column col-6">
+                        <select v-model="options.sqlInsertDivider" class="form-select">
+                           <option value="bytes">
+                              KiB
+                           </option>
+                           <option value="rows">
+                              {{ $tc('word.row', 2) }}
+                           </option>
+                        </select>
+                     </div>
+                  </div>
+               </div>
+            </div>
+         </div>
+         <div class="modal-footer columns">
+            <div class="column col modal-progress-wrapper text-left">
+               <div v-if="progressPercentage > 0" class="export-progress">
+                  <span class="progress-status">
+                     {{ progressPercentage }}% - {{ progressStatus }}
+                  </span>
+                  <progress
+                     class="progress d-block"
+                     :value="progressPercentage"
+                     max="100"
+                  />
+               </div>
+            </div>
+            <div class="column col-auto px-0">
+               <button class="btn btn-link" @click.stop="closeModal">
+                  {{ $t('word.close') }}
+               </button>
+               <button
+                  class="btn btn-primary mr-2"
+                  :class="{'loading': isExporting}"
+                  :disabled="isExporting || isRefreshing"
+                  autofocus
+                  @click.prevent="startExport"
+               >
+                  {{ $t('word.export') }}
+               </button>
+            </div>
+         </div>
+      </div>
+   </div>
+</template>
+
+<script>
+import { ipcRenderer } from 'electron';
+import { mapActions, mapGetters } from 'vuex';
+import moment from 'moment';
+import customizations from 'common/customizations';
+import Application from '@/ipc-api/Application';
+import Schema from '@/ipc-api/Schema';
+
+export default {
+   name: 'ModalExportSchema',
+
+   props: {
+      selectedSchema: String
+   },
+   data () {
+      return {
+         isExporting: false,
+         isRefreshing: false,
+         progressPercentage: 0,
+         progressStatus: '',
+         tables: [],
+         options: {
+            includes: {},
+            sqlInsertAfter: 250,
+            sqlInsertDivider: 'bytes'
+         },
+         basePath: ''
+      };
+   },
+   computed: {
+      ...mapGetters({
+         selectedWorkspace: 'workspaces/getSelected',
+         getWorkspace: 'workspaces/getWorkspace',
+         getDatabaseVariable: 'workspaces/getDatabaseVariable'
+      }),
+      currentWorkspace () {
+         return this.getWorkspace(this.selectedWorkspace);
+      },
+      schemaItems () {
+         const db = this.currentWorkspace.structure.find(db => db.name === this.selectedSchema);
+         if (db)
+            return db.tables.filter(table => table.type === 'table');
+
+         return [];
+      },
+      filename () {
+         const date = moment().format('YYYY-MM-DD');
+         return `${this.selectedSchema}_${date}.sql`;
+      },
+      dumpFilePath () {
+         return `${this.basePath}/${this.filename}`;
+      },
+      includeStructureStatus () {
+         if (this.tables.every(item => item.includeStructure)) return 1;
+         else if (this.tables.some(item => item.includeStructure)) return 2;
+         else return 0;
+      },
+      includeContentStatus () {
+         if (this.tables.every(item => item.includeContent)) return 1;
+         else if (this.tables.some(item => item.includeContent)) return 2;
+         else return 0;
+      },
+      includeDropStatementStatus () {
+         if (this.tables.every(item => item.includeDropStatement)) return 1;
+         else if (this.tables.some(item => item.includeDropStatement)) return 2;
+         else return 0;
+      }
+   },
+   async created () {
+      if (!this.schemaItems.length) await this.refresh();
+
+      window.addEventListener('keydown', this.onKey);
+
+      this.basePath = await Application.getDownloadPathDirectory();
+      this.tables = this.schemaItems.map(item => ({
+         table: item.name,
+         includeStructure: true,
+         includeContent: true,
+         includeDropStatement: true
+      }));
+
+      const structure = ['views', 'triggers', 'routines', 'functions', 'schedulers', 'triggerFunctions'];
+
+      structure.forEach(feat => {
+         const val = customizations[this.currentWorkspace.client][feat];
+         if (val)
+            this.$set(this.options.includes, feat, true);
+      });
+
+      ipcRenderer.on('export-progress', this.updateProgress);
+   },
+   beforeDestroy () {
+      window.removeEventListener('keydown', this.onKey);
+      ipcRenderer.off('export-progress', this.updateProgress);
+   },
+   methods: {
+      ...mapActions({
+         addNotification: 'notifications/addNotification',
+         refreshSchema: 'workspaces/refreshSchema'
+      }),
+      async startExport () {
+         this.isExporting = true;
+         const { uid, client } = this.currentWorkspace;
+         const params = {
+            uid,
+            type: client,
+            schema: this.selectedSchema,
+            outputFile: this.dumpFilePath,
+            tables: [...this.tables],
+            ...this.options
+         };
+
+         try {
+            const { status, response } = await Schema.export(params);
+            if (status === 'success')
+               this.progressStatus = response.cancelled ? this.$t('word.aborted') : this.$t('word.completed');
+            else {
+               this.progressStatus = response;
+               this.addNotification({ status: 'error', message: response });
+            }
+         }
+         catch (err) {
+            this.addNotification({ status: 'error', message: err.stack });
+         }
+
+         this.isExporting = false;
+      },
+      updateProgress (event, state) {
+         this.progressPercentage = Number((state.currentItemIndex / state.totalItems * 100).toFixed(1));
+         switch (state.op) {
+            case 'PROCESSING':
+               this.progressStatus = this.$t('message.processingTableExport', { table: state.currentItem });
+               break;
+            case 'FETCH':
+               this.progressStatus = this.$t('message.fechingTableExport', { table: state.currentItem });
+               break;
+            case 'WRITE':
+               this.progressStatus = this.$t('message.writingTableExport', { table: state.currentItem });
+               break;
+         }
+      },
+      async closeModal () {
+         let willClose = true;
+         if (this.isExporting) {
+            willClose = false;
+            const { response } = await Schema.abortExport();
+            willClose = response.willAbort;
+         }
+
+         if (willClose)
+            this.$emit('close');
+      },
+      onKey (e) {
+         e.stopPropagation();
+         if (e.key === 'Escape')
+            this.closeModal();
+      },
+      checkAllTables () {
+         this.tables = this.tables.map(item => ({ ...item, includeStructure: true, includeContent: true, includeDropStatement: true }));
+      },
+      uncheckAllTables () {
+         this.tables = this.tables.map(item => ({ ...item, includeStructure: false, includeContent: false, includeDropStatement: false }));
+      },
+      toggleAllTablesOption (option) {
+         const options = ['includeStructure', 'includeContent', 'includeDropStatement'];
+         if (!options.includes(option)) return;
+
+         if (this[`${option}Status`] !== 1)
+            this.tables = this.tables.map(item => ({ ...item, [option]: true }));
+         else
+            this.tables = this.tables.map(item => ({ ...item, [option]: false }));
+      },
+      async refresh () {
+         this.isRefreshing = true;
+         await this.refreshSchema({ uid: this.currentWorkspace.uid, schema: this.selectedSchema });
+         this.isRefreshing = false;
+      },
+      async openPathDialog () {
+         const result = await Application.showOpenDialog({ properties: ['openDirectory'] });
+         if (result && !result.canceled)
+            this.basePath = result.filePaths[0];
+      }
+   }
+};
+</script>
+
+<style lang="scss" scoped>
+.export-options {
+  flex: 1;
+  overflow: hidden;
+
+  .left {
+     display: flex;
+     flex-direction: column;
+     flex: 1;
+  }
+}
+
+.workspace-query-results {
+   flex: 1 0 1px;
+  .table {
+    width: 100% !important;
+  }
+
+  .form-checkbox {
+    min-height: 0.8rem;
+    padding: 0;
+
+    .form-icon {
+      top: 0.1rem;
+    }
+  }
+}
+
+.modal {
+
+  .modal-container {
+    max-width: 800px;
+  }
+
+    .modal-body {
+      max-height: 60vh;
+      display: flex;
+      flex-direction: column;
+    }
+
+    .modal-footer {
+       display: flex;
+    }
+}
+
+.progress-status {
+   font-style: italic;
+   font-size: 80%;
+}
+
+</style>
--- a/src/renderer/components/ModalFakerRows.vue
+++ b/src/renderer/components/ModalFakerRows.vue
@@ -6,7 +6,7 @@
            <div class="modal-title h6">
               <div class="d-flex">
                  <i class="mdi mdi-24px mdi-playlist-plus mr-1" />
-                  <span class="cut-text">{{ $t('message.tableFiller') }}</span>
+                  <span class="cut-text">{{ $tc('message.insertRow', 2) }}</span>
               </div>
            </div>
            <a class="btn btn-clear c-hand" @click.stop="closeModal" />
--- a/src/renderer/components/ModalImportSchema.vue
+++ b/src/renderer/components/ModalImportSchema.vue
@@ -0,0 +1,181 @@
+<template>
+   <div class="modal active">
+      <a class="modal-overlay" @click.stop="closeModal" />
+      <div class="modal-container p-0">
+         <div class="modal-header pl-2">
+            <div class="modal-title h6">
+               <div class="d-flex">
+                  <i class="mdi mdi-24px mdi-database-arrow-up mr-1" />
+                  <span class="cut-text">{{ $t('message.importSchema') }}</span>
+               </div>
+            </div>
+            <a class="btn btn-clear c-hand" @click.stop="closeModal" />
+         </div>
+         <div class="modal-body pb-0">
+            {{ sqlFile }}
+            <div v-if="queryErrors.length > 0" class="mt-2">
+               <label>{{ $tc('message.importQueryErrors', queryErrors.length) }}</label>
+               <textarea
+                  v-model="formattedQueryErrors"
+                  class="form-input"
+                  rows="5"
+                  readonly
+               />
+            </div>
+         </div>
+         <div class="modal-footer columns">
+            <div class="column col modal-progress-wrapper text-left">
+               <div class="import-progress">
+                  <span class="progress-status">
+                     {{ progressPercentage }}% - {{ progressStatus }} - {{ $tc('message.executedQueries', queryCount) }}
+                  </span>
+                  <progress
+                     class="progress d-block"
+                     :value="progressPercentage"
+                     max="100"
+                  />
+               </div>
+            </div>
+            <div class="column col-auto px-0">
+               <button class="btn btn-link" @click.stop="closeModal">
+                  {{ completed ? $t('word.close') : $t('word.cancel') }}
+               </button>
+            </div>
+         </div>
+      </div>
+   </div>
+</template>
+
+<script>
+import { ipcRenderer } from 'electron';
+import { mapActions, mapGetters } from 'vuex';
+import moment from 'moment';
+import Schema from '@/ipc-api/Schema';
+
+export default {
+   name: 'ModalImportSchema',
+
+   props: {
+      selectedSchema: String
+   },
+   data () {
+      return {
+         sqlFile: '',
+         isImporting: false,
+         progressPercentage: 0,
+         queryCount: 0,
+         completed: false,
+         progressStatus: 'Reading',
+         queryErrors: []
+      };
+   },
+   computed: {
+      ...mapGetters({
+         selectedWorkspace: 'workspaces/getSelected',
+         getWorkspace: 'workspaces/getWorkspace'
+      }),
+      currentWorkspace () {
+         return this.getWorkspace(this.selectedWorkspace);
+      },
+      formattedQueryErrors () {
+         return this.queryErrors.map(err =>
+            `Time: ${moment(err.time).format('HH:mm:ss.S')} (${err.time})\nError: ${err.message}`
+         ).join('\n\n');
+      }
+   },
+   async created () {
+      window.addEventListener('keydown', this.onKey);
+
+      ipcRenderer.on('import-progress', this.updateProgress);
+      ipcRenderer.on('query-error', this.handleQueryError);
+   },
+   beforeDestroy () {
+      window.removeEventListener('keydown', this.onKey);
+      ipcRenderer.off('import-progress', this.updateProgress);
+      ipcRenderer.off('query-error', this.handleQueryError);
+   },
+   methods: {
+      ...mapActions({
+         addNotification: 'notifications/addNotification',
+         refreshSchema: 'workspaces/refreshSchema'
+      }),
+      async startImport (sqlFile) {
+         this.isImporting = true;
+         this.sqlFile = sqlFile;
+
+         const { uid, client } = this.currentWorkspace;
+         const params = {
+            uid,
+            type: client,
+            schema: this.selectedSchema,
+            file: sqlFile
+         };
+
+         try {
+            this.completed = false;
+            const { status, response } = await Schema.import(params);
+            if (status === 'success')
+               this.progressStatus = response.cancelled ? this.$t('word.aborted') : this.$t('word.completed');
+            else {
+               this.progressStatus = response;
+               this.addNotification({ status: 'error', message: response });
+            }
+            this.refreshSchema({ uid, schema: this.selectedSchema });
+            this.completed = true;
+         }
+         catch (err) {
+            this.addNotification({ status: 'error', message: err.stack });
+         }
+
+         this.isImporting = false;
+      },
+      updateProgress (event, state) {
+         this.progressPercentage = Number(state.percentage).toFixed(1);
+         this.queryCount = Number(state.queryCount);
+      },
+      handleQueryError (event, err) {
+         this.queryErrors.push(err);
+      },
+      async closeModal () {
+         let willClose = true;
+         if (this.isImporting) {
+            willClose = false;
+            const { response } = await Schema.abortImport();
+            willClose = response.willAbort;
+         }
+
+         if (willClose)
+            this.$emit('close');
+      },
+      onKey (e) {
+         e.stopPropagation();
+         if (e.key === 'Escape')
+            this.closeModal();
+      }
+   }
+};
+</script>
+
+<style lang="scss" scoped>
+.modal {
+
+   .modal-container {
+      max-width: 800px;
+   }
+
+   .modal-body {
+      max-height: 60vh;
+      display: flex;
+      flex-direction: column;
+   }
+
+   .modal-footer {
+      display: flex;
+   }
+}
+
+.progress-status {
+   font-style: italic;
+   font-size: 80%;
+}
+</style>
--- a/src/renderer/components/ModalSettings.vue
+++ b/src/renderer/components/ModalSettings.vue
@@ -282,12 +282,18 @@
                  <div class="text-center">
                     <img src="../images/logo.svg" width="128">
                     <h4>{{ appName }}</h4>
-                     <p>
+                     <p class="mb-2">
                        {{ $t('word.version') }} {{ appVersion }}<br>
                        <a class="c-hand" @click="openOutside('https://github.com/Fabio286/antares')"><i class="mdi mdi-github d-inline" /> GitHub</a> • <a class="c-hand" @click="openOutside('https://twitter.com/AntaresSQL')"><i class="mdi mdi-twitter d-inline" /> Twitter</a> • <a class="c-hand" @click="openOutside('https://antares-sql.app/')"><i class="mdi mdi-web d-inline" /> Website</a><br>
-                        <small>{{ $t('word.author') }} <a class="c-hand" @click="openOutside('https://github.com/Fabio286')">Fabio Di Stasio</a></small><br>
-                        <small>{{ $t('message.madeWithJS') }}</small>
+                        <small>{{ $t('word.author') }} <a class="c-hand" @click="openOutside('https://github.com/Fabio286')">{{ appAuthor }}</a></small><br>
                     </p>
+                     <div class="mb-2">
+                        <small class="d-block text-uppercase">{{ $t('word.contributors') }}:</small>
+                        <div class="d-block py-1">
+                           <small v-for="(contributor, i) in otherContributors" :key="i">{{ i !== 0 ? ', ' : '' }}{{ contributor }}</small>
+                        </div>
+                        <small>{{ $t('message.madeWithJS') }}</small>
+                     </div>
                  </div>
               </div>
            </div>
@@ -313,6 +319,7 @@ export default {
   },
   data () {
      return {
+         appAuthor: 'Fabio Di Stasio',
         localLocale: null,
         localPageSize: null,
         localTimeout: null,
@@ -367,7 +374,8 @@ export default {
                  { code: 'vibrant_ink', name: 'Vibrant Ink' }
               ]
            }
-         ]
+         ],
+         contributors: process.env.APP_CONTRIBUTORS
      };
   },
   computed: {
@@ -417,6 +425,12 @@ GROUP BY
 ORDER BY
    employee.id ASC;
 `;
+      },
+      otherContributors () {
+         return this.contributors
+            .split(',')
+            .filter(c => !c.includes(this.appAuthor))
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
      }
   },
   created () {
--- a/src/renderer/components/TheFooter.vue
+++ b/src/renderer/components/TheFooter.vue
@@ -11,9 +11,9 @@

      <div class="footer-right-elements">
         <ul class="footer-elements">
-            <li class="footer-element footer-link" @click="openOutside('https://www.treedom.net/en/user/fabio-di-stasio/event/antares-for-the-planet')">
-               <i class="mdi mdi-18px mdi-tree mr-1" />
-               <small>{{ $t('message.plantATree') }}</small>
+            <li class="footer-element footer-link" @click="openOutside('https://www.paypal.com/paypalme/fabiodistasio')">
+               <i class="mdi mdi-18px mdi-coffee mr-1" />
+               <small>{{ $t('word.donate') }}</small>
            </li>
            <li class="footer-element footer-link" @click="openOutside('https://github.com/Fabio286/antares/issues')">
               <i class="mdi mdi-18px mdi-bug" />
--- a/src/renderer/components/Workspace.vue
+++ b/src/renderer/components/Workspace.vue
@@ -24,7 +24,11 @@
               @mousedown.left="selectTab({uid: workspace.uid, tab: tab.uid})"
               @mouseup.middle="closeTab(tab)"
            >
-               <a v-if="tab.type === 'query'" class="tab-link">
+               <a
+                  v-if="tab.type === 'query'"
+                  class="tab-link"
+                  :class="{'badge': tab.isChanged}"
+               >
                  <i class="mdi mdi-18px mdi-code-tags mr-1" />
                  <span>
                     <span>{{ tab.content || 'Query' | cutText }} #{{ tab.index }}</span>
--- a/src/renderer/components/WorkspaceAddConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceAddConnectionPanel.vue
@@ -61,6 +61,19 @@
                           </select>
                        </div>
                     </div>
+                     <div v-if="connection.client === 'pg'" class="form-group columns">
+                        <div class="column col-4 col-sm-12">
+                           <label class="form-label">{{ $t('word.connectionString') }}</label>
+                        </div>
+                        <div class="column col-8 col-sm-12">
+                           <input
+                              ref="pgString"
+                              v-model="connection.pgConnString"
+                              class="form-input"
+                              type="text"
+                           >
+                        </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.hostName') }}/IP</label>
@@ -412,7 +425,8 @@ export default {
            sshUser: '',
            sshPass: '',
            sshKey: '',
-            sshPort: 22
+            sshPort: 22,
+            pgConnString: ''
         },
         isConnecting: false,
         isTesting: false,
--- a/src/renderer/components/WorkspaceEditConnectionPanel.vue
+++ b/src/renderer/components/WorkspaceEditConnectionPanel.vue
@@ -61,6 +61,19 @@
                           </select>
                        </div>
                     </div>
+                     <div v-if="connection.client === 'pg'" class="form-group columns">
+                        <div class="column col-4 col-sm-12">
+                           <label class="form-label">{{ $t('word.connectionString') }}</label>
+                        </div>
+                        <div class="column col-8 col-sm-12">
+                           <input
+                              ref="pgString"
+                              v-model="localConnection.pgConnString"
+                              class="form-input"
+                              type="text"
+                           >
+                        </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.hostName') }}/IP</label>
--- a/src/renderer/components/WorkspaceExploreBarSchemaContext.vue
+++ b/src/renderer/components/WorkspaceExploreBarSchemaContext.vue
@@ -58,6 +58,20 @@
            </div>
         </div>
      </div>
+      <div
+         v-if="workspace.customizations.schemaExport"
+         class="context-element"
+         @click="showExportSchemaModal"
+      >
+         <span class="d-flex"><i class="mdi mdi-18px mdi-database-arrow-down text-light pr-1" /> {{ $t('word.export') }}</span>
+      </div>
+      <div
+         v-if="workspace.customizations.schemaImport"
+         class="context-element"
+         @click="initImport"
+      >
+         <span class="d-flex"><i class="mdi mdi-18px mdi-database-arrow-up text-light pr-1" /> {{ $t('word.import') }}</span>
+      </div>
      <div
         v-if="workspace.customizations.schemaEdit"
         class="context-element"
@@ -95,6 +109,17 @@
         :selected-schema="selectedSchema"
         @close="hideEditModal"
      />
+      <ModalExportSchema
+         v-if="isExportSchemaModal"
+         :selected-schema="selectedSchema"
+         @close="hideExportSchemaModal"
+      />
+      <ModalImportSchema
+         v-if="isImportSchemaModal"
+         ref="importModalRef"
+         :selected-schema="selectedSchema"
+         @close="hideImportSchemaModal"
+      />
   </BaseContextMenu>
 </template>

@@ -103,14 +128,19 @@ import { mapGetters, mapActions } from 'vuex';
 import BaseContextMenu from '@/components/BaseContextMenu';
 import ConfirmModal from '@/components/BaseConfirmModal';
 import ModalEditSchema from '@/components/ModalEditSchema';
+import ModalExportSchema from '@/components/ModalExportSchema';
+import ModalImportSchema from '@/components/ModalImportSchema';
 import Schema from '@/ipc-api/Schema';
+import Application from '@/ipc-api/Application';

 export default {
   name: 'WorkspaceExploreBarSchemaContext',
   components: {
      BaseContextMenu,
      ConfirmModal,
-      ModalEditSchema
+      ModalEditSchema,
+      ModalExportSchema,
+      ModalImportSchema
   },
   props: {
      contextEvent: MouseEvent,
@@ -119,7 +149,9 @@ export default {
   data () {
      return {
         isDeleteModal: false,
-         isEditModal: false
+         isEditModal: false,
+         isExportSchemaModal: false,
+         isImportSchemaModal: false
      };
   },
   computed: {
@@ -170,6 +202,30 @@ export default {
         this.isEditModal = false;
         this.closeContext();
      },
+      showExportSchemaModal () {
+         this.isExportSchemaModal = true;
+      },
+      hideExportSchemaModal () {
+         this.isExportSchemaModal = false;
+         this.closeContext();
+      },
+      showImportSchemaModal () {
+         this.isImportSchemaModal = true;
+      },
+      hideImportSchemaModal () {
+         this.isImportSchemaModal = false;
+         this.closeContext();
+      },
+      async initImport () {
+         const result = await Application.showOpenDialog({ properties: ['openFile'], filters: [{ name: 'SQL', extensions: ['sql'] }] });
+         if (result && !result.canceled) {
+            const file = result.filePaths[0];
+            this.showImportSchemaModal();
+            this.$nextTick(() => {
+               this.$refs.importModalRef.startImport(file);
+            });
+         }
+      },
      closeContext () {
         this.$emit('close-context');
      },
--- a/src/renderer/components/WorkspaceTabQuery.vue
+++ b/src/renderer/components/WorkspaceTabQuery.vue
@@ -46,6 +46,24 @@
                     <span>{{ $t('word.run') }}</span>
                  </button>
               </div>
+               <button
+                  v-if="!autocommit"
+                  class="btn btn-dark btn-sm"
+                  :class="{'loading':isQuering}"
+                  @click="commitTab()"
+               >
+                  <i class="mdi mdi-24px mdi-cube-send pr-1" />
+                  <span>{{ $t('word.commit') }}</span>
+               </button>
+               <button
+                  v-if="!autocommit"
+                  class="btn btn-dark btn-sm"
+                  :class="{'loading':isQuering}"
+                  @click="rollbackTab()"
+               >
+                  <i class="mdi mdi-24px mdi-undo-variant pr-1" />
+                  <span>{{ $t('word.rollback') }}</span>
+               </button>
               <button
                  class="btn btn-link btn-sm mr-0"
                  :disabled="!query || isQuering"
@@ -78,7 +96,7 @@
               </button>
               <div class="dropdown table-dropdown pr-2">
                  <button
-                     :disabled="!results.length || isQuering"
+                     :disabled="!hasResults || isQuering"
                     class="btn btn-dark btn-sm dropdown-toggle mr-0 pr-0"
                     tabindex="0"
                  >
@@ -95,6 +113,17 @@
                     </li>
                  </ul>
               </div>
+               <div class="input-group pr-2" :title="$t('message.commitMode')">
+                  <i class="input-group-addon addon-sm mdi mdi-24px mdi-source-commit p-0" />
+                  <select v-model="autocommit" class="form-select select-sm text-bold">
+                     <option :value="true">
+                        {{ $t('message.autoCommit') }}
+                     </option>
+                     <option :value="false">
+                        {{ $t('message.manualCommit') }}
+                     </option>
+                  </select>
+               </div>
            </div>
            <div class="workspace-query-info">
               <div
@@ -104,11 +133,19 @@
               >
                  <i class="mdi mdi-timer-sand mdi-rotate-180 pr-1" /> <b>{{ durationsCount / 1000 }}s</b>
               </div>
-               <div v-if="resultsCount">
-                  {{ $t('word.results') }}: <b>{{ resultsCount.toLocaleString() }}</b>
+               <div
+                  v-if="resultsCount"
+                  class="d-flex"
+                  :title="$t('word.results')"
+               >
+                  <i class="mdi mdi-equal pr-1" /> <b>{{ resultsCount.toLocaleString() }}</b>
               </div>
-               <div v-if="affectedCount !== null">
-                  {{ $t('message.affectedRows') }}: <b>{{ affectedCount }}</b>
+               <div
+                  v-if="hasAffected"
+                  class="d-flex"
+                  :title="$t('message.affectedRows')"
+               >
+                  <i class="mdi mdi-target pr-1" /> <b>{{ affectedCount }}</b>
               </div>
               <div class="input-group" :title="$t('word.schema')">
                  <i class="input-group-addon addon-sm mdi mdi-24px mdi-database" />
@@ -182,6 +219,7 @@ export default {
         isQuering: false,
         isCancelling: false,
         showCancel: false,
+         autocommit: true,
         results: [],
         selectedSchema: null,
         resultsCount: 0,
@@ -200,6 +238,9 @@ export default {
      workspace () {
         return this.getWorkspace(this.connection.uid);
      },
+      tabUid () {
+         return this.$vnode.key;
+      },
      breadcrumbsSchema () {
         return this.workspace.breadcrumbs.schema || null;
      },
@@ -214,6 +255,12 @@ export default {
      },
      history () {
         return this.getHistoryByWorkspace(this.connection.uid) || [];
+      },
+      hasResults () {
+         return this.results.length && this.results[0].rows;
+      },
+      hasAffected () {
+         return this.affectedCount || (!this.resultsCount && this.affectedCount !== null);
      }
   },
   watch: {
@@ -251,12 +298,18 @@ export default {
   },
   beforeDestroy () {
      window.removeEventListener('keydown', this.onKey);
+      const params = {
+         uid: this.connection.uid,
+         tabUid: this.tab.uid
+      };
+      Schema.destroyConnectionToCommit(params);
   },
   methods: {
      ...mapActions({
         addNotification: 'notifications/addNotification',
         changeBreadcrumbs: 'workspaces/changeBreadcrumbs',
         updateTabContent: 'workspaces/updateTabContent',
+         setUnsavedChanges: 'workspaces/setUnsavedChanges',
         saveHistory: 'history/saveHistory'
      }),
      async runQuery (query) {
@@ -270,6 +323,7 @@ export default {
               uid: this.connection.uid,
               schema: this.selectedSchema,
               tabUid: this.tab.uid,
+               autocommit: this.autocommit,
               query
            };

@@ -294,6 +348,8 @@ export default {
                  content: query
               });
               this.saveHistory(params);
+               if (!this.autocommit)
+                  this.setUnsavedChanges({ uid: this.connection.uid, tUid: this.tabUid, isChanged: true });
            }
            else
               this.addNotification({ status: 'error', message: response });
@@ -391,6 +447,42 @@ export default {
      },
      downloadTable (format) {
         this.$refs.queryTable.downloadTable(format, `${this.tab.type}-${this.tab.index}`);
+      },
+      async commitTab () {
+         this.isQuering = true;
+         try {
+            const params = {
+               uid: this.connection.uid,
+               tabUid: this.tab.uid
+            };
+
+            await Schema.commitTab(params);
+            this.setUnsavedChanges({ uid: this.connection.uid, tUid: this.tabUid, isChanged: false });
+            this.addNotification({ status: 'success', message: this.$t('message.actionSuccessful', { action: 'COMMIT' }) });
+         }
+         catch (err) {
+            this.addNotification({ status: 'error', message: err.stack });
+         }
+
+         this.isQuering = false;
+      },
+      async rollbackTab () {
+         this.isQuering = true;
+         try {
+            const params = {
+               uid: this.connection.uid,
+               tabUid: this.tab.uid
+            };
+
+            await Schema.rollbackTab(params);
+            this.setUnsavedChanges({ uid: this.connection.uid, tUid: this.tabUid, isChanged: false });
+            this.addNotification({ status: 'success', message: this.$t('message.actionSuccessful', { action: 'ROLLBACK' }) });
+         }
+         catch (err) {
+            this.addNotification({ status: 'error', message: err.stack });
+         }
+
+         this.isQuering = false;
      }
   }
 };
@@ -419,10 +511,12 @@ export default {

    .workspace-query-runner-footer {
      display: flex;
+      flex-wrap: wrap;
+      row-gap: 0.4rem;
      justify-content: space-between;
      padding: 0.3rem 0.6rem 0.4rem;
      align-items: center;
-      height: 42px;
+      min-height: 42px;

      .workspace-query-buttons,
      .workspace-query-info {
--- a/src/renderer/components/WorkspaceTabQueryTable.vue
+++ b/src/renderer/components/WorkspaceTabQueryTable.vue
@@ -175,8 +175,10 @@ export default {
         if (this.currentSort && !this.isHardSort) {
            return [...this.localResults].sort((a, b) => {
               let modifier = 1;
-               const valA = typeof a[this.currentSort] === 'string' ? a[this.currentSort].toLowerCase() : a[this.currentSort];
-               const valB = typeof b[this.currentSort] === 'string' ? b[this.currentSort].toLowerCase() : b[this.currentSort];
+               let valA = typeof a[this.currentSort] === 'string' ? a[this.currentSort].toLowerCase() : a[this.currentSort];
+               if (!isNaN(valA)) valA = Number(valA);
+               let valB = typeof b[this.currentSort] === 'string' ? b[this.currentSort].toLowerCase() : b[this.currentSort];
+               if (!isNaN(valB)) valB = Number(valB);
               if (this.currentSortDir === 'desc') modifier = -1;
               if (valA < valB) return -1 * modifier;
               if (valA > valB) return 1 * modifier;
--- a/src/renderer/components/WorkspaceTabQueryTableRow.vue
+++ b/src/renderer/components/WorkspaceTabQueryTableRow.vue
@@ -272,7 +272,8 @@ export default {
         if (BIT.includes(type)) {
            if (typeof val === 'number') val = [val];
            const hex = Buffer.from(val).toString('hex');
-            return hexToBinary(hex);
+            const bitString = hexToBinary(hex);
+            return parseInt(bitString).toString().padStart(precision, '0');
         }

         if (ARRAY.includes(type)) {
--- a/src/renderer/components/WorkspaceTabTable.vue
+++ b/src/renderer/components/WorkspaceTabTable.vue
@@ -85,7 +85,7 @@
                  @click="showFakerModal"
               >
                  <i class="mdi mdi-24px mdi-playlist-plus mr-1" />
-                  <span>{{ $t('message.tableFiller') }}</span>
+                  <span>{{ $tc('message.insertRow', 2) }}</span>
               </button>

               <div class="dropdown table-dropdown pr-2">
--- a/src/renderer/i18n/en-US.js
+++ b/src/renderer/i18n/en-US.js
@@ -80,6 +80,7 @@ module.exports = {
      deterministic: 'Deterministic',
      context: 'Context',
      export: 'Export',
+      import: 'Import',
      returns: 'Returns',
      timing: 'Timing',
      state: 'State',
@@ -122,9 +123,23 @@ module.exports = {
      select: 'Select',
      passphrase: 'Passphrase',
      filter: 'Filter',
+      change: 'Change',
+      views: 'Views',
+      triggers: 'Triggers',
+      routines: 'Routines',
+      functions: 'Functions',
+      schedulers: 'Schedulers',
+      includes: 'Includes',
+      drop: 'Drop',
+      completed: 'Completed',
+      aborted: 'Aborted',
      disabled: 'Disabled',
      enable: 'Enable',
-      disable: 'Disable'
+      disable: 'Disable',
+      commit: 'Commit',
+      rollback: 'Rollback',
+      connectionString: 'Connection string',
+      contributors: 'Contributors'
   },
   message: {
      appWelcome: 'Welcome to Antares SQL Client!',
@@ -250,9 +265,25 @@ module.exports = {
      searchForQueries: 'Search for queries',
      killProcess: 'Kill process',
      closeTab: 'Close tab',
+      exportSchema: 'Export schema',
+      importSchema: 'Import schema',
+      directoryPath: 'Directory path',
+      newInserStmtEvery: 'New INSERT statement every',
+      processingTableExport: 'Processing {table}',
+      fechingTableExport: 'Fetching {table} data',
+      writingTableExport: 'Writing {table} data',
+      checkAllTables: 'Check all tables',
+      uncheckAllTables: 'Uncheck all tables',
      goToDownloadPage: 'Go to download page',
      readOnlyMode: 'Read-only mode',
-      killQuery: 'Kill query'
+      killQuery: 'Kill query',
+      insertRow: 'Insert row | Insert rows',
+      commitMode: 'Commit mode',
+      autoCommit: 'Auto commit',
+      manualCommit: 'Manual commit',
+      actionSuccessful: '{action} successful',
+      importQueryErrors: 'Warning: {n} error has accurrend | Warning: {n} errors occurred',
+      executedQueries: '{n} query executed | {n} queries executed'
   },
   faker: {
      address: 'Address',
--- a/src/renderer/i18n/it-IT.js
+++ b/src/renderer/i18n/it-IT.js
@@ -80,6 +80,7 @@ module.exports = {
      deterministic: 'Deterministico',
      context: 'Contesto',
      export: 'Esporta',
+      import: 'Importa',
      returns: 'Ritorna',
      timing: 'Temporizzazione',
      state: 'Stato',
@@ -122,6 +123,16 @@ module.exports = {
      select: 'Seleziona',
      passphrase: 'Passphrase',
      filter: 'Filtra',
+      change: 'Cambia',
+      views: 'Viste',
+      triggers: 'Trigger',
+      routines: 'Routine',
+      functions: 'Function',
+      schedulers: 'Scheduler',
+      includes: 'Includi',
+      drop: 'Drop',
+      completed: 'Completato',
+      aborted: 'Annullato',
      disabled: 'Disabilitato',
      enable: 'Abilita',
      disable: 'Disabilita'
@@ -237,6 +248,15 @@ module.exports = {
      noOpenTabs: 'Non ci sono tab aperte, naviga nella barra sinistra o:',
      noSchema: 'Nessuno schema',
      restorePreviourSession: 'Ripristina sessione precedente',
+      exportSchema: 'Esporta schema',
+      importSchema: 'Importa schema',
+      directoryPath: 'Percorso directory',
+      newInserStmtEvery: 'Nuova istruzione INSERT ogni',
+      processingTableExport: 'Processo {table}',
+      fechingTableExport: 'Ricavo i dati {table}',
+      writingTableExport: 'Scrittura dati {table}',
+      checkAllTables: 'Seleziona tutte le tabelle',
+      uncheckAllTables: 'Deseleziona tutte le tabelle',
      runQuery: 'Esegui query',
      thereAreNoTableFields: 'Non ci sono campi della tabella',
      newTable: 'Nuova tabella',
@@ -251,7 +271,9 @@ module.exports = {
      killProcess: 'Uccidi processo',
      closeTab: 'Chiudi tab',
      goToDownloadPage: 'Vai alla pagina di download',
-      readOnlyMode: 'Modalità sola lettura'
+      readOnlyMode: 'Modalità sola lettura',
+      importQueryErrors: 'Attenzione: si è verificato un errore | Attenzione si sono verificati {n} errori',
+      executedQueries: '{n} query eseguite | {n} query eseguite'
   },
   faker: {
      address: 'Indirizzo',
--- a/src/renderer/ipc-api/Application.js
+++ b/src/renderer/ipc-api/Application.js
@@ -5,4 +5,12 @@ export default class {
   static getKey (params) {
      return ipcRenderer.sendSync('get-key', params);
   }
+
+   static showOpenDialog (options) {
+      return ipcRenderer.invoke('showOpenDialog', options);
+   }
+
+   static getDownloadPathDirectory () {
+      return ipcRenderer.invoke('get-download-dir-path');
+   }
 }
--- a/src/renderer/ipc-api/Connection.js
+++ b/src/renderer/ipc-api/Connection.js
@@ -1,17 +1,21 @@
 'use strict';
 import { ipcRenderer } from 'electron';

+import connStringConstruct from '../libs/connStringDecode';
+
 export default class {
   static makeTest (params) {
+      params = connStringConstruct(params);
      return ipcRenderer.invoke('test-connection', params);
   }

-   static checkConnection (params) {
-      return ipcRenderer.invoke('check-connection', params);
+   static connect (params) {
+      params = connStringConstruct(params);
+      return ipcRenderer.invoke('connect', params);
   }

-   static connect (params) {
-      return ipcRenderer.invoke('connect', params);
+   static checkConnection (uid) {
+      return ipcRenderer.invoke('check-connection', uid);
   }

   static disconnect (uid) {
--- a/src/renderer/ipc-api/Schema.js
+++ b/src/renderer/ipc-api/Schema.js
@@ -50,6 +50,18 @@ export default class {
      return ipcRenderer.invoke('kill-tab-query', params);
   }

+   static commitTab (params) {
+      return ipcRenderer.invoke('commit-tab', params);
+   }
+
+   static rollbackTab (params) {
+      return ipcRenderer.invoke('rollback-tab', params);
+   }
+
+   static destroyConnectionToCommit (params) {
+      return ipcRenderer.invoke('destroy-connection-to-commit', params);
+   }
+
   static useSchema (params) {
      return ipcRenderer.invoke('use-schema', params);
   }
@@ -57,4 +69,20 @@ export default class {
   static rawQuery (params) {
      return ipcRenderer.invoke('raw-query', params);
   }
+
+   static export (params) {
+      return ipcRenderer.invoke('export', params);
+   }
+
+   static abortExport () {
+      return ipcRenderer.invoke('abort-export');
+   }
+
+   static import (params) {
+      return ipcRenderer.invoke('import-sql', params);
+   }
+
+   static abortImport () {
+      return ipcRenderer.invoke('abort-import-sql');
+   }
 }
--- a/src/renderer/libs/connStringDecode.js
+++ b/src/renderer/libs/connStringDecode.js
@@ -0,0 +1,48 @@
+import formatter from 'pg-connection-string'; // parses a connection string
+
+const formatHost = host => {
+   const results = host === 'localhost' ? '127.0.0.1' : host;
+   return results;
+};
+
+const checkForSSl = conn => {
+   return conn.includes('ssl=true');
+};
+
+const connStringConstruct = (args) => {
+   if (!args.pgConnString)
+      return args;
+
+   if (typeof args.pgConnString !== 'string')
+      return args;
+
+   const stringArgs = formatter.parse(args.pgConnString);
+
+   const client = args.client || 'pg';
+
+   args.client = client;
+   args.host = formatHost(stringArgs.host);
+   args.database = stringArgs.database;
+   args.port = stringArgs.port || '5432';
+   args.user = stringArgs.user;
+   args.password = stringArgs.password;
+
+   // ssh
+   args.ssh = stringArgs.ssh || args.ssh;
+   args.sshHost = stringArgs.sshHost;
+   args.sshUser = stringArgs.sshUser;
+   args.sshPass = stringArgs.sshPass;
+   args.sshKey = stringArgs.sshKey;
+   args.sshPort = stringArgs.sshPort;
+
+   // ssl mode
+   args.ssl = checkForSSl(args.pgConnString);
+   args.cert = stringArgs.sslcert;
+   args.key = stringArgs.sslkey;
+   args.ca = stringArgs.sslrootcert;
+   args.ciphers = stringArgs.ciphers;
+
+   return args;
+};
+
+export default connStringConstruct;
--- a/src/renderer/scss/main.scss
+++ b/src/renderer/scss/main.scss
@@ -165,6 +165,15 @@ option:checked {
      }
    }
  }
+  
+  .modal-overlay{
+    background: rgba( 255, 255, 255, 0.1 );
+    box-shadow: 0 8px 32px 0 rgba( 31, 38, 135, 0.37 );
+    backdrop-filter: blur( 4px );
+    -webkit-backdrop-filter: blur( 4px );
+    border-radius: 10px;
+    border: 1px solid rgba( 255, 255, 255, 0.18 );
+  }
 }

 .tab {
--- a/tests/app.spec.js
+++ b/tests/app.spec.js
@@ -1,25 +1,11 @@
 const { _electron: electron } = require('playwright');
 const { strict: assert } = require('assert');

-const isWindows = process.platform === 'win32';
-async function wait (ms) {
-   return new Promise(resolve => {
-      setTimeout(resolve, ms);
-   });
-}
-
 (async () => {
-   if (isWindows) {
-      console.log('Termporary skipping tests on Windows');
-      return;
-   }
-
   console.log('Starting tests');
   // Launch Electron app.
   const electronApp = await electron.launch({ args: ['dist/main.js'] });

-   if (isWindows) await wait(5000);
-
   /**
     * App main window state
     * @type {{isVisible: boolean; isDevToolsOpened: boolean; isCrashed: boolean}}
--- a/webpack.main.config.js
+++ b/webpack.main.config.js
@@ -1,15 +1,14 @@
 const path = require('path');
-const { CleanWebpackPlugin } = require('clean-webpack-plugin');
+const webpack = require('webpack');
 const ProgressPlugin = require('progress-webpack-plugin');

-const { dependencies, devDependencies } = require('./package.json');
+const { dependencies, devDependencies, version } = require('./package.json');

 const externals = Object.keys(dependencies).concat(Object.keys(devDependencies));
 const isDevMode = process.env.NODE_ENV === 'development';
 const whiteListedModules = [];

-module.exports = [
-   { // Main
+module.exports = { // Main
   name: 'main',
   mode: process.env.NODE_ENV,
   devtool: isDevMode ? 'eval-source-map' : false,
@@ -42,7 +41,11 @@ module.exports = [
   },
   plugins: [
      new ProgressPlugin(true),
-         new CleanWebpackPlugin({ root: path.join(__dirname, 'dist') })
+      new webpack.DefinePlugin({
+         'process.env': {
+            PACKAGE_VERSION: `"${version}"`
+         }
+      })
   ],
   module: {
      rules: [
@@ -66,5 +69,4 @@ module.exports = [
         }
      ]
   }
-   }
-];
+};
--- a/webpack.renderer.config.js
+++ b/webpack.renderer.config.js
@@ -1,3 +1,4 @@
+const fs = require('fs');
 const path = require('path');
 const webpack = require('webpack');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
@@ -6,6 +7,11 @@ const MiniCssExtractPlugin = require('mini-css-extract-plugin');
 const ProgressPlugin = require('progress-webpack-plugin');

 const { dependencies, devDependencies, version } = require('./package.json');
+const { contributors } = JSON.parse(fs.readFileSync('./.all-contributorsrc', 'utf-8'));
+const parsedContributors = contributors.reduce((acc, c) => {
+   acc.push(c.name);
+   return acc;
+}, []).join(',');

 const externals = Object.keys(dependencies).concat(Object.keys(devDependencies));
 const isDevMode = process.env.NODE_ENV === 'development';
@@ -64,7 +70,8 @@ const config = {
      new VueLoaderPlugin(),
      new webpack.DefinePlugin({
         'process.env': {
-            PACKAGE_VERSION: `"${version}"`
+            PACKAGE_VERSION: `"${version}"`,
+            APP_CONTRIBUTORS: `"${parsedContributors}"`
         }
      })
   ],
--- a/webpack.workers.config.js
+++ b/webpack.workers.config.js
@@ -0,0 +1,81 @@
+const path = require('path');
+const webpack = require('webpack');
+const ProgressPlugin = require('progress-webpack-plugin');
+
+const { dependencies, devDependencies, version } = require('./package.json');
+
+const externals = Object.keys(dependencies).concat(Object.keys(devDependencies));
+const isDevMode = process.env.NODE_ENV === 'development';
+const whiteListedModules = [];
+
+const config = {
+   name: 'workers',
+   mode: process.env.NODE_ENV,
+   devtool: isDevMode ? 'eval-source-map' : false,
+   entry: {
+      exporter: path.join(__dirname, './src/main/workers/exporter.js'),
+      importer: path.join(__dirname, './src/main/workers/importer.js')
+   },
+   target: 'node',
+   output: {
+      libraryTarget: 'commonjs2',
+      path: path.join(__dirname, 'dist'),
+      filename: '[name].js'
+   },
+   node: {
+      global: true,
+      __dirname: isDevMode,
+      __filename: isDevMode
+   },
+   externals: externals.filter((d) => !whiteListedModules.includes(d)),
+   module: {
+      rules: [
+         {
+            test: /\.js$/,
+            use: 'babel-loader',
+            exclude: /node_modules/
+         },
+         {
+            test: /\.node$/,
+            use: 'node-loader'
+         }
+      ]
+   },
+   resolve: {
+      extensions: ['.js', '.json'],
+      alias: {
+         src: path.join(__dirname, 'src/'),
+         common: path.resolve(__dirname, 'src/common')
+      },
+      fallback: {
+         'pg-native': false,
+         'cpu-features': false,
+         cardinal: false
+      }
+   },
+   plugins: [
+      new ProgressPlugin(true),
+      new webpack.DefinePlugin({
+         'process.env': {
+            PACKAGE_VERSION: `"${version}"`
+         }
+      })
+   ]
+};
+
+/**
+ * Adjust rendererConfig for production settings
+ */
+if (isDevMode) {
+   // any dev only config
+   config.plugins.push(new webpack.HotModuleReplacementPlugin());
+}
+else {
+   config.plugins.push(
+      new webpack.LoaderOptionsPlugin({
+         minimize: true
+      })
+   );
+}
+
+module.exports = config;
Author	SHA1	Message	Date
Fabio Di Stasio	9109b2c328	chore(release): 0.5.0	2022-03-12 14:25:04 +01:00
Fabio Di Stasio	dd070d008d	Merge pull request #129 from toriphes/feat/db-import-export feat(MySQL): db import export	2022-03-12 14:17:48 +01:00
Fabio Di Stasio	ee415da127	fix(MySQL): exception exporting empty procedures/functions	2022-03-12 10:37:40 +01:00
Fabio Di Stasio	f0d368e3e3	refactor: minor refactor	2022-03-12 10:01:22 +01:00
Fabio Di Stasio	4be55f3fe9	feat(MySQL): support to multi spatial fields export	2022-03-12 09:52:40 +01:00
Fabio Di Stasio	fd00ea42ee	refactor: hide export option for PostgreSQL	2022-03-10 10:54:44 +01:00
Fabio Di Stasio	50b4411e9a	Merge pull request #204 from raliqala/fix-and-minimize-con-string perf(PostgreSQL): ⚡Postgres connection string update, better error handling and any connection string accommodation	2022-03-10 10:52:10 +01:00
Topollo	cd0a5dc034	Merge branch 'fix-and-minimize-con-string' of https://github.com/raliqala/antares into fix-and-minimize-con-string	2022-03-10 11:45:54 +02:00
Topollo	9fd427c4ff	removed electron-rebuild	2022-03-10 11:44:52 +02:00
Fabio Di Stasio	f3759b6541	perf(MySQL): prevent memory leak on large dump import	2022-03-10 10:23:22 +01:00
Fabio Di Stasio	191a354020	chore: delete UsersraliqAppDataLocalnpm-cache_logs2022-03-05T07_59_37_036Z-debug.log	2022-03-10 09:02:16 +01:00
Topollo	7dc314eecf	Merge branch 'master' into fix-and-minimize-con-string	2022-03-09 22:14:28 +02:00
Topollo	330a80fe70	perf(PostgreSQL): ⚡ Postgres connection update, better error handling and connection string accommodation. Used the pg package parser function to handle connection strings to lowering chances of errors. All other connection string will work here an example for ssl ```const args = "postgres://user:password@localhost:5432/db?&sslrootcert=./myCaCertificate.pem&sslcert=./myClientCertificate.pem&sslkey=./myPrivateClientKey.pem&ciphers=mytestcipher&ssl=true"``` for ssh these can be used ```ssh: false, sshHost: '', sshUser: '', sshPass: '', sshKey: '', sshPort: 22,``` no breaking changes	2022-03-09 21:52:13 +02:00
Topollo	b2ce533b82	Merge branch 'postgres_con_string' into fix-and-minimize-con-string	2022-03-09 19:41:31 +02:00
Topollo	12ce6b1135	Update testStringDecode.js	2022-03-09 19:40:04 +02:00
Topollo	71c5829702	hi	2022-03-09 19:31:41 +02:00
Fabio Di Stasio	1c4d5b05b3	feat(UI): toggle tables checkbox by column on export modal	2022-03-07 23:07:42 +01:00
Fabio Di Stasio	e85197a2cc	chore: UsersraliqAppDataLocalnpm-cache_logs2022-03-05T07_59_37_036Z-debug.log	2022-03-07 20:10:44 +01:00
Giulio Ganci	abf2b92e6e	feat(UI): auto-refresh schema at the end of the import process	2022-03-06 19:54:32 +01:00
Giulio Ganci	3be826df4b	feat(MySQL): enhance export characters escaping	2022-03-06 19:37:12 +01:00
Fabio Di Stasio	9db6bfd255	refactor: show contributors in settings	2022-03-06 16:02:24 +01:00
allcontributors[bot]	110adf90de	docs: update .all-contributorsrc [skip ci]	2022-03-06 09:48:30 +01:00
allcontributors[bot]	40e4fbda15	docs: update README.md [skip ci]	2022-03-06 09:48:30 +01:00
Fabio Di Stasio	8e983ad2cb	refactor(PostgreSQL): minor refactor on UI and code for pg connection string	2022-03-06 09:45:55 +01:00
Topollo	6305752ad1	feat(PostgreSQL): ✨ Postgress connection string feature for local and server connection string This feature is based on this [issue](https://github.com/Fabio286/antares/issues/193) I tested with the following posgress connection strings postgresql://postgres:pgpassword@127.0.0.1:5432/my_local_databse?connection=local postgres://serveruser:serverpass@test.db.elephantsql.com/my_remote_databse?connection=server postgres://serveruser:serverpass@test.db.elephantsql.com:5432/my_remote_databse postgresql://postgres:pgpassword@127.0.0.1:5432/my_local_databse. The connection string decoder is loaded before "test-connection", "check-connection", and "connect"	2022-03-06 09:45:55 +01:00
Fabio Di Stasio	cc02e2c5a8	refactor(PostgreSQL): minor refactor on UI and code for pg connection string	2022-03-06 09:40:11 +01:00
Topollo	f4a63eae2a	feat(PostgreSQL): ✨ Postgress connection string feature for local and server connection string This feature is based on this [issue](https://github.com/Fabio286/antares/issues/193) I tested with the following posgress connection strings postgresql://postgres:pgpassword@127.0.0.1:5432/my_local_databse?connection=local postgres://serveruser:serverpass@test.db.elephantsql.com/my_remote_databse?connection=server postgres://serveruser:serverpass@test.db.elephantsql.com:5432/my_remote_databse postgresql://postgres:pgpassword@127.0.0.1:5432/my_local_databse. The connection string decoder is loaded before "test-connection", "check-connection", and "connect"	2022-03-06 02:20:10 +02:00
Fabio Di Stasio	763be8532d	fix: wrong soft sort algorithm for numeric fields, closes #199	2022-03-05 21:58:56 +01:00
Giulio Ganci	a6f5645a22	feat(UI): better real-time import stats	2022-03-05 18:55:11 +01:00
Giulio Ganci	bbe13f27dc	perf(MySQL): import tasks managed with async queue	2022-03-05 18:54:08 +01:00
Fabio Di Stasio	f444746f46	perf(MySQL): import performance improvement	2022-03-05 17:00:05 +01:00
Fabio Di Stasio	b4af645941	fix(MySQL):spatial fielts support on export	2022-03-03 22:52:50 +01:00
Fabio Di Stasio	a5c8daa5b8	chore: workers debug config	2022-03-01 22:15:33 +01:00
Fabio Di Stasio	1a9fc37285	fix(MySQL): missing initial delimiter for exported procedures	2022-03-01 19:05:53 +01:00
Fabio Di Stasio	f0351e5b94	fix(MySQL): missing functions and procedures definer escapes on exporter	2022-03-01 10:15:06 +01:00
Fabio Di Stasio	9bda4e71b7	Merge branch 'feat/db-import-export' of https://github.com/toriphes/antares into pr/toriphes/129	2022-02-28 23:33:16 +01:00
Fabio Di Stasio	7c00055034	Merge branch 'master' of https://github.com/Fabio286/antares into pr/toriphes/129	2022-02-28 22:00:13 +01:00
Fabio Di Stasio	4479a9600b	fix: wrong schema and table size on explore bar	2022-02-28 14:19:07 +01:00
Giulio Ganci	7a6bd8bdbd	fix: sql parser hangs during import	2022-02-27 17:33:03 +01:00
Fabio Di Stasio	ad713fcf35	chore(release): 0.4.4	2022-02-27 14:07:24 +01:00
Fabio Di Stasio	251795e2d2	Merge branch 'master' into feat/db-import-export	2022-02-26 10:19:15 +01:00
Fabio Di Stasio	45cda7a7cc	Merge branch 'master' of https://github.com/Fabio286/antares into pr/toriphes/129	2022-02-26 10:14:00 +01:00
Fabio Di Stasio	b7039553cc	fix: bigint support, closes #197	2022-02-26 10:02:23 +01:00
Fabio Di Stasio	ddee68b4c2	ci: set windows-2019 for GitHub Actions	2022-02-26 10:01:46 +01:00
Fabio Di Stasio	573ac6d42e	perf: use fork() for the import process	2022-02-24 13:14:57 +01:00
Fabio Di Stasio	265f28b4d9	fix: zero-padded bit fields beyond length	2022-02-21 21:40:26 +01:00
Fabio Di Stasio	1990d9a3d4	perf(MySQL): improved several field types support on exporter	2022-02-19 12:40:54 +01:00
Fabio Di Stasio	748d44977e	perf: use fork() for the export process	2022-02-18 18:16:13 +01:00
Fabio Di Stasio	4051eff382	build: webpack workers configuration	2022-02-17 18:47:50 +01:00
Fabio Di Stasio	4276586e11	fix(MySQL): procedures exportation	2022-02-16 12:58:24 +01:00
Fabio Di Stasio	832fb0fb03	Merge branch 'feat/db-import-export' of https://github.com/toriphes/antares into pr/toriphes/129	2022-02-16 09:16:14 +01:00
Fabio Di Stasio	328ab61757	Merge branch 'master' of https://github.com/Fabio286/antares into pr/toriphes/129	2022-02-16 09:14:46 +01:00
Fabio Di Stasio	95d15de1bd	chore: update README.md	2022-02-16 08:57:54 +01:00
Fabio Di Stasio	7dcd4441c4	feat(SQLite): manual commit mode	2022-02-15 09:23:07 +01:00
Fabio Di Stasio	d81e0911ab	feat(PostgreSQL): manual commit mode	2022-02-15 09:23:07 +01:00
Fabio Di Stasio	5bfff649e9	feat: reminder for uncommitted changes closing a tab	2022-02-15 09:23:07 +01:00
Fabio Di Stasio	76743e8f7c	feat: execution notification for ROLLBACK and COMMIT	2022-02-15 09:23:07 +01:00
Fabio Di Stasio	4ed2f9a939	feat(MySQL): manual commit mode	2022-02-15 09:23:07 +01:00
Fabio Di Stasio	c5eb73ed3f	chore: update electron	2022-02-15 09:21:14 +01:00
Fabio Di Stasio	fa3f3e1fd8	fix(MySQL): default value not displayed for DECIMAL fields	2022-02-05 09:43:37 +01:00
Giulio Ganci	4e9f8d16ee	feat: initial mysql import support	2021-12-28 15:30:07 +01:00
Giulio Ganci	d25c62b4da	feat: delete dump file when the export is canceled	2021-11-04 23:09:28 +01:00
Giulio Ganci	8cf738bac8	fix(MySQL): export crash with large databases	2021-11-04 22:36:45 +01:00
Fabio Di Stasio	409ed54608	perf: split the export select query to avoid running out of memory	2021-11-01 16:12:20 +01:00
Fabio Di Stasio	d9d3bf2bc9	perf: avoid to load schema elements if already loaded in export modal	2021-11-01 14:52:45 +01:00
Fabio Di Stasio	9e9de7b5c5	Merge branch 'master' of https://github.com/Fabio286/antares into pr/toriphes/129	2021-11-01 10:09:37 +01:00
Giulio Ganci	b2a5b40c03	feat: mysql export for trigger, views, schedulers, functions and routines	2021-10-31 17:22:59 +01:00
Giulio Ganci	0de2321920	feat: initial db export implementation	2021-10-29 12:58:37 +02:00