dbgate-tools 4.3.4 → 4.4.1

package/lib/alterPlan.d.ts

@@ -1,3 +1,4 @@
+import { DbDiffOptions } from './diffTools';
 import { AlterProcessor, ColumnInfo, ConstraintInfo, DatabaseInfo, SqlObjectInfo, SqlDialect, TableInfo } from '../../types';
 interface AlterOperation_CreateTable {
     operationType: 'createTable';
@@ -65,13 +66,14 @@ declare type AlterOperation = AlterOperation_CreateColumn | AlterOperation_Chang
 export declare class AlterPlan {
     db: DatabaseInfo;
     dialect: SqlDialect;
+    opts: DbDiffOptions;
     recreates: {
         tables: number;
         constraints: number;
         sqlObjects: number;
     };
     operations: AlterOperation[];
-    constructor(db: DatabaseInfo, dialect: SqlDialect);
+    constructor(db: DatabaseInfo, dialect: SqlDialect, opts: DbDiffOptions);
     createTable(table: TableInfo): void;
     dropTable(table: TableInfo): void;
     createSqlObject(obj: SqlObjectInfo): void;
@@ -94,6 +96,8 @@ export declare class AlterPlan {
     _canDropConstraint(cnt: ConstraintInfo): boolean;
     _testTableRecreate(op: AlterOperation, operationType: string, isAllowed: boolean | Function, objectField: string): AlterOperation[] | null;
     _groupTableRecreations(): AlterOperation[];
+    _moveForeignKeysToLast(): AlterOperation[];
+    _filterAllowedOperations(): AlterOperation[];
     transformPlan(): void;
 }
 export declare function runAlterOperation(op: AlterOperation, processor: AlterProcessor): void;

package/lib/alterPlan.js

@@ -5,13 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAlterOperation = exports.AlterPlan = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const _1 = require(".");
+const diffTools_1 = require("./diffTools");
 const database_info_alter_processor_1 = require("./database-info-alter-processor");
 const DatabaseAnalyser_1 = require("./DatabaseAnalyser");
 class AlterPlan {
-    constructor(db, dialect) {
+    constructor(db, dialect, opts) {
         this.db = db;
         this.dialect = dialect;
+        this.opts = opts;
         this.recreates = {
             tables: 0,
             constraints: 0,
@@ -117,6 +118,8 @@ class AlterPlan {
     }
     _getDependendColumnConstraints(column, dependencyDefinition) {
         const table = this.db.tables.find(x => x.pureName == column.pureName && x.schemaName == column.schemaName);
+        if (!table)
+            return [];
         const fks = (dependencyDefinition === null || dependencyDefinition === void 0 ? void 0 : dependencyDefinition.includes('dependencies'))
             ? table.dependencies.filter(fk => fk.columns.find(col => col.refColumnName == column.columnName))
             : [];
@@ -132,6 +135,9 @@ class AlterPlan {
         const lists = this.operations.map(op => {
             if (op.operationType == 'dropColumn') {
                 const constraints = this._getDependendColumnConstraints(op.oldObject, this.dialect.dropColumnDependencies);
+                if (constraints.length > 0 && this.opts.noDropConstraint) {
+                    return [];
+                }
                 const res = [
                     ...constraints.map(oldObject => {
                         const opRes = {
@@ -146,6 +152,9 @@ class AlterPlan {
             }
             if (op.operationType == 'changeColumn') {
                 const constraints = this._getDependendColumnConstraints(op.oldObject, this.dialect.changeColumnDependencies);
+                if (constraints.length > 0 && this.opts.noDropConstraint) {
+                    return [];
+                }
                 const res = [
                     ...constraints.map(oldObject => {
                         const opRes = {
@@ -183,6 +192,10 @@ class AlterPlan {
                 ];
             }
             if (op.operationType == 'changeConstraint') {
+                if (this.opts.noDropConstraint) {
+                    // skip constraint recreate
+                    return [];
+                }
                 this.recreates.constraints += 1;
                 const opDrop = {
                     operationType: 'dropConstraint',
@@ -246,6 +259,10 @@ class AlterPlan {
             }
             // console.log('*****************RECREATED NEEDED', op, operationType, isAllowed);
             // console.log(this.dialect);
+            if (this.opts.noDropTable) {
+                // skip this operation, as it cannot be achieved
+                return [];
+            }
             const table = this.db.tables.find(x => x.pureName == op[objectField].pureName && x.schemaName == op[objectField].schemaName);
             this.recreates.tables += 1;
             return [
@@ -262,7 +279,7 @@ class AlterPlan {
         const res = [];
         const recreates = {};
         for (const op of this.operations) {
-            if (op.operationType == 'recreateTable') {
+            if (op.operationType == 'recreateTable' && op.table) {
                 const existingRecreate = recreates[`${op.table.schemaName}||${op.table.pureName}`];
                 if (existingRecreate) {
                     existingRecreate.operations.push(...op.operations);
@@ -288,6 +305,41 @@ class AlterPlan {
         }
         return res;
     }
+    _moveForeignKeysToLast() {
+        if (!this.dialect.createForeignKey) {
+            return this.operations;
+        }
+        const fks = [];
+        const res = this.operations.map(op => {
+            if (op.operationType == 'createTable') {
+                fks.push(...(op.newObject.foreignKeys || []));
+                return Object.assign(Object.assign({}, op), { newObject: Object.assign(Object.assign({}, op.newObject), { foreignKeys: [] }) });
+            }
+            return op;
+        });
+        return [
+            ...res,
+            ...fks.map(fk => ({
+                operationType: 'createConstraint',
+                newObject: fk,
+            })),
+        ];
+    }
+    _filterAllowedOperations() {
+        return this.operations.filter(op => {
+            if (this.opts.noDropColumn && op.operationType == 'dropColumn')
+                return false;
+            if (this.opts.noDropTable && op.operationType == 'dropTable')
+                return false;
+            if (this.opts.noDropTable && op.operationType == 'recreateTable')
+                return false;
+            if (this.opts.noDropConstraint && op.operationType == 'dropConstraint')
+                return false;
+            if (this.opts.noDropSqlObject && op.operationType == 'dropSqlObject')
+                return false;
+            return true;
+        });
+    }
     transformPlan() {
         // console.log('*****************OPERATIONS0', this.operations);
         this.operations = this._addLogicalDependencies();
@@ -296,6 +348,10 @@ class AlterPlan {
         // console.log('*****************OPERATIONS2', this.operations);
         this.operations = this._groupTableRecreations();
         // console.log('*****************OPERATIONS3', this.operations);
+        this.operations = this._moveForeignKeysToLast();
+        // console.log('*****************OPERATIONS4', this.operations);
+        this.operations = this._filterAllowedOperations();
+        // console.log('*****************OPERATIONS5', this.operations);
     }
 }
 exports.AlterPlan = AlterPlan;
@@ -342,7 +398,7 @@ function runAlterOperation(op, processor) {
             break;
         case 'recreateTable':
             {
-                const oldTable = (0, _1.generateTablePairingId)(op.table);
+                const oldTable = (0, diffTools_1.generateTablePairingId)(op.table);
                 const newTable = lodash_1.default.cloneDeep(oldTable);
                 const newDb = DatabaseAnalyser_1.DatabaseAnalyser.createEmptyStructure();
                 newDb.tables.push(newTable);

package/lib/computeDiffRows.d.ts

@@ -0,0 +1,38 @@
+import { DbDiffOptions, testEqualTables, testEqualSqlObjects } from './diffTools';
+import { DatabaseInfo, EngineDriver, SqlObjectInfo, TableInfo } from 'dbgate-types';
+export declare function computeDiffRowsCore(sourceList: any, targetList: any, testEqual: any): any[];
+export declare const DbDiffCompareDefs: {
+    tables: {
+        test: typeof testEqualTables;
+        name: string;
+        plural: string;
+        icon: string;
+    };
+    views: {
+        test: typeof testEqualSqlObjects;
+        name: string;
+        plural: string;
+        icon: string;
+    };
+    matviews: {
+        test: typeof testEqualSqlObjects;
+        name: string;
+        plural: string;
+        icon: string;
+    };
+    procedures: {
+        test: typeof testEqualSqlObjects;
+        name: string;
+        plural: string;
+        icon: string;
+    };
+    functions: {
+        test: typeof testEqualSqlObjects;
+        name: string;
+        plural: string;
+        icon: string;
+    };
+};
+export declare function computeDbDiffRows(sourceDb: DatabaseInfo, targetDb: DatabaseInfo, opts: DbDiffOptions, driver: EngineDriver): any[];
+export declare function computeTableDiffColumns(sourceTable: TableInfo, targetTable: TableInfo, opts: DbDiffOptions, driver: EngineDriver): any[];
+export declare function getCreateObjectScript(obj: TableInfo | SqlObjectInfo, driver: EngineDriver): string;

package/lib/computeDiffRows.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateObjectScript = exports.computeTableDiffColumns = exports.computeDbDiffRows = exports.DbDiffCompareDefs = exports.computeDiffRowsCore = void 0;
+const diffTools_1 = require("./diffTools");
+const lodash_1 = __importDefault(require("lodash"));
+function computeDiffRowsCore(sourceList, targetList, testEqual) {
+    const res = [];
+    for (const obj of sourceList) {
+        const paired = targetList.find(x => x.pairingId == obj.pairingId);
+        if (paired) {
+            const isEqual = testEqual(obj, paired);
+            res.push({
+                source: obj,
+                target: paired,
+                state: isEqual ? 'equal' : 'changed',
+                __isChanged: !isEqual,
+            });
+        }
+        else {
+            res.push({
+                source: obj,
+                state: 'added',
+                __isAdded: true,
+            });
+        }
+    }
+    for (const obj of targetList) {
+        const paired = sourceList.find(x => x.pairingId == obj.pairingId);
+        if (!paired) {
+            res.push({
+                target: obj,
+                state: 'removed',
+                __isDeleted: true,
+            });
+        }
+    }
+    return res;
+}
+exports.computeDiffRowsCore = computeDiffRowsCore;
+exports.DbDiffCompareDefs = {
+    tables: {
+        test: diffTools_1.testEqualTables,
+        name: 'Table',
+        plural: 'Tables',
+        icon: 'img table',
+    },
+    views: {
+        test: diffTools_1.testEqualSqlObjects,
+        name: 'View',
+        plural: 'Views',
+        icon: 'img view',
+    },
+    matviews: {
+        test: diffTools_1.testEqualSqlObjects,
+        name: 'Materialized view',
+        plural: 'Materialized views',
+        icon: 'img view',
+    },
+    procedures: {
+        test: diffTools_1.testEqualSqlObjects,
+        name: 'Procedure',
+        plural: 'Procedures',
+        icon: 'img procedure',
+    },
+    functions: {
+        test: diffTools_1.testEqualSqlObjects,
+        name: 'Function',
+        plural: 'Functions',
+        icon: 'img function',
+    },
+};
+function computeDbDiffRows(sourceDb, targetDb, opts, driver) {
+    if (!sourceDb || !targetDb || !driver)
+        return [];
+    const res = [];
+    for (const objectTypeField of ['tables', 'views', 'procedures', 'matviews', 'functions']) {
+        const defs = exports.DbDiffCompareDefs[objectTypeField];
+        res.push(...lodash_1.default.sortBy(computeDiffRowsCore(sourceDb[objectTypeField], targetDb[objectTypeField], (a, b) => defs.test(a, b, opts, targetDb, driver)).map(row => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            return (Object.assign(Object.assign({}, row), { sourceSchemaName: (_a = row === null || row === void 0 ? void 0 : row.source) === null || _a === void 0 ? void 0 : _a.schemaName, sourcePureName: (_b = row === null || row === void 0 ? void 0 : row.source) === null || _b === void 0 ? void 0 : _b.pureName, targetSchemaName: (_c = row === null || row === void 0 ? void 0 : row.target) === null || _c === void 0 ? void 0 : _c.schemaName, targetPureName: (_d = row === null || row === void 0 ? void 0 : row.target) === null || _d === void 0 ? void 0 : _d.pureName, typeName: defs.name, typeIcon: defs.icon, identifier: `${((_e = row === null || row === void 0 ? void 0 : row.source) === null || _e === void 0 ? void 0 : _e.schemaName) || ((_f = row === null || row === void 0 ? void 0 : row.target) === null || _f === void 0 ? void 0 : _f.schemaName)}.${((_g = row === null || row === void 0 ? void 0 : row.source) === null || _g === void 0 ? void 0 : _g.pureName) || ((_h = row === null || row === void 0 ? void 0 : row.target) === null || _h === void 0 ? void 0 : _h.pureName)}`, objectTypeField }));
+        }), 'identifier'));
+    }
+    return res;
+}
+exports.computeDbDiffRows = computeDbDiffRows;
+function computeTableDiffColumns(sourceTable, targetTable, opts, driver) {
+    if (!driver)
+        return [];
+    return computeDiffRowsCore((sourceTable === null || sourceTable === void 0 ? void 0 : sourceTable.columns) || [], (targetTable === null || targetTable === void 0 ? void 0 : targetTable.columns) || [], (a, b) => (0, diffTools_1.testEqualColumns)(a, b, true, true, opts)).map(row => {
+        var _a, _b, _c, _d, _e, _f;
+        return (Object.assign(Object.assign({}, row), { sourceColumnName: (_a = row === null || row === void 0 ? void 0 : row.source) === null || _a === void 0 ? void 0 : _a.columnName, targetColumnName: (_b = row === null || row === void 0 ? void 0 : row.target) === null || _b === void 0 ? void 0 : _b.columnName, sourceDataType: (_c = row === null || row === void 0 ? void 0 : row.source) === null || _c === void 0 ? void 0 : _c.dataType, targetDataType: (_d = row === null || row === void 0 ? void 0 : row.target) === null || _d === void 0 ? void 0 : _d.dataType, sourceNotNull: (_e = row === null || row === void 0 ? void 0 : row.source) === null || _e === void 0 ? void 0 : _e.notNull, targetNotNull: (_f = row === null || row === void 0 ? void 0 : row.target) === null || _f === void 0 ? void 0 : _f.notNull }));
+    });
+}
+exports.computeTableDiffColumns = computeTableDiffColumns;
+function getCreateObjectScript(obj, driver) {
+    if (!obj || !driver)
+        return '';
+    if (obj.objectTypeField == 'tables') {
+        const dmp = driver.createDumper();
+        dmp.createTable(obj);
+        return dmp.s;
+    }
+    return obj.createSql || '';
+}
+exports.getCreateObjectScript = getCreateObjectScript;

package/lib/database-info-alter-processor.js

@@ -23,14 +23,20 @@ class DatabaseInfoAlterProcessor {
     }
     createColumn(column) {
         const table = this.db.tables.find(x => x.pureName == column.pureName && x.schemaName == column.schemaName);
+        if (!table)
+            throw new Error(`createColumn error, cannot find table: ${column.schemaName}.${column.pureName}`);
         table.columns.push(column);
     }
     changeColumn(oldColumn, newColumn) {
         const table = this.db.tables.find(x => x.pureName == oldColumn.pureName && x.schemaName == oldColumn.schemaName);
+        if (!table)
+            throw new Error(`changeColumn error, cannot find table: ${oldColumn.schemaName}.${oldColumn.pureName}`);
         table.columns = table.columns.map(x => (x.columnName == oldColumn.columnName ? newColumn : x));
     }
     dropColumn(column) {
         const table = this.db.tables.find(x => x.pureName == column.pureName && x.schemaName == column.schemaName);
+        if (!table)
+            throw new Error(`dropColumn error, cannot find table: ${column.schemaName}.${column.pureName}`);
         lodash_1.default.remove(table.columns, x => x.columnName == column.columnName);
     }
     createConstraint(constraint) {

package/lib/diffTools.d.ts

@@ -1,23 +1,33 @@
-import { ColumnInfo, DatabaseInfo, EngineDriver, TableInfo } from 'dbgate-types';
+import { ColumnInfo, DatabaseInfo, EngineDriver, SqlObjectInfo, TableInfo } from 'dbgate-types';
 import { AlterPlan } from './alterPlan';
 declare type DbDiffSchemaMode = 'strict' | 'ignore' | 'ignoreImplicit';
 export interface DbDiffOptions {
-    allowRecreateTable?: boolean;
-    allowRecreateConstraint?: boolean;
-    allowRecreateSpecificObject?: boolean;
-    allowPairRenamedTables?: boolean;
     ignoreCase?: boolean;
     schemaMode?: DbDiffSchemaMode;
     leftImplicitSchema?: string;
     rightImplicitSchema?: string;
+    ignoreConstraintNames?: boolean;
+    noDropTable?: boolean;
+    noDropColumn?: boolean;
+    noDropConstraint?: boolean;
+    noDropSqlObject?: boolean;
+    noRenameTable?: boolean;
+    noRenameColumn?: boolean;
+    ignoreForeignKeyActions?: boolean;
+    ignoreDataTypes?: boolean;
 }
 export declare function generateTablePairingId(table: TableInfo): TableInfo;
 export declare function generateDbPairingId(db: DatabaseInfo): DatabaseInfo;
 export declare function testEqualColumns(a: ColumnInfo, b: ColumnInfo, checkName: boolean, checkDefault: boolean, opts?: DbDiffOptions): boolean;
 export declare function testEqualTypes(a: ColumnInfo, b: ColumnInfo, opts?: DbDiffOptions): boolean;
+export declare function testEqualTables(a: TableInfo, b: TableInfo, opts: DbDiffOptions, db: DatabaseInfo, driver: EngineDriver): boolean;
+export declare function testEqualSqlObjects(a: SqlObjectInfo, b: SqlObjectInfo, opts: DbDiffOptions): boolean;
 export declare function createAlterTablePlan(oldTable: TableInfo, newTable: TableInfo, opts: DbDiffOptions, db: DatabaseInfo, driver: EngineDriver): AlterPlan;
 export declare function createAlterDatabasePlan(oldDb: DatabaseInfo, newDb: DatabaseInfo, opts: DbDiffOptions, db: DatabaseInfo, driver: EngineDriver): AlterPlan;
 export declare function getAlterTableScript(oldTable: TableInfo, newTable: TableInfo, opts: DbDiffOptions, db: DatabaseInfo, driver: EngineDriver): {
+    sql: string;
+    recreates: any[];
+} | {
     sql: string;
     recreates: {
         tables: number;
@@ -32,5 +42,8 @@ export declare function getAlterDatabaseScript(oldDb: DatabaseInfo, newDb: Datab
         constraints: number;
         sqlObjects: number;
     };
+    isEmpty: boolean;
 };
+export declare function matchPairedObjects(db1: DatabaseInfo, db2: DatabaseInfo, opts: DbDiffOptions): DatabaseInfo;
+export declare const modelCompareDbDiffOptions: DbDiffOptions;
 export {};

package/lib/diffTools.js

@@ -3,10 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAlterDatabaseScript = exports.getAlterTableScript = exports.createAlterDatabasePlan = exports.createAlterTablePlan = exports.testEqualTypes = exports.testEqualColumns = exports.generateDbPairingId = exports.generateTablePairingId = void 0;
+exports.modelCompareDbDiffOptions = exports.matchPairedObjects = exports.getAlterDatabaseScript = exports.getAlterTableScript = exports.createAlterDatabasePlan = exports.createAlterTablePlan = exports.testEqualSqlObjects = exports.testEqualTables = exports.testEqualTypes = exports.testEqualColumns = exports.generateDbPairingId = exports.generateTablePairingId = void 0;
 const v1_1 = __importDefault(require("uuid/v1"));
 const alterPlan_1 = require("./alterPlan");
 const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const omit_1 = __importDefault(require("lodash/omit"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const pick_1 = __importDefault(require("lodash/pick"));
 function generateTablePairingId(table) {
     var _a, _b, _c, _d, _e;
     if (!table)
@@ -33,7 +37,7 @@ function generateDbPairingId(db) {
 exports.generateDbPairingId = generateDbPairingId;
 function testEqualNames(a, b, opts) {
     if (opts.ignoreCase)
-        return a.toLowerCase() == b.toLowerCase();
+        return (a || '').toLowerCase() == (b || '').toLowerCase();
     return a == b;
 }
 function testEqualSchemas(lschema, rschema, opts) {
@@ -63,6 +67,7 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
     //    return false;
     //}
     if (a.computedExpression != b.computedExpression) {
+        console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different computed expression: ${a.computedExpression}, ${b.computedExpression}`);
         // opts.DiffLogger.Trace(
         //   'Column {0}, {1}: different computed expression: {2}; {3}',
         //   a,
@@ -78,6 +83,7 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
     if (checkDefault) {
         if (a.defaultValue == null) {
             if (a.defaultValue != b.defaultValue) {
+                console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different default value: ${a.defaultValue}, ${b.defaultValue}`);
                 // opts.DiffLogger.Trace(
                 //   'Column {0}, {1}: different default values: {2}; {3}',
                 //   a,
@@ -90,6 +96,7 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
         }
         else {
             if (a.defaultValue != b.defaultValue) {
+                console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different default value: ${a.defaultValue}, ${b.defaultValue}`);
                 // opts.DiffLogger.Trace(
                 //   'Column {0}, {1}: different default values: {2}; {3}',
                 //   a,
@@ -101,6 +108,7 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
             }
         }
         if (a.defaultConstraint != b.defaultConstraint) {
+            console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different default constraint: ${a.defaultConstraint}, ${b.defaultConstraint}`);
             // opts.DiffLogger.Trace(
             //   'Column {0}, {1}: different default constraint names: {2}; {3}',
             //   a,
@@ -111,15 +119,18 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
             return false;
         }
     }
-    if (a.notNull != b.notNull) {
+    if ((a.notNull || false) != (b.notNull || false)) {
+        console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different nullability: ${a.notNull}, ${b.notNull}`);
         // opts.DiffLogger.Trace('Column {0}, {1}: different nullable: {2}; {3}', a, b, a.NotNull, b.NotNull);
         return false;
     }
-    if (a.autoIncrement != b.autoIncrement) {
+    if ((a.autoIncrement || false) != (b.autoIncrement || false)) {
+        console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different autoincrement: ${a.autoIncrement}, ${b.autoIncrement}`);
         // opts.DiffLogger.Trace('Column {0}, {1}: different autoincrement: {2}; {3}', a, b, a.AutoIncrement, b.AutoIncrement);
         return false;
     }
-    if (a.isSparse != b.isSparse) {
+    if ((a.isSparse || false) != (b.isSparse || false)) {
+        console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different is_sparse: ${a.isSparse}, ${b.isSparse}`);
         // opts.DiffLogger.Trace('Column {0}, {1}: different is_sparse: {2}; {3}', a, b, a.IsSparse, b.IsSparse);
         return false;
     }
@@ -154,28 +165,36 @@ function testEqualColumns(a, b, checkName, checkDefault, opts = {}) {
 }
 exports.testEqualColumns = testEqualColumns;
 function testEqualConstraints(a, b, opts = {}) {
-    return (0, json_stable_stringify_1.default)(a) == (0, json_stable_stringify_1.default)(b);
+    const omitList = [];
+    if (opts.ignoreForeignKeyActions) {
+        omitList.push('updateAction');
+        omitList.push('deleteAction');
+    }
+    if (opts.ignoreConstraintNames) {
+        omitList.push('constraintName');
+    }
+    if (opts.schemaMode == 'ignore') {
+        omitList.push('schemaName');
+        omitList.push('refSchemaName');
+    }
+    // if (a.constraintType == 'primaryKey' && b.constraintType == 'primaryKey') {
+    //   console.log('PK1', stableStringify(_.omit(a, omitList)));
+    //   console.log('PK2', stableStringify(_.omit(b, omitList)));
+    // }
+    // if (a.constraintType == 'foreignKey' && b.constraintType == 'foreignKey') {
+    //   console.log('FK1', stableStringify(_omit(a, omitList)));
+    //   console.log('FK2', stableStringify(_omit(b, omitList)));
+    // }
+    return (0, json_stable_stringify_1.default)((0, omit_1.default)(a, omitList)) == (0, json_stable_stringify_1.default)((0, omit_1.default)(b, omitList));
 }
 function testEqualTypes(a, b, opts = {}) {
-    if (a.dataType != b.dataType) {
-        // opts.DiffLogger.Trace("Column {0}, {1}: different types: {2}; {3}", a, b, a.DataType, b.DataType);
+    if (opts.ignoreDataTypes) {
+        return true;
+    }
+    if ((a.dataType || '').toLowerCase() != (b.dataType || '').toLowerCase()) {
+        console.debug(`Column ${a.pureName}.${a.columnName}, ${b.pureName}.${b.columnName}: different data type: ${a.dataType}, ${b.dataType}`);
         return false;
     }
-    //if (a.Length != b.Length)
-    //{
-    //    opts.DiffLogger.Trace("Column {0}, {1}: different lengths: {2}; {3}", a, b, a.Length, b.Length);
-    //    return false;
-    //}
-    //if (a.Precision != b.Precision)
-    //{
-    //    opts.DiffLogger.Trace("Column {0}, {1}: different lengths: {2}; {3}", a, b, a.Precision, b.Precision);
-    //    return false;
-    //}
-    //if (a.Scale != b.Scale)
-    //{
-    //    opts.DiffLogger.Trace("Column {0}, {1}: different scale: {2}; {3}", a, b, a.Scale, b.Scale);
-    //    return false;
-    //}
     return true;
 }
 exports.testEqualTypes = testEqualTypes;
@@ -215,9 +234,13 @@ function planAlterTable(plan, oldTable, newTable, opts) {
     // if (oldTable.primaryKey)
     const columnPairs = createPairs(oldTable.columns, newTable.columns);
     const constraintPairs = createPairs(getTableConstraints(oldTable), getTableConstraints(newTable), (a, b) => a.constraintType == 'primaryKey' && b.constraintType == 'primaryKey');
-    constraintPairs.filter(x => x[1] == null).forEach(x => plan.dropConstraint(x[0]));
-    columnPairs.filter(x => x[1] == null).forEach(x => plan.dropColumn(x[0]));
-    if (!testEqualFullNames(oldTable, newTable, opts)) {
+    if (!opts.noDropConstraint) {
+        constraintPairs.filter(x => x[1] == null).forEach(x => plan.dropConstraint(x[0]));
+    }
+    if (!opts.noDropColumn) {
+        columnPairs.filter(x => x[1] == null).forEach(x => plan.dropColumn(x[0]));
+    }
+    if (!testEqualFullNames(oldTable, newTable, opts) && !opts.noRenameTable) {
         plan.renameTable(oldTable, newTable.pureName);
     }
     columnPairs.filter(x => x[0] == null).forEach(x => plan.createColumn(x[1]));
@@ -225,7 +248,7 @@ function planAlterTable(plan, oldTable, newTable, opts) {
         .filter(x => x[0] && x[1])
         .forEach(x => {
         if (!testEqualColumns(x[0], x[1], true, true, opts)) {
-            if (testEqualColumns(x[0], x[1], false, true, opts)) {
+            if (testEqualColumns(x[0], x[1], false, true, opts) && !opts.noRenameColumn) {
                 // console.log('PLAN RENAME COLUMN')
                 plan.renameColumn(x[0], x[1].columnName);
             }
@@ -245,11 +268,25 @@ function planAlterTable(plan, oldTable, newTable, opts) {
     });
     constraintPairs.filter(x => x[0] == null).forEach(x => plan.createConstraint(x[1]));
 }
+function testEqualTables(a, b, opts, db, driver) {
+    const plan = new alterPlan_1.AlterPlan(db, driver.dialect, opts);
+    planAlterTable(plan, a, b, opts);
+    // console.log('plan.operations', a, b, plan.operations);
+    return plan.operations.length == 0;
+}
+exports.testEqualTables = testEqualTables;
+function testEqualSqlObjects(a, b, opts) {
+    return a.createSql == b.createSql;
+}
+exports.testEqualSqlObjects = testEqualSqlObjects;
 function createAlterTablePlan(oldTable, newTable, opts, db, driver) {
-    const plan = new alterPlan_1.AlterPlan(db, driver.dialect);
+    const plan = new alterPlan_1.AlterPlan(db, driver.dialect, opts);
     if (oldTable == null) {
         plan.createTable(newTable);
     }
+    else if (newTable == null) {
+        plan.dropTable(oldTable);
+    }
     else {
         planAlterTable(plan, oldTable, newTable, opts);
     }
@@ -258,22 +295,31 @@ function createAlterTablePlan(oldTable, newTable, opts, db, driver) {
 }
 exports.createAlterTablePlan = createAlterTablePlan;
 function createAlterDatabasePlan(oldDb, newDb, opts, db, driver) {
-    const plan = new alterPlan_1.AlterPlan(db, driver.dialect);
+    const plan = new alterPlan_1.AlterPlan(db, driver.dialect, opts);
     for (const objectTypeField of ['tables', 'views', 'procedures', 'matviews', 'functions']) {
         for (const oldobj of oldDb[objectTypeField] || []) {
             const newobj = (newDb[objectTypeField] || []).find(x => x.pairingId == oldobj.pairingId);
             if (objectTypeField == 'tables') {
-                if (newobj == null)
-                    plan.dropTable(oldobj);
-                else
+                if (newobj == null) {
+                    if (!opts.noDropTable) {
+                        plan.dropTable(oldobj);
+                    }
+                }
+                else {
                     planAlterTable(plan, oldobj, newobj, opts);
+                }
             }
             else {
-                if (newobj == null)
-                    plan.dropSqlObject(oldobj);
-                else if (newobj.createSql != oldobj.createSql) {
+                if (newobj == null) {
+                    if (!opts.noDropSqlObject) {
+                        plan.dropSqlObject(oldobj);
+                    }
+                }
+                else if (!testEqualSqlObjects(oldobj.createSql, newobj.createSql, opts)) {
                     plan.recreates.sqlObjects += 1;
-                    plan.dropSqlObject(oldobj);
+                    if (!opts.noDropSqlObject) {
+                        plan.dropSqlObject(oldobj);
+                    }
                     plan.createSqlObject(newobj);
                 }
             }
@@ -281,11 +327,11 @@ function createAlterDatabasePlan(oldDb, newDb, opts, db, driver) {
         for (const newobj of newDb[objectTypeField] || []) {
             const oldobj = (oldDb[objectTypeField] || []).find(x => x.pairingId == newobj.pairingId);
             if (objectTypeField == 'tables') {
-                if (newobj == null)
+                if (oldobj == null)
                     plan.createTable(newobj);
             }
             else {
-                if (newobj == null)
+                if (oldobj == null)
                     plan.createSqlObject(newobj);
             }
         }
@@ -295,6 +341,9 @@ function createAlterDatabasePlan(oldDb, newDb, opts, db, driver) {
 }
 exports.createAlterDatabasePlan = createAlterDatabasePlan;
 function getAlterTableScript(oldTable, newTable, opts, db, driver) {
+    if ((!oldTable && !newTable) || !driver) {
+        return { sql: '', recreates: [] };
+    }
     const plan = createAlterTablePlan(oldTable, newTable, opts, db, driver);
     const dmp = driver.createDumper();
     if (!driver.dialect.disableExplicitTransaction)
@@ -319,6 +368,42 @@ function getAlterDatabaseScript(oldDb, newDb, opts, db, driver) {
     return {
         sql: dmp.s,
         recreates: plan.recreates,
+        isEmpty: plan.operations.length == 0,
     };
 }
 exports.getAlterDatabaseScript = getAlterDatabaseScript;
+function matchPairedObjects(db1, db2, opts) {
+    if (!db1 || !db2)
+        return null;
+    const res = (0, cloneDeep_1.default)(db2);
+    for (const objectTypeField of ['tables', 'views', 'procedures', 'matviews', 'functions']) {
+        for (const obj2 of res[objectTypeField] || []) {
+            const obj1 = db1[objectTypeField].find(x => testEqualFullNames(x, obj2, opts));
+            if (obj1) {
+                obj2.pairingId = obj1.pairingId;
+                if (objectTypeField == 'tables') {
+                    for (const col2 of obj2.columns) {
+                        const col1 = obj1.columns.find(x => testEqualNames(x.columnName, col2.columnName, opts));
+                        if (col1)
+                            col2.pairingId = col1.pairingId;
+                    }
+                    for (const fk2 of obj2.foreignKeys) {
+                        const fk1 = obj1.foreignKeys.find(x => testEqualNames(x.refTableName, fk2.refTableName, opts) &&
+                            (0, isEqual_1.default)(x.columns.map(y => (0, pick_1.default)(y, ['columnName', 'refColumnName'])), fk2.columns.map(y => (0, pick_1.default)(y, ['columnName', 'refColumnName']))));
+                        if (fk1)
+                            fk2.pairingId = fk1.pairingId;
+                    }
+                }
+            }
+        }
+    }
+    return res;
+}
+exports.matchPairedObjects = matchPairedObjects;
+exports.modelCompareDbDiffOptions = {
+    ignoreCase: true,
+    schemaMode: 'ignore',
+    ignoreConstraintNames: true,
+    ignoreForeignKeyActions: true,
+    ignoreDataTypes: true,
+};

package/lib/index.d.ts

@@ -13,4 +13,6 @@ export * from './settingsExtractors';
 export * from './filterName';
 export * from './diffTools';
 export * from './schemaEditorTools';
+export * from './yamlModelConv';
 export * from './stringTools';
+export * from './computeDiffRows';

package/lib/index.js

@@ -25,4 +25,6 @@ __exportStar(require("./settingsExtractors"), exports);
 __exportStar(require("./filterName"), exports);
 __exportStar(require("./diffTools"), exports);
 __exportStar(require("./schemaEditorTools"), exports);
+__exportStar(require("./yamlModelConv"), exports);
 __exportStar(require("./stringTools"), exports);
+__exportStar(require("./computeDiffRows"), exports);

package/lib/yamlModelConv.d.ts

@@ -0,0 +1,25 @@
+import { TableInfo, DatabaseInfo } from 'dbgate-types';
+export interface ColumnInfoYaml {
+    name: string;
+    type: string;
+    notNull?: boolean;
+    autoIncrement?: boolean;
+    references?: string;
+    primaryKey?: boolean;
+}
+export interface DatabaseModelFile {
+    name: string;
+    text: string;
+    json: {};
+}
+export interface TableInfoYaml {
+    name: string;
+    columns: ColumnInfoYaml[];
+    primaryKey?: string[];
+}
+export interface ForeignKeyInfoYaml {
+    deleteAction?: string;
+}
+export declare function tableInfoToYaml(table: TableInfo): TableInfoYaml;
+export declare function tableInfoFromYaml(table: TableInfoYaml, allTables: TableInfoYaml[]): TableInfo;
+export declare function databaseInfoFromYamlModel(files: DatabaseModelFile[]): DatabaseInfo;

package/lib/yamlModelConv.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.databaseInfoFromYamlModel = exports.tableInfoFromYaml = exports.tableInfoToYaml = void 0;
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const compact_1 = __importDefault(require("lodash/compact"));
+const DatabaseAnalyser_1 = require("./DatabaseAnalyser");
+// function foreignKeyInfoToYaml() {}
+function columnInfoToYaml(column, table) {
+    const res = {
+        name: column.columnName,
+        type: column.dataType,
+    };
+    if (column.autoIncrement)
+        res.autoIncrement = true;
+    if (column.notNull)
+        res.notNull = true;
+    const fk = table.foreignKeys &&
+        table.foreignKeys.find(fk => fk.columns.length == 1 && fk.columns[0].columnName == column.columnName);
+    if (fk &&
+        // fk.refSchemaName == table.schemaName &&
+        (!fk.deleteAction || fk.deleteAction == 'NO ACTION') &&
+        (!fk.updateAction || fk.updateAction == 'NO ACTION')) {
+        res.references = fk.refTableName;
+        fk['_dumped'] = true;
+    }
+    // if (table.primaryKey && table.primaryKey.columns.length == 1) {
+    //   table.primaryKey['_dumped'] = true;
+    //   res.primaryKey = true;
+    // }
+    return res;
+}
+function columnInfoFromYaml(column, table) {
+    const res = {
+        pureName: table.name,
+        columnName: column.name,
+        dataType: column.type,
+        autoIncrement: column.autoIncrement,
+        notNull: column.notNull || (table.primaryKey && table.primaryKey.includes(column.name)),
+    };
+    return res;
+}
+function tableInfoToYaml(table) {
+    const tableCopy = (0, cloneDeep_1.default)(table);
+    const res = {
+        name: tableCopy.pureName,
+        // schema: tableCopy.schemaName,
+        columns: tableCopy.columns.map(c => columnInfoToYaml(c, tableCopy)),
+    };
+    if (tableCopy.primaryKey && !tableCopy.primaryKey['_dumped']) {
+        res.primaryKey = tableCopy.primaryKey.columns.map(x => x.columnName);
+    }
+    // const foreignKeys = (tableCopy.foreignKeys || []).filter(x => !x['_dumped']).map(foreignKeyInfoToYaml);
+    return res;
+}
+exports.tableInfoToYaml = tableInfoToYaml;
+function convertForeignKeyFromYaml(col, table, allTables) {
+    const refTable = allTables.find(x => x.name == col.references);
+    if (!refTable || !refTable.primaryKey)
+        return null;
+    return {
+        constraintType: 'foreignKey',
+        pureName: table.name,
+        refTableName: col.references,
+        columns: [
+            {
+                columnName: col.name,
+                refColumnName: refTable.primaryKey[0],
+            },
+        ],
+    };
+}
+function tableInfoFromYaml(table, allTables) {
+    const res = {
+        pureName: table.name,
+        columns: table.columns.map(c => columnInfoFromYaml(c, table)),
+        foreignKeys: (0, compact_1.default)(table.columns.filter(x => x.references).map(col => convertForeignKeyFromYaml(col, table, allTables))),
+    };
+    if (table.primaryKey) {
+        res.primaryKey = {
+            pureName: table.name,
+            constraintType: 'primaryKey',
+            columns: table.primaryKey.map(columnName => ({ columnName })),
+        };
+    }
+    return res;
+}
+exports.tableInfoFromYaml = tableInfoFromYaml;
+function databaseInfoFromYamlModel(files) {
+    const model = DatabaseAnalyser_1.DatabaseAnalyser.createEmptyStructure();
+    const tablesYaml = [];
+    for (const file of files) {
+        if (file.name.endsWith('.table.yaml') || file.name.endsWith('.sql')) {
+            if (file.name.endsWith('.table.yaml')) {
+                tablesYaml.push(file.json);
+            }
+            if (file.name.endsWith('.view.sql')) {
+                model.views.push({
+                    pureName: file.name.slice(0, -'.view.sql'.length),
+                    createSql: file.text,
+                    columns: [],
+                });
+            }
+            if (file.name.endsWith('.matview.sql')) {
+                model.matviews.push({
+                    pureName: file.name.slice(0, -'.matview.sql'.length),
+                    createSql: file.text,
+                    columns: [],
+                });
+            }
+            if (file.name.endsWith('.proc.sql')) {
+                model.procedures.push({
+                    pureName: file.name.slice(0, -'.proc.sql'.length),
+                    createSql: file.text,
+                });
+            }
+            if (file.name.endsWith('.func.sql')) {
+                model.functions.push({
+                    pureName: file.name.slice(0, -'.func.sql'.length),
+                    createSql: file.text,
+                });
+            }
+            if (file.name.endsWith('.trigger.sql')) {
+                model.triggers.push({
+                    pureName: file.name.slice(0, -'.trigger.sql'.length),
+                    createSql: file.text,
+                });
+            }
+        }
+    }
+    model.tables = tablesYaml.map(table => tableInfoFromYaml(table, tablesYaml));
+    return model;
+}
+exports.databaseInfoFromYamlModel = databaseInfoFromYamlModel;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.3.4",
+  "version": "4.4.1",
   "name": "dbgate-tools",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -25,14 +25,14 @@
   ],
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^4.3.4",
+    "dbgate-types": "^4.4.1",
     "jest": "^24.9.0",
     "ts-jest": "^25.2.1",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "lodash": "^4.17.21",
-    "dbgate-query-splitter": "^4.3.4",
+    "dbgate-query-splitter": "^4.4.1",
     "uuid": "^3.4.0"
   }
 }