added plugins

2026-04-18 02:06:01 +00:00 · 2021-04-13 16:17:53 +02:00
parent 446e7c139f
commit 4d5cc119f2
115 changed files with 5519 additions and 24 deletions
--- a/plugins/dbgate-plugin-postgres/LICENSE
+++ b/plugins/dbgate-plugin-postgres/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jan Prochazka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/plugins/dbgate-plugin-postgres/README.md
+++ b/plugins/dbgate-plugin-postgres/README.md
@@ -0,0 +1,6 @@
+[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
+[![NPM version](https://img.shields.io/npm/v/dbgate-plugin-postgres.svg)](https://www.npmjs.com/package/dbgate-plugin-postgres)
+
+# dbgate-plugin-postgres
+
+Use DbGate for install of this plugin
--- a/plugins/dbgate-plugin-postgres/icon.svg
+++ b/plugins/dbgate-plugin-postgres/icon.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+
+<svg width="432.071pt" height="445.383pt" viewBox="0 0 432.071 445.383" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+<g id="orginal" style="fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	</g>
+<g id="Layer_x0020_3" style="fill-rule:nonzero;clip-rule:nonzero;fill:none;stroke:#FFFFFF;stroke-width:12.4651;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;">
+<path style="fill:#000000;stroke:#000000;stroke-width:37.3953;stroke-linecap:butt;stroke-linejoin:miter;" d="M323.205,324.227c2.833-23.601,1.984-27.062,19.563-23.239l4.463,0.392c13.517,0.615,31.199-2.174,41.587-7c22.362-10.376,35.622-27.7,13.572-23.148c-50.297,10.376-53.755-6.655-53.755-6.655c53.111-78.803,75.313-178.836,56.149-203.322    C352.514-5.534,262.036,26.049,260.522,26.869l-0.482,0.089c-9.938-2.062-21.06-3.294-33.554-3.496c-22.761-0.374-40.032,5.967-53.133,15.904c0,0-161.408-66.498-153.899,83.628c1.597,31.936,45.777,241.655,98.47,178.31    c19.259-23.163,37.871-42.748,37.871-42.748c9.242,6.14,20.307,9.272,31.912,8.147l0.897-0.765c-0.281,2.876-0.157,5.689,0.359,9.019c-13.572,15.167-9.584,17.83-36.723,23.416c-27.457,5.659-11.326,15.734-0.797,18.367c12.768,3.193,42.305,7.716,62.268-20.224    l-0.795,3.188c5.325,4.26,4.965,30.619,5.72,49.452c0.756,18.834,2.017,36.409,5.856,46.771c3.839,10.36,8.369,37.05,44.036,29.406c29.809-6.388,52.6-15.582,54.677-101.107"/>
+<path style="fill:#336791;stroke:none;" d="M402.395,271.23c-50.302,10.376-53.76-6.655-53.76-6.655c53.111-78.808,75.313-178.843,56.153-203.326c-52.27-66.785-142.752-35.2-144.262-34.38l-0.486,0.087c-9.938-2.063-21.06-3.292-33.56-3.496c-22.761-0.373-40.026,5.967-53.127,15.902    c0,0-161.411-66.495-153.904,83.63c1.597,31.938,45.776,241.657,98.471,178.312c19.26-23.163,37.869-42.748,37.869-42.748c9.243,6.14,20.308,9.272,31.908,8.147l0.901-0.765c-0.28,2.876-0.152,5.689,0.361,9.019c-13.575,15.167-9.586,17.83-36.723,23.416    c-27.459,5.659-11.328,15.734-0.796,18.367c12.768,3.193,42.307,7.716,62.266-20.224l-0.796,3.188c5.319,4.26,9.054,27.711,8.428,48.969c-0.626,21.259-1.044,35.854,3.147,47.254c4.191,11.4,8.368,37.05,44.042,29.406c29.809-6.388,45.256-22.942,47.405-50.555    c1.525-19.631,4.976-16.729,5.194-34.28l2.768-8.309c3.192-26.611,0.507-35.196,18.872-31.203l4.463,0.392c13.517,0.615,31.208-2.174,41.591-7c22.358-10.376,35.618-27.7,13.573-23.148z"/>
+<path d="M215.866,286.484c-1.385,49.516,0.348,99.377,5.193,111.495c4.848,12.118,15.223,35.688,50.9,28.045c29.806-6.39,40.651-18.756,45.357-46.051c3.466-20.082,10.148-75.854,11.005-87.281"/>
+<path d="M173.104,38.256c0,0-161.521-66.016-154.012,84.109c1.597,31.938,45.779,241.664,98.473,178.316c19.256-23.166,36.671-41.335,36.671-41.335"/>
+<path d="M260.349,26.207c-5.591,1.753,89.848-34.889,144.087,34.417c19.159,24.484-3.043,124.519-56.153,203.329"/>
+<path style="stroke-linejoin:bevel;" d="M348.282,263.953c0,0,3.461,17.036,53.764,6.653c22.04-4.552,8.776,12.774-13.577,23.155c-18.345,8.514-59.474,10.696-60.146-1.069c-1.729-30.355,21.647-21.133,19.96-28.739c-1.525-6.85-11.979-13.573-18.894-30.338    c-6.037-14.633-82.796-126.849,21.287-110.183c3.813-0.789-27.146-99.002-124.553-100.599c-97.385-1.597-94.19,119.762-94.19,119.762"/>
+<path d="M188.604,274.334c-13.577,15.166-9.584,17.829-36.723,23.417c-27.459,5.66-11.326,15.733-0.797,18.365c12.768,3.195,42.307,7.718,62.266-20.229c6.078-8.509-0.036-22.086-8.385-25.547c-4.034-1.671-9.428-3.765-16.361,3.994z"/>
+<path d="M187.715,274.069c-1.368-8.917,2.93-19.528,7.536-31.942c6.922-18.626,22.893-37.255,10.117-96.339c-9.523-44.029-73.396-9.163-73.436-3.193c-0.039,5.968,2.889,30.26-1.067,58.548c-5.162,36.913,23.488,68.132,56.479,64.938"/>
+<path style="fill:#FFFFFF;stroke-width:4.155;stroke-linecap:butt;stroke-linejoin:miter;" d="M172.517,141.7c-0.288,2.039,3.733,7.48,8.976,8.207c5.234,0.73,9.714-3.522,9.998-5.559c0.284-2.039-3.732-4.285-8.977-5.015c-5.237-0.731-9.719,0.333-9.996,2.367z"/>
+<path style="fill:#FFFFFF;stroke-width:2.0775;stroke-linecap:butt;stroke-linejoin:miter;" d="M331.941,137.543c0.284,2.039-3.732,7.48-8.976,8.207c-5.238,0.73-9.718-3.522-10.005-5.559c-0.277-2.039,3.74-4.285,8.979-5.015c5.239-0.73,9.718,0.333,10.002,2.368z"/>
+<path d="M350.676,123.432c0.863,15.994-3.445,26.888-3.988,43.914c-0.804,24.748,11.799,53.074-7.191,81.435"/>
+<path style="stroke-width:3;" d="M0,60.232"/>
+</g>
+</svg>
--- a/plugins/dbgate-plugin-postgres/package.json
+++ b/plugins/dbgate-plugin-postgres/package.json
@@ -0,0 +1,39 @@
+{
+  "name": "dbgate-plugin-postgres",
+  "main": "dist/backend.js",
+  "version": "1.2.2",
+  "license": "MIT",
+  "description": "PostgreSQL connector plugin for DbGate",
+  "homepage": "https://github.com/dbgate/dbgate-plugin-postgres",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dbgate/dbgate-plugin-postgres.git"
+  },
+  "funding": "https://www.paypal.com/paypalme/JanProchazkaCz/30eur",
+  "author": "Jan Prochazka",
+  "keywords": [
+    "dbgate",
+    "dbgateplugin",
+    "postgresql"
+  ],
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:frontend": "webpack --config webpack-frontend.config",
+    "build:backend": "webpack --config webpack-backend.config.js",
+    "build": "yarn build:frontend && yarn build:backend",
+    "plugin": "yarn build && yarn pack && dbgate-plugin dbgate-plugin-postgres",
+    "plugout": "dbgate-plugout dbgate-plugin-postgres",
+    "prepublishOnly": "yarn build"
+  },
+  "devDependencies": {
+    "dbgate-plugin-tools": "^1.0.4",
+    "dbgate-tools": "^4.0.3-rc.1",
+    "lodash": "^4.17.15",
+    "pg": "^7.17.0",
+    "pg-query-stream": "^3.1.1",
+    "webpack": "^4.42.0",
+    "webpack-cli": "^3.3.11"
+  }
+}
--- a/plugins/dbgate-plugin-postgres/prettier.config.js
+++ b/plugins/dbgate-plugin-postgres/prettier.config.js
@@ -0,0 +1,9 @@
+module.exports = {
+  trailingComma: 'es5',
+  tabWidth: 2,
+  semi: true,
+  singleQuote: true,
+  arrowParen: 'avoid',
+  arrowParens: 'avoid',
+  printWidth: 120,
+};
--- a/plugins/dbgate-plugin-postgres/src/backend/Analyser.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/Analyser.js
@@ -0,0 +1,185 @@
+const fp = require('lodash/fp');
+const _ = require('lodash');
+const sql = require('./sql');
+
+const { DatabaseAnalyser } = require('dbgate-tools');
+const { isTypeString, isTypeNumeric } = require('dbgate-tools');
+
+function normalizeTypeName(dataType) {
+  if (dataType == 'character varying') return 'varchar';
+  if (dataType == 'timestamp without time zone') return 'timestamp';
+  return dataType;
+}
+
+function getColumnInfo({
+  isNullable,
+  isIdentity,
+  columnName,
+  dataType,
+  charMaxLength,
+  numericPrecision,
+  numericScale,
+  defaultValue,
+}) {
+  const normDataType = normalizeTypeName(dataType);
+  let fullDataType = normDataType;
+  if (charMaxLength && isTypeString(normDataType)) fullDataType = `${normDataType}(${charMaxLength})`;
+  if (numericPrecision && numericScale && isTypeNumeric(normDataType))
+    fullDataType = `${normDataType}(${numericPrecision},${numericScale})`;
+  return {
+    columnName,
+    dataType: fullDataType,
+    notNull: !isNullable || isNullable == 'NO' || isNullable == 'no',
+    autoIncrement: !!isIdentity,
+    defaultValue,
+  };
+}
+
+class Analyser extends DatabaseAnalyser {
+  constructor(pool, driver) {
+    super(pool, driver);
+  }
+
+  createQuery(resFileName, typeFields) {
+    let res = sql[resFileName];
+
+    if (this.singleObjectFilter) {
+      const { typeField, schemaName, pureName } = this.singleObjectFilter;
+      if (!typeFields || !typeFields.includes(typeField)) return null;
+      res = res.replace(/=OBJECT_ID_CONDITION/g, ` = '${typeField}:${schemaName || 'public'}.${pureName}'`);
+      return res;
+    }
+    if (!this.modifications || !typeFields || this.modifications.length == 0) {
+      res = res.replace(/=OBJECT_ID_CONDITION/g, ' is not null');
+    } else {
+      const filterNames = this.modifications
+        .filter(x => typeFields.includes(x.objectTypeField) && (x.action == 'add' || x.action == 'change'))
+        .filter(x => x.newName)
+        .map(x => `${x.objectTypeField}:${x.newName.schemaName}.${x.newName.pureName}`);
+      if (filterNames.length == 0) {
+        res = res.replace(/=OBJECT_ID_CONDITION/g, ' IS NULL');
+      } else {
+        res = res.replace(/=OBJECT_ID_CONDITION/g, ` in (${filterNames.map(x => `'${x}'`).join(',')})`);
+      }
+    }
+    return res;
+
+    // let res = sql[resFileName];
+    // res = res.replace('=[OBJECT_ID_CONDITION]', ' is not null');
+    // return res;
+  }
+  async _runAnalysis() {
+    const tables = await this.driver.query(this.pool, this.createQuery('tableModifications', ['tables']));
+    const columns = await this.driver.query(this.pool, this.createQuery('columns', ['tables']));
+    const pkColumns = await this.driver.query(this.pool, this.createQuery('primaryKeys', ['tables']));
+    const fkColumns = await this.driver.query(this.pool, this.createQuery('foreignKeys', ['tables']));
+    const views = await this.driver.query(this.pool, this.createQuery('views', ['views']));
+    const routines = await this.driver.query(this.pool, this.createQuery('routines', ['procedures', 'functions']));
+    // console.log('PG fkColumns', fkColumns.rows);
+
+    return this.mergeAnalyseResult({
+      tables: tables.rows.map(table => ({
+        ...table,
+        objectId: `tables:${table.schemaName}.${table.pureName}`,
+        columns: columns.rows
+          .filter(col => col.pureName == table.pureName && col.schemaName == table.schemaName)
+          .map(getColumnInfo),
+        primaryKey: DatabaseAnalyser.extractPrimaryKeys(table, pkColumns.rows),
+        foreignKeys: DatabaseAnalyser.extractForeignKeys(table, fkColumns.rows),
+      })),
+      views: views.rows.map(view => ({
+        ...view,
+        objectId: `views:${view.schemaName}.${view.pureName}`,
+        columns: columns.rows
+          .filter(col => col.pureName == view.pureName && col.schemaName == view.schemaName)
+          .map(getColumnInfo),
+      })),
+      procedures: routines.rows
+        .filter(x => x.objectType == 'PROCEDURE')
+        .map(proc => ({
+          objectId: `procedures:${proc.schemaName}.${proc.pureName}`,
+          ...proc,
+        })),
+      functions: routines.rows
+        .filter(x => x.objectType == 'FUNCTION')
+        .map(func => ({
+          objectId: `functions:${func.schemaName}.${func.pureName}`,
+          ...func,
+        })),
+    });
+  }
+
+  async getModifications() {
+    const tableModificationsQueryData = await this.driver.query(this.pool, this.createQuery('tableModifications'));
+    const viewModificationsQueryData = await this.driver.query(this.pool, this.createQuery('viewModifications'));
+    const routineModificationsQueryData = await this.driver.query(this.pool, this.createQuery('routineModifications'));
+
+    const allModifications = _.compact([
+      ...tableModificationsQueryData.rows.map(x => ({ ...x, objectTypeField: 'tables' })),
+      ...viewModificationsQueryData.rows.map(x => ({ ...x, objectTypeField: 'views' })),
+      ...routineModificationsQueryData.rows
+        .filter(x => x.objectType == 'PROCEDURE')
+        .map(x => ({ ...x, objectTypeField: 'procedures' })),
+      ...routineModificationsQueryData.rows
+        .filter(x => x.objectType == 'FUNCTION')
+        .map(x => ({ ...x, objectTypeField: 'functions' })),
+    ]);
+
+    const modifications = allModifications.map(x => {
+      const { objectTypeField, hashCode, pureName, schemaName } = x;
+
+      if (!objectTypeField || !this.structure[objectTypeField]) return null;
+      const obj = this.structure[objectTypeField].find(x => x.pureName == pureName && x.schemaName == schemaName);
+
+      // object not modified
+      if (obj && obj.hashCode == hashCode) return null;
+
+      // console.log('MODIFICATION OF ', objectTypeField, schemaName, pureName);
+
+      /** @type {import('dbgate-types').DatabaseModification} */
+      const action = obj
+        ? {
+            newName: { schemaName, pureName },
+            oldName: _.pick(obj, ['schemaName', 'pureName']),
+            action: 'change',
+            objectTypeField,
+            objectId: `${objectTypeField}:${schemaName}.${pureName}`,
+          }
+        : {
+            newName: { schemaName, pureName },
+            action: 'add',
+            objectTypeField,
+            objectId: `${objectTypeField}:${schemaName}.${pureName}`,
+          };
+      return action;
+    });
+
+    return [
+      ..._.compact(modifications),
+      ...this.getDeletedObjects([...allModifications.map(x => `${x.schemaName}.${x.pureName}`)]),
+    ];
+  }
+
+  getDeletedObjectsForField(nameArray, objectTypeField) {
+    return this.structure[objectTypeField]
+      .filter(x => !nameArray.includes(`${x.schemaName}.${x.pureName}`))
+      .map(x => ({
+        oldName: _.pick(x, ['schemaName', 'pureName']),
+        action: 'remove',
+        objectTypeField,
+        objectId: `${objectTypeField}:${x.schemaName}.${x.pureName}`,
+      }));
+  }
+
+  getDeletedObjects(nameArray) {
+    return [
+      ...this.getDeletedObjectsForField(nameArray, 'tables'),
+      ...this.getDeletedObjectsForField(nameArray, 'views'),
+      ...this.getDeletedObjectsForField(nameArray, 'procedures'),
+      ...this.getDeletedObjectsForField(nameArray, 'functions'),
+      ...this.getDeletedObjectsForField(nameArray, 'triggers'),
+    ];
+  }
+}
+
+module.exports = Analyser;
--- a/plugins/dbgate-plugin-postgres/src/backend/driver.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/driver.js
@@ -0,0 +1,213 @@
+const _ = require('lodash');
+const stream = require('stream');
+const driverBase = require('../frontend/driver');
+const Analyser = require('./Analyser');
+const pg = require('pg');
+const pgQueryStream = require('pg-query-stream');
+const { createBulkInsertStreamBase, splitPostgresQuery, makeUniqueColumnNames } = require('dbgate-tools');
+
+function extractPostgresColumns(result) {
+  if (!result || !result.fields) return [];
+  const res = result.fields.map(fld => ({
+    columnName: fld.name,
+  }));
+  makeUniqueColumnNames(res);
+  return res;
+}
+
+function zipDataRow(rowArray, columns) {
+  return _.zipObject(
+    columns.map(x => x.columnName),
+    rowArray
+  );
+}
+
+async function runStreamItem(client, sql, options) {
+  return new Promise((resolve, reject) => {
+    const query = new pgQueryStream(sql, undefined, { rowMode: 'array' });
+    const stream = client.query(query);
+
+    // const handleInfo = (info) => {
+    //   const { message, lineNumber, procName } = info;
+    //   options.info({
+    //     message,
+    //     line: lineNumber,
+    //     procedure: procName,
+    //     time: new Date(),
+    //     severity: 'info',
+    //   });
+    // };
+
+    let wasHeader = false;
+
+    const handleEnd = result => {
+      // console.log('RESULT', result);
+      resolve();
+    };
+
+    let columns = null;
+    const handleReadable = () => {
+      if (!wasHeader) {
+        columns = extractPostgresColumns(query._result);
+        if (columns && columns.length > 0) {
+          options.recordset(columns);
+        }
+        wasHeader = true;
+      }
+
+      for (;;) {
+        const row = stream.read();
+        if (!row) break;
+
+        options.row(zipDataRow(row, columns));
+      }
+    };
+
+    // const handleFields = (columns) => {
+    //   // console.log('FIELDS', columns[0].name);
+    //   options.recordset(columns);
+    //   // options.recordset(extractColumns(columns));
+    // };
+
+    const handleError = error => {
+      console.log('ERROR', error);
+      const { message, lineNumber, procName } = error;
+      options.info({
+        message,
+        line: lineNumber,
+        procedure: procName,
+        time: new Date(),
+        severity: 'error',
+      });
+      resolve();
+    };
+
+    stream.on('error', handleError);
+    stream.on('readable', handleReadable);
+    // stream.on('result', handleRow)
+    // stream.on('data', handleRow)
+    stream.on('end', handleEnd);
+  });
+}
+
+/** @type {import('dbgate-types').EngineDriver} */
+const driver = {
+  ...driverBase,
+  analyserClass: Analyser,
+
+  async connect({ server, port, user, password, database, ssl }) {
+    const client = new pg.Client({
+      host: server,
+      port,
+      user,
+      password,
+      database: database || 'postgres',
+      ssl,
+    });
+    await client.connect();
+    return client;
+  },
+  async query(client, sql) {
+    if (sql == null) {
+      return {
+        rows: [],
+        columns: [],
+      };
+    }
+    const res = await client.query({ text: sql, rowMode: 'array' });
+    const columns = extractPostgresColumns(res);
+    return { rows: res.rows.map(row => zipDataRow(row, columns)), columns };
+  },
+  async stream(client, sql, options) {
+    const sqlSplitted = splitPostgresQuery(sql);
+
+    for (const sqlItem of sqlSplitted) {
+      await runStreamItem(client, sqlItem, options);
+    }
+
+    options.done();
+    // return stream;
+  },
+  // async analyseSingleObject(pool, name, typeField = 'tables') {
+  //   const analyser = new PostgreAnalyser(pool, this);
+  //   analyser.singleObjectFilter = { ...name, typeField };
+  //   const res = await analyser.fullAnalysis();
+  //   return res.tables[0];
+  // },
+  // // @ts-ignore
+  // analyseSingleTable(pool, name) {
+  //   return this.analyseSingleObject(pool, name, 'tables');
+  // },
+  async getVersion(client) {
+    const { rows } = await this.query(client, 'SELECT version()');
+    const { version } = rows[0];
+    return { version };
+  },
+  // async analyseFull(pool) {
+  //   const analyser = new PostgreAnalyser(pool, this);
+  //   return analyser.fullAnalysis();
+  // },
+  // async analyseIncremental(pool, structure) {
+  //   const analyser = new PostgreAnalyser(pool, this);
+  //   return analyser.incrementalAnalysis(structure);
+  // },
+  async readQuery(client, sql, structure) {
+    const query = new pgQueryStream(sql, undefined, { rowMode: 'array' });
+
+    const queryStream = client.query(query);
+
+    let wasHeader = false;
+
+    const pass = new stream.PassThrough({
+      objectMode: true,
+      highWaterMark: 100,
+    });
+
+    const handleEnd = result => {
+      pass.end();
+    };
+
+    let columns = null;
+    const handleReadable = () => {
+      if (!wasHeader) {
+        columns = extractPostgresColumns(query._result);
+        pass.write({
+          __isStreamHeader: true,
+          ...(structure || { columns }),
+        });
+        wasHeader = true;
+      }
+
+      for (;;) {
+        const row = queryStream.read();
+        if (!row) break;
+
+        pass.write(zipDataRow(row, columns));
+      }
+    };
+
+    const handleError = error => {
+      console.error(error);
+      pass.end();
+    };
+
+    queryStream.on('error', handleError);
+    queryStream.on('readable', handleReadable);
+    queryStream.on('end', handleEnd);
+
+    return pass;
+  },
+  // createDumper() {
+  //   return new PostgreDumper(this);
+  // },
+  async writeTable(pool, name, options) {
+    // @ts-ignore
+    return createBulkInsertStreamBase(this, stream, pool, name, options);
+  },
+  async listDatabases(client) {
+    const { rows } = await this.query(client, 'SELECT datname AS name FROM pg_database WHERE datistemplate = false');
+    return rows;
+  },
+};
+
+module.exports = driver;
--- a/plugins/dbgate-plugin-postgres/src/backend/index.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/index.js
@@ -0,0 +1,6 @@
+const driver = require('./driver');
+
+module.exports = {
+  packageName: 'dbgate-plugin-postgres',
+  driver,
+};
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/columns.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/columns.js
@@ -0,0 +1,19 @@
+module.exports = `
+select 
+	table_schema as "schemaName", 
+	table_name as "pureName", 
+	column_name as "columnName",
+	is_nullable as "isNullable",
+	data_type as "dataType",
+	character_maximum_length as "charMaxLength",
+	numeric_precision as "numericPrecision",
+	numeric_scale as "numericScale",
+	column_default as "defaultValue"
+from information_schema.columns
+where 
+		table_schema <> 'information_schema' 
+		and table_schema <> 'pg_catalog' 
+		and table_schema !~ '^pg_toast' 
+		and 'tables:' || table_schema || '.' || table_name =OBJECT_ID_CONDITION
+order by ordinal_position
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/foreignKeys.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/foreignKeys.js
@@ -0,0 +1,24 @@
+module.exports = `
+select 
+	fk.constraint_name as "constraintName",
+	fk.constraint_schema as "constraintSchema",
+	base.table_name as "pureName",
+	base.table_schema as "schemaName",
+	fk.update_rule as "updateAction",
+	fk.delete_rule as "deleteAction",
+	ref.table_name as "refTableName",
+	ref.table_schema as "refSchemaName",
+	basecol.column_name as "columnName",
+	refcol.column_name as "refColumnName"
+from information_schema.referential_constraints fk
+inner join information_schema.table_constraints base on fk.constraint_name = base.constraint_name and fk.constraint_schema = base.constraint_schema
+inner join information_schema.table_constraints ref on fk.unique_constraint_name = ref.constraint_name and fk.unique_constraint_schema = ref.constraint_schema
+inner join information_schema.key_column_usage basecol on base.table_name = basecol.table_name and base.constraint_name = basecol.constraint_name
+inner join information_schema.key_column_usage refcol on ref.table_name = refcol.table_name and ref.constraint_name = refcol.constraint_name and basecol.ordinal_position = refcol.ordinal_position
+where 
+		base.table_schema <> 'information_schema' 
+		and base.table_schema <> 'pg_catalog' 
+		and base.table_schema !~ '^pg_toast' 
+		and 'tables:' || base.table_schema || '.' || base.table_name =OBJECT_ID_CONDITION
+order by basecol.ordinal_position
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/index.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/index.js
@@ -0,0 +1,19 @@
+const columns = require('./columns');
+const tableModifications = require('./tableModifications');
+const viewModifications = require('./viewModifications');
+const primaryKeys = require('./primaryKeys');
+const foreignKeys = require('./foreignKeys');
+const views = require('./views');
+const routines = require('./routines');
+const routineModifications = require('./routineModifications');
+
+module.exports = {
+  columns,
+  tableModifications,
+  viewModifications,
+  primaryKeys,
+  foreignKeys,
+  views,
+  routines,
+  routineModifications,
+};
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/primaryKeys.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/primaryKeys.js
@@ -0,0 +1,17 @@
+module.exports = `
+select 
+	table_constraints.constraint_schema as "constraintSchema",
+	table_constraints.constraint_name as "constraintName",
+	table_constraints.table_schema as "schemaName",
+	table_constraints.table_name as "pureName",
+	key_column_usage.column_name as "columnName"
+from information_schema.table_constraints
+inner join information_schema.key_column_usage on table_constraints.table_name = key_column_usage.table_name and table_constraints.constraint_name = key_column_usage.constraint_name
+where 
+		table_constraints.table_schema <> 'information_schema' 
+		and table_constraints.table_schema <> 'pg_catalog' 
+		and table_constraints.table_schema !~ '^pg_toast' 
+		and table_constraints.constraint_type = 'PRIMARY KEY'
+		and 'tables:' || table_constraints.table_schema || '.' || table_constraints.table_name =OBJECT_ID_CONDITION
+order by key_column_usage.ordinal_position
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/routineModifications.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/routineModifications.js
@@ -0,0 +1,10 @@
+module.exports = `
+select 
+  routine_name as "pureName",
+  routine_schema as "schemaName",
+  md5(routine_definition) as "hashCode",
+  routine_type as "objectType"
+from
+  information_schema.routines where routine_schema != 'information_schema' and routine_schema != 'pg_catalog' 
+  and routine_type in ('PROCEDURE', 'FUNCTION')
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/routines.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/routines.js
@@ -0,0 +1,15 @@
+module.exports = `
+select 
+  routine_name as "pureName",
+  routine_schema as "schemaName",
+  routine_definition as "createSql",
+  md5(routine_definition) as "hashCode",
+  routine_type as "objectType"
+from
+  information_schema.routines where routine_schema != 'information_schema' and routine_schema != 'pg_catalog' 
+  and (
+   (routine_type = 'PROCEDURE' and ('procedures:' || routine_schema || '.' ||  routine_schema) =OBJECT_ID_CONDITION)
+   or
+   (routine_type = 'FUNCTION' and ('functions:' || routine_schema || '.' ||  routine_schema) =OBJECT_ID_CONDITION)
+  )
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/tableModifications.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/tableModifications.js
@@ -0,0 +1,52 @@
+module.exports = `
+with pkey as
+(
+    select cc.conrelid, format(E'create constraint %I primary key(%s);\\n', cc.conname,
+        string_agg(a.attname, ', ' 
+            order by array_position(cc.conkey, a.attnum))) pkey
+    from pg_catalog.pg_constraint cc
+        join pg_catalog.pg_class c on c.oid = cc.conrelid
+        join pg_catalog.pg_attribute a on a.attrelid = cc.conrelid 
+            and a.attnum = any(cc.conkey)
+    where cc.contype = 'p'
+    group by cc.conrelid, cc.conname
+)
+
+
+SELECT oid as "objectId", nspname as "schemaName", relname as "pureName",
+  md5('CREATE TABLE ' || nspname || '.' || relname || E'\\n(\\n' ||
+  array_to_string(
+    array_agg(
+      '    ' || column_name || ' ' ||  type || ' '|| not_null
+    )
+    , E',\\n'
+  ) || E'\\n);\\n' || coalesce((select pkey from pkey where pkey.conrelid = oid),'NO_PK')) as "hashCode"
+from
+(
+  SELECT 
+    c.relname, a.attname AS column_name, c.oid,
+    n.nspname,
+    pg_catalog.format_type(a.atttypid, a.atttypmod) as type,
+    case 
+      when a.attnotnull
+    then 'NOT NULL' 
+    else 'NULL' 
+    END as not_null 
+  FROM pg_class c,
+   pg_namespace n,
+   pg_attribute a,
+   pg_type t
+
+   WHERE c.relkind = 'r'
+   AND a.attnum > 0
+   AND a.attrelid = c.oid
+   AND a.atttypid = t.oid
+   AND n.oid = c.relnamespace
+    AND n.nspname <> 'pg_catalog'
+    AND n.nspname <> 'information_schema'
+    AND n.nspname !~ '^pg_toast'
+ ORDER BY a.attnum
+) as tabledefinition
+where ('tables:' || nspname || '.' ||  relname) =OBJECT_ID_CONDITION
+group by relname, nspname, oid
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/viewModifications.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/viewModifications.js
@@ -0,0 +1,8 @@
+module.exports = `
+select 
+  table_name as "pureName",
+  table_schema as "schemaName",
+  md5(view_definition) as "hashCode"
+from
+  information_schema.views where table_schema != 'information_schema' and table_schema != 'pg_catalog'
+`;
--- a/plugins/dbgate-plugin-postgres/src/backend/sql/views.js
+++ b/plugins/dbgate-plugin-postgres/src/backend/sql/views.js
@@ -0,0 +1,11 @@
+module.exports = `
+select 
+  table_name as "pureName",
+  table_schema as "schemaName",
+  view_definition as "createSql",
+  md5(view_definition) as "hashCode"
+from
+  information_schema.views 
+where table_schema != 'information_schema' and table_schema != 'pg_catalog'
+  and ('views:' || table_schema || '.' ||  table_name) =OBJECT_ID_CONDITION
+`;
--- a/plugins/dbgate-plugin-postgres/src/frontend/Dumper.js
+++ b/plugins/dbgate-plugin-postgres/src/frontend/Dumper.js
@@ -0,0 +1,66 @@
+const { SqlDumper } = require('dbgate-tools');
+
+class Dumper extends SqlDumper {
+  /** @param type {import('dbgate-types').TransformType} */
+  transform(type, dumpExpr) {
+    switch (type) {
+      case 'GROUP:YEAR':
+      case 'YEAR':
+        this.put('^extract(^year ^from %c)', dumpExpr);
+        break;
+      case 'MONTH':
+        this.put('^extract(^month ^from %c)', dumpExpr);
+        break;
+      case 'DAY':
+        this.put('^extract(^day ^from %c)', dumpExpr);
+        break;
+      case 'GROUP:MONTH':
+        this.put("^to_char(%c, '%s')", dumpExpr, 'YYYY-MM');
+        break;
+      case 'GROUP:DAY':
+        this.put("^to_char(%c, '%s')", dumpExpr, 'YYYY-MM-DD');
+        break;
+      default:
+        dumpExpr();
+        break;
+    }
+  }
+
+  dropRecreatedTempTable(tmptable) {
+    this.putCmd('^drop ^table %i ^cascade', tmptable);
+  }
+
+  renameTable(obj, newname) {
+    this.putCmd('^alter ^table %f ^rename ^to %i', obj, newname);
+  }
+
+  renameColumn(column, newcol) {
+    this.putCmd('^alter ^table %f ^rename ^column %i ^to %i', column, column.columnName, newcol);
+  }
+
+  dropTable(obj, options = {}) {
+    this.put('^drop ^table');
+    if (options.testIfExists) this.put(' ^if ^exists');
+    this.put(' %f', obj.FullName);
+    this.endCommand();
+  }
+
+  //public override void CreateIndex(IndexInfo ix)
+  //{
+  //}
+
+  enableConstraints(table, enabled) {
+    this.putCmd('^alter ^table %f %k ^trigger ^all', table, enabled ? 'enable' : 'disable');
+  }
+
+  columnDefinition(col, options) {
+    const { autoIncrement } = options || {};
+    if (col.autoIncrement) {
+      this.put('^serial');
+      return;
+    }
+    super.columnDefinition(col, options);
+  }
+}
+
+module.exports = Dumper;
--- a/plugins/dbgate-plugin-postgres/src/frontend/driver.js
+++ b/plugins/dbgate-plugin-postgres/src/frontend/driver.js
@@ -0,0 +1,27 @@
+const { driverBase } = require('dbgate-tools');
+const Dumper = require('./Dumper');
+
+/** @type {import('dbgate-types').SqlDialect} */
+const dialect = {
+  rangeSelect: true,
+  // stringEscapeChar: '\\',
+  stringEscapeChar: "'",
+  fallbackDataType: 'varchar',
+  anonymousPrimaryKey: true,
+  enableConstraintsPerTable: true,
+  quoteIdentifier(s) {
+    return '"' + s + '"';
+  },
+};
+
+/** @type {import('dbgate-types').EngineDriver} */
+const driver = {
+  ...driverBase,
+  dumperClass: Dumper,
+  dialect,
+  engine: 'postgres@dbgate-plugin-postgres',
+  title: 'Postgre SQL',
+  defaultPort: 5432,
+};
+
+module.exports = driver;
--- a/plugins/dbgate-plugin-postgres/src/frontend/index.js
+++ b/plugins/dbgate-plugin-postgres/src/frontend/index.js
@@ -0,0 +1,6 @@
+import driver from './driver';
+
+export default {
+  packageName: 'dbgate-plugin-postgres',
+  driver,
+};
--- a/plugins/dbgate-plugin-postgres/test/testdb.sql
+++ b/plugins/dbgate-plugin-postgres/test/testdb.sql
--- a/plugins/dbgate-plugin-postgres/webpack-backend.config.js
+++ b/plugins/dbgate-plugin-postgres/webpack-backend.config.js
@@ -0,0 +1,40 @@
+var webpack = require('webpack');
+var path = require('path');
+
+var config = {
+  context: __dirname + '/src/backend',
+
+  entry: {
+    app: './index.js',
+  },
+  target: 'node',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'backend.js',
+    libraryTarget: 'commonjs2',
+  },
+
+  // uncomment for disable minimalization
+  //   optimization: {
+  //     minimize: false,
+  //   },
+
+  plugins: [
+    new webpack.IgnorePlugin({
+      checkResource(resource) {
+        const lazyImports = ['pg-native', 'uws'];
+        if (!lazyImports.includes(resource)) {
+          return false;
+        }
+        try {
+          require.resolve(resource);
+        } catch (err) {
+          return true;
+        }
+        return false;
+      },
+    }),
+  ],
+};
+
+module.exports = config;
--- a/plugins/dbgate-plugin-postgres/webpack-frontend.config.js
+++ b/plugins/dbgate-plugin-postgres/webpack-frontend.config.js
@@ -0,0 +1,24 @@
+var webpack = require("webpack");
+var path = require("path");
+
+var config = {
+  context: __dirname + "/src/frontend",
+
+  entry: {
+    app: "./index.js",
+  },
+  target: "web",
+  output: {
+    path: path.resolve(__dirname, "dist"),
+    filename: "frontend.js",
+    libraryTarget: "var",
+    library: 'plugin',
+  },
+
+  // uncomment for disable minimalization
+  // optimization: {
+  //   minimize: false,
+  // },
+};
+
+module.exports = config;