engines moved to separate library

lib/engines/mssql/MsSqlAnalyser.js

@@ -0,0 +1,81 @@
+const fs = require('fs-extra');
+const fp = require('lodash/fp');
+const path = require('path');
+const _ = require('lodash');
+
+const DatabaseAnalayser = require('../default/DatabaseAnalyser');
+
+/** @returns {Promise<string>} */
+async function loadQuery(name) {
+  return await fs.readFile(path.join(__dirname, name), 'utf-8');
+}
+
+const byTableFilter = table => x => x.pureName == table.pureName && x.schemaName == x.schemaName;
+
+function extractPrimaryKeys(table, pkColumns) {
+  const filtered = pkColumns.filter(byTableFilter(table));
+  if (filtered.length == 0) return undefined;
+  return {
+    ..._.pick(filtered[0], ['constraintName', 'schemaName', 'pureName']),
+    constraintType: 'primaryKey',
+    columns: filtered.map(fp.pick('columnName')),
+  };
+}
+
+function extractForeignKeys(table, fkColumns) {
+  const grouped = _.groupBy(fkColumns.filter(byTableFilter(table)), 'constraintName');
+  return _.keys(grouped).map(constraintName => ({
+    constraintName,
+    constraintType: 'foreignKey',
+    ..._.pick(grouped[constraintName][0], [
+      'constraintName',
+      'schemaName',
+      'pureName',
+      'refSchemaName',
+      'refTableName',
+      'updateAction',
+      'deleteAction',
+    ]),
+    columns: grouped[constraintName].map(fp.pick(['columnName', 'refColumnName'])),
+  }));
+}
+
+class MsSqlAnalyser extends DatabaseAnalayser {
+  constructor(pool, driver) {
+    super(pool, driver);
+  }
+
+  async createQuery(
+    resFileName,
+    tables = false,
+    views = false,
+    procedures = false,
+    functions = false,
+    triggers = false
+  ) {
+    let res = await loadQuery(resFileName);
+    res = res.replace('=[OBJECT_ID_CONDITION]', ' is not null');
+    return res;
+  }
+  async runAnalysis() {
+    const tables = await this.driver.query(this.pool, await this.createQuery('tables.sql'));
+    const columns = await this.driver.query(this.pool, await this.createQuery('columns.sql'));
+    const pkColumns = await this.driver.query(this.pool, await this.createQuery('primary_keys.sql'));
+    const fkColumns = await this.driver.query(this.pool, await this.createQuery('foreign_keys.sql'));
+
+    this.result.tables = tables.rows.map(table => ({
+      ...table,
+      columns: columns.rows
+        .filter(col => col.objectId == table.objectId)
+        .map(({ isNullable, isIdentity, ...col }) => ({
+          ...col,
+          notNull: !isNullable,
+          autoIncrement: !!isIdentity,
+        })),
+      primaryKey: extractPrimaryKeys(table, pkColumns.rows),
+      foreignKeys: extractForeignKeys(table, fkColumns.rows),
+    }));
+  }
+}
+
+module.exports = MsSqlAnalyser;

lib/engines/mssql/MsSqlDumper.js

@@ -0,0 +1,5 @@
+const SqlDumper = require('../default/SqlDumper');
+
+class MsSqlDumper extends SqlDumper {}
+
+module.exports = MsSqlDumper;

lib/engines/mssql/columns.sql

@@ -0,0 +1,13 @@
+select c.name as columnName, t.name as dataType, c.object_id as objectId, c.is_identity as isIdentity,
+	c.max_length as maxLength, c.precision, c.scale, c.is_nullable as isNullable,
+	d.definition as defaultValue, d.name as defaultConstraint,
+	m.definition as computedExpression, m.is_persisted as isPersisted, c.column_id as columnId, 
+	-- TODO only if version >= 2008
+	c.is_sparse as isSparse
+from sys.columns c
+inner join sys.types t on c.system_type_id = t.system_type_id and c.user_type_id = t.user_type_id
+inner join sys.objects o on c.object_id = o.object_id
+left join sys.default_constraints d on c.default_object_id = d.object_id
+left join sys.computed_columns m on m.object_id = c.object_id and m.column_id = c.column_id
+where o.type = 'U' and o.object_id =[OBJECT_ID_CONDITION]
+order by c.column_id

lib/engines/mssql/foreign_keys.sql

@@ -0,0 +1,38 @@
+SELECT
+    schemaName = FK.TABLE_SCHEMA,
+    pureName = FK.TABLE_NAME,
+    columnName = CU.COLUMN_NAME,
+
+    refSchemaName = ISNULL(IXS.name, PK.TABLE_SCHEMA),
+    refTableName = ISNULL(IXT.name, PK.TABLE_NAME),
+    refColumnName = IXCC.name,
+
+    constraintName = C.CONSTRAINT_NAME,
+    updateAction = rc.UPDATE_RULE,
+    deleteAction = rc.DELETE_RULE,
+
+    objectId = o.object_id 
+
+FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C
+INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME
+
+LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME
+LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME
+--LEFT JOIN (
+--SELECT i1.TABLE_NAME, i2.COLUMN_NAME
+--FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1
+--INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME
+--WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY'
+--) PT ON PT.TABLE_NAME = PK.TABLE_NAME
+INNER JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc ON FK.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+
+LEFT JOIN sys.indexes IX ON IX.name = C.UNIQUE_CONSTRAINT_NAME
+LEFT JOIN sys.objects IXT ON IXT.object_id = IX.object_id
+LEFT JOIN sys.index_columns IXC ON IX.index_id = IXC.index_id and IX.object_id = IXC.object_id
+LEFT JOIN sys.columns IXCC ON IXCC.column_id = IXC.column_id AND IXCC.object_id = IXC.object_id
+LEFT JOIN sys.schemas IXS ON IXT.schema_id = IXS.schema_id
+
+inner join sys.objects o on FK.TABLE_NAME = o.name
+inner join sys.schemas s on o.schema_id = s.schema_id and FK.TABLE_SCHEMA = s.name
+
+where o.object_id =[OBJECT_ID_CONDITION]

lib/engines/mssql/index.js

@@ -0,0 +1,56 @@
+const _ = require("lodash");
+const MsSqlAnalyser = require("./MsSqlAnalyser");
+const MsSqlDumper = require("./MsSqlDumper");
+
+/** @type {import('dbgate').SqlDialect} */
+const dialect = {
+  limitSelect: true,
+  quoteIdentifier(s) {
+    return `[${s}]`;
+  }
+};
+
+/** @type {import('dbgate').EngineDriver} */
+const driver = {
+  async connect({ mssql }, { server, port, user, password, database }) {
+    const pool = await mssql.connect({
+      server,
+      port,
+      user,
+      password,
+      database
+    });
+    return pool;
+  },
+  async query(pool, sql) {
+    const resp = await pool.request().query(sql);
+    // console.log(Object.keys(resp.recordset));
+    const columns = _.sortBy(_.values(resp.recordset.columns), "index");
+    return { rows: resp.recordset, columns };
+  },
+  async getVersion(pool) {
+    const { version } = (
+      await this.query(pool, "SELECT @@VERSION AS version")
+    ).rows[0];
+    return { version };
+  },
+  async listDatabases(pool) {
+    const { rows } = await this.query(
+      pool,
+      "SELECT name FROM sys.databases order by name"
+    );
+    return rows;
+  },
+  async analyseFull(pool) {
+    const analyser = new MsSqlAnalyser(pool, this);
+    await analyser.runAnalysis();
+    return analyser.result;
+  },
+  // async analyseIncremental(pool) {},
+  createDumper() {
+    return new MsSqlDumper(this);
+  },
+  dialect
+};
+
+module.exports = driver;

lib/engines/mssql/primary_keys.sql

@@ -0,0 +1,12 @@
+select o.object_id, pureName = t.Table_Name, schemaName = t.Table_Schema, columnName = c.Column_Name, constraintName=t.constraint_name from 
+    INFORMATION_SCHEMA.TABLE_CONSTRAINTS t,
+    sys.objects o,
+    sys.schemas s,
+    INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE c
+where
+    c.Constraint_Name = t.Constraint_Name
+    and t.table_name = o.name 
+    and o.schema_id = s.schema_id and t.Table_Schema = s.name
+    and c.Table_Name = t.Table_Name
+    and Constraint_Type = 'PRIMARY KEY'
+	and o.object_id =[OBJECT_ID_CONDITION]

lib/engines/mssql/tables.sql

@@ -0,0 +1,6 @@
+select
+	o.name as pureName, s.name as schemaName, o.object_id as objectId,
+	o.create_date, o.modify_date 
+from sys.tables o
+inner join sys.schemas s on o.schema_id = s.schema_id
+where o.object_id =[OBJECT_ID_CONDITION]