dbmodel 0.1.2 → 5.2.2-alpha.11

package/lib/clients/mssql/build.js

@@ -1,191 +0,0 @@
-const _ = require('lodash');
-const fs = require('fs');
-const endOfLine = require('os').EOL;
-const {
-  getCreateTableSql,
-  getCreateColumnSql,
-  getCreateFkSql,
-  getCreateIndexSql,
-  getProjectIndexesAsDatabase,
-  sortViewsByDependency,
-  getFillTableSql,
-} = require('./getsql');
-
-function writeLine(options, data) {
-  fs.writeSync(options.outputDescriptor, data);
-  fs.writeSync(options.outputDescriptor, endOfLine);
-}
-
-function buildTables(options) {
-  const tables = options.projectStructure.tables;
-
-  for (const tableName of _.keys(tables)) {
-    const table = tables[tableName];
-    writeLine(options, `IF (NOT EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='${tableName}'))`);
-    writeLine(options, 'BEGIN');
-    writeLine(options, `PRINT 'Creating table ${tableName}'`);
-    writeLine(options, getCreateTableSql(table));
-    writeLine(options, 'END');
-    writeLine(options, 'ELSE');
-    writeLine(options, 'BEGIN');
-    writeLine(options, `PRINT 'Table ${tableName} already exists'`);
-    writeLine(options, 'END');
-    writeLine(options, 'GO');
-
-    for (const column of table.columns) {
-      writeLine(
-        options,
-        `IF (NOT EXISTS(SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='${tableName}' AND COLUMN_NAME='${column.name}'))`
-      );
-      writeLine(options, 'BEGIN');
-      writeLine(options, `PRINT 'Creating column ${tableName}.${column.name}'`);
-      writeLine(options, getCreateColumnSql(table, column));
-      writeLine(options, 'END');
-      writeLine(options, 'GO');
-    }
-  }
-
-  for (const tableName of _.keys(tables)) {
-    const table = tables[tableName];
-    for (const column of table.columns) {
-      if (column.references) {
-        writeLine(
-          options,
-          `IF (NOT EXISTS(
-            SELECT *
-            FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C
-            INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK 
-              ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME AND c.CONSTRAINT_SCHEMA = FK.CONSTRAINT_SCHEMA
-            LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK 
-              ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME AND c.UNIQUE_CONSTRAINT_SCHEMA = PK.CONSTRAINT_SCHEMA
-            LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU 
-              ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME AND C.CONSTRAINT_SCHEMA = CU.CONSTRAINT_SCHEMA
-            WHERE c.CONSTRAINT_SCHEMA = 'dbo' 
-              AND FK.TABLE_NAME='${tableName}'
-              AND PK.TABLE_NAME='${column.references}'
-              AND CU.COLUMN_NAME = '${column.name}'
-            ))
-            `
-        );
-        writeLine(options, 'BEGIN');
-        writeLine(options, `PRINT 'Creating foreign key on ${tableName}.${column.name}'`);
-        writeLine(options, getCreateFkSql(table, column, tables));
-        writeLine(options, 'END');
-        writeLine(options, 'GO');
-      }
-    }
-  }
-
-  const projectIndexArray = getProjectIndexesAsDatabase(tables);
-
-  for (const index of projectIndexArray) {
-    writeLine(
-      options,
-      `IF (NOT EXISTS(
-      SELECT *
-      FROM sys.indexes i
-      inner join sys.objects o ON o.object_id = i.object_id
-      WHERE i.name='${index.indexName}' and o.name='${index.tableName}'
-      and i.is_primary_key=0
-      and i.is_hypothetical=0 and indexproperty(i.object_id, i.name, 'IsStatistics') = 0
-      and objectproperty(i.object_id, 'IsUserTable') = 1
-      and i.index_id between 1 and 254
-      ))`
-    );
-    writeLine(options, 'BEGIN');
-    writeLine(options, `PRINT 'Creating index ${index.indexName} on ${index.tableName}'`);
-    writeLine(options, getCreateIndexSql(index));
-    writeLine(options, 'END');
-    writeLine(options, 'GO');
-  }
-}
-
-function buildObjects(
-  options,
-  projectObjects,
-  objectTypeName,
-  createRegex,
-  createCommand,
-  alterCommand,
-  info_schema,
-  info_schema_column,
-  sortObjects
-) {
-  const sortedList = sortObjects ? sortObjects(_.keys(projectObjects), projectObjects) : _.keys(projectObjects);
-
-  for (const objectName of sortedList) {
-    const objectSql = projectObjects[objectName];
-    writeLine(options, `DECLARE @sql NVARCHAR(MAX) = '';`);
-
-    writeLine(
-      options,
-      `IF (NOT EXISTS(
-      SELECT * FROM INFORMATION_SCHEMA.${info_schema} WHERE ${info_schema_column}='${objectName}'
-      ))`
-    );
-    writeLine(options, 'BEGIN');
-    writeLine(options, `PRINT 'Creating ${objectTypeName} ${objectName}'`);
-    writeLine(options, `SET @sql = '${createCommand}';`);
-    writeLine(options, 'END');
-    writeLine(options, `ELSE`);
-    writeLine(options, 'BEGIN');
-    writeLine(options, `PRINT 'Altering ${objectTypeName} ${objectName}'`);
-    writeLine(options, `SET @sql = '${alterCommand}';`);
-    writeLine(options, 'END');
-
-    writeLine(options, `SET @sql = @sql + ' ' + '${objectSql.replace(createRegex, '').replace(/'/g, "''")}';`);
-    writeLine(options, `EXEC sp_executesql @sql;`);
-    writeLine(options, 'GO');
-  }
-}
-
-function buildFillTables(options) {
-  const tables = options.projectStructure.tables;
-  for (const tableName of _.keys(tables)) {
-    const table = tables[tableName];
-    const sql = getFillTableSql(table);
-    if (!sql) continue;
-    writeLine(options, `PRINT 'Filling table ${tableName}'`);
-    writeLine(options, sql);
-  }
-}
-
-async function build(options) {
-  buildTables(options);
-
-  buildObjects(
-    options,
-    options.projectStructure.views,
-    'view',
-    /create\s+view/i,
-    'CREATE VIEW',
-    'ALTER VIEW',
-    'VIEWS',
-    'TABLE_NAME',
-    sortViewsByDependency
-  );
-  buildObjects(
-    options,
-    options.projectStructure.procedures,
-    'procedure',
-    /create\s+procedure/i,
-    'CREATE PROCEDURE',
-    'ALTER PROCEDURE',
-    'ROUTINES',
-    'ROUTINE_NAME'
-  );
-  buildObjects(
-    options,
-    options.projectStructure.functions,
-    'function',
-    /create\s+function/i,
-    'CREATE FUNCTION',
-    'ALTER FUNCTION',
-    'ROUTINES',
-    'ROUTINE_NAME'
-  );
-
-  buildFillTables(options);
-}
-
-module.exports = build;

package/lib/clients/mssql/connect.js

@@ -1,9 +0,0 @@
-const mssql = require('mssql');
-
-async function connect(options) {
-  if (options.mssqlPool) return options; // already connected
-  const { connection } = options;
-  options.mssqlPool = await mssql.connect(connection);
-}
-
-module.exports = connect;

package/lib/clients/mssql/deploy.js

@@ -1,343 +0,0 @@
-const _ = require('lodash');
-const JSONNormalize = require('json-normalize');
-const {
-  getColumnDefinitionSql,
-  getCreateTableSql,
-  getCreateColumnSql,
-  getCreateFkSql,
-  getCreateIndexSql,
-  getProjectIndexesAsDatabase,
-  getFillTableSql,
-  sortViewsByDependency,
-} = require('./getsql');
-
-async function executeAndLog(options, log, command, logSql = true) {
-  if (_.isArray(command)) {
-    if (log) {
-      console.log(log);
-    }
-    for (const cmd of command) {
-      await executeAndLog(options, null, cmd, logSql);
-    }
-  } else {
-    if (log) {
-      console.log(log);
-    }
-    if (logSql) {
-      console.log(command);
-    }
-
-    const { mssqlPool } = options;
-    await mssqlPool.request().query(command);
-  }
-}
-
-async function processAddedTables(options) {
-  const dbTables = options.databaseStructure.mssqlModel.tables;
-  const projectTables = options.projectStructure.tables;
-  const adding = _.difference(Object.keys(projectTables), Object.keys(dbTables));
-  await Promise.all(
-    adding.map(async table => {
-      const createSql = getCreateTableSql(projectTables[table]);
-      await executeAndLog(options, `Adding table ${table}`, createSql);
-    })
-  );
-}
-
-async function processTableData(options) {
-  const projectTables = options.projectStructure.tables;
-
-  for (const table of _.values(projectTables)) {
-    const sql = getFillTableSql(table);
-    if (!sql) continue;
-    await executeAndLog(options, `Filling table ${table.name}`, sql, false);
-  }
-}
-
-async function processAddedColumns(options) {
-  const dbTables = options.databaseStructure.mssqlModel.tables;
-  const projectTables = options.projectStructure.tables;
-
-  const both = _.intersection(Object.keys(projectTables), Object.keys(dbTables));
-  await Promise.all(
-    both.map(async table => {
-      const dbTable = dbTables[table];
-      const projectTable = projectTables[table];
-      const adding = _.difference(
-        projectTable.columns.map(x => x.name),
-        dbTable.map(x => x.columnName)
-      );
-      await Promise.all(
-        adding.map(async column => {
-          const createSql = getCreateColumnSql(
-            projectTable,
-            projectTable.columns.find(x => x.name == column)
-          );
-          await executeAndLog(options, `Adding column ${column}`, createSql);
-        })
-      );
-    })
-  );
-}
-
-function normalizeDefaultValue(value) {
-  if (value == null) return null;
-  let svalue = value.toString();
-  while (svalue.startsWith('(') && svalue.endsWith(')')) {
-    svalue = svalue.substring(1, svalue.length - 1);
-  }
-  return svalue;
-}
-
-async function processColumnTypeUpdate(options) {
-  const dbTables = options.databaseStructure.mssqlModel.tables;
-  const projectTables = options.projectStructure.tables;
-  const { suggestions } = options;
-
-  const bothTables = _.intersection(Object.keys(projectTables), Object.keys(dbTables));
-  await Promise.all(
-    bothTables.map(async table => {
-      const dbTable = dbTables[table];
-      const projectTable = projectTables[table];
-      const bothColumns = _.intersection(
-        projectTable.columns.map(x => x.name),
-        dbTable.map(x => x.columnName)
-      );
-      for (const column of bothColumns) {
-        const projectCol = projectTable.columns.filter(x => x.name == column)[0];
-        const dbCol = dbTable.filter(x => x.columnName == column)[0];
-
-        if (!dbCol.isNullable != (projectCol.notNull || false)) {
-          const sql = `ALTER TABLE [${table}] ALTER COLUMN ${getColumnDefinitionSql(projectTable, projectCol)};`;
-          const message = `Changing column notNull flag ${table}.${column} from ${!dbCol.isNullable} to ${
-            projectCol.notNull
-          }`;
-          suggestions.push({ sql, message });
-          // await executeAndLog(options, message, sql);
-        }
-
-        if (dbCol.defaultValue == null && projectCol.default != null) {
-          const sql = `ALTER TABLE [${table}] ADD CONSTRAINT [DF_${table}_${column}] DEFAULT ${projectCol.default} FOR [${column}]`;
-          const message = `Creating default value for column ${column} from table ${table}, ${projectCol.default}`;
-          suggestions.push({ sql, message });
-        }
-
-        if (dbCol.defaultValue != null && projectCol.default == null) {
-          const sql = `ALTER TABLE [${table}] DROP CONSTRAINT [DF_${table}_${column}]`;
-          const message = `Drop default value for column ${column} from table ${table}`;
-          suggestions.push({ sql, message });
-        }
-
-        if (
-          dbCol.defaultValue != null &&
-          projectCol.default != null &&
-          normalizeDefaultValue(projectCol.default) != normalizeDefaultValue(dbCol.defaultValue)
-        ) {
-          const sql = `ALTER TABLE [${table}] DROP CONSTRAINT [DF_${table}_${column}];ALTER TABLE [${table}] ADD CONSTRAINT [DF_${table}_${column}] DEFAULT ${projectCol.default} FOR [${column}]`;
-          const message = `Changing default value for column ${column} from table ${table}, ${projectCol.default}`;
-          suggestions.push({ sql, message });
-        }
-      }
-    })
-  );
-}
-
-async function addMissingReferences(options) {
-  const projectTables = options.projectStructure.tables;
-  const dbReferences = options.databaseStructure.mssqlModel.references;
-
-  await Promise.all(
-    Object.keys(projectTables).map(async table => {
-      await Promise.all(
-        projectTables[table].columns
-          .filter(x => x.references)
-          .filter(x => !dbReferences.find(y => table == y.fkTable && x.name == y.fkColumn))
-          .map(async column => {
-            const createSql = getCreateFkSql(projectTables[table], column, projectTables);
-            await executeAndLog(options, `Adding foreign key ${table}.${column.name}`, createSql);
-          })
-      );
-    })
-  );
-}
-
-function jsonNormalizeIndex(index) {
-  const indexCopy = { ...index };
-  if (!indexCopy.filterDefinition) delete indexCopy.filterDefinition;
-  delete indexCopy.continueOnError;
-  if (indexCopy.filterDefinition) {
-    indexCopy.filterDefinition = indexCopy.filterDefinition
-      .replace(/\s/g, '')
-      .replace(/\(/g, '')
-      .replace(/\)/g, '')
-      .replace(/\[/g, '')
-      .replace(/\]/g, '');
-  }
-  return JSONNormalize.stringifySync(indexCopy);
-}
-
-async function processIndexes(options) {
-  const dbIndexes = options.databaseStructure.mssqlModel.indexes;
-  const projectTables = options.projectStructure.tables;
-  const { suggestions } = options;
-
-  const dbIndexArray = _.flatten(_.values(dbIndexes).map(it => _.values(it)));
-  const projectIndexArray = getProjectIndexesAsDatabase(projectTables);
-
-  for (const dbIndex of dbIndexArray) {
-    const prjIndex = projectIndexArray.find(
-      x => x.tableName === dbIndex.tableName && x.indexName === dbIndex.indexName
-    );
-    if (prjIndex != null && (prjIndex == null || jsonNormalizeIndex(prjIndex) != jsonNormalizeIndex(dbIndex))) {
-      await executeAndLog(
-        options,
-        `Removing index ${dbIndex.indexName} on ${dbIndex.tableName}`,
-        `DROP INDEX [${dbIndex.indexName}] ON [${dbIndex.tableName}]`
-      );
-    }
-
-    if (prjIndex == null) {
-      suggestions.push({
-        message: `Index ${dbIndex.indexName} on ${dbIndex.tableName} not found in project`,
-        sql: `DROP INDEX [${dbIndex.indexName}] ON [${dbIndex.tableName}];`,
-      });
-    }
-  }
-
-  // eslint-disable-next-line require-atomic-updates
-  for (const prjIndex of projectIndexArray) {
-    const dbIndex = dbIndexArray.find(x => x.tableName === prjIndex.tableName && x.indexName === prjIndex.indexName);
-    if (dbIndex == null || jsonNormalizeIndex(prjIndex) != jsonNormalizeIndex(dbIndex)) {
-      try {
-        await executeAndLog(
-          options,
-          `Creating index ${prjIndex.indexName} on ${prjIndex.tableName}`,
-          getCreateIndexSql(prjIndex)
-        );
-      } catch (e) {
-        if (prjIndex.continueOnError) {
-          console.log(`FAILED creating index ${prjIndex.indexName}: ${e.message}`);
-          console.log('Continue because of continueOnError');
-        } else {
-          throw e;
-        }
-      }
-    }
-  }
-}
-
-async function detectTablesOnlyInDb(options) {
-  const projectTables = options.projectStructure.tables;
-  const dbTables = options.databaseStructure.mssqlModel.tables;
-  const { suggestions } = options;
-
-  const removed = _.difference(Object.keys(dbTables), Object.keys(projectTables));
-  removed.forEach(table => {
-    suggestions.push({
-      message: `Table ${table} is only in DB (missing in project)`,
-      sql: `DROP TABLE [${table}];`,
-    });
-  });
-}
-
-async function detectColumnsOnlyInDb(options) {
-  const projectTables = options.projectStructure.tables;
-  const dbTables = options.databaseStructure.mssqlModel.tables;
-  const { suggestions } = options;
-
-  const bothTables = _.intersection(Object.keys(projectTables), Object.keys(dbTables));
-  for (const tableName of bothTables) {
-    const dbTable = dbTables[tableName];
-    const projectTable = projectTables[tableName];
-
-    const removed = _.difference(
-      dbTable.map(x => x.columnName),
-      projectTable.columns.map(x => x.name)
-    );
-    suggestions.push(
-      ...removed.map(col => ({
-        message: `Column ${col} from table ${tableName} is only in DB (missing in project)`,
-        sql: `ALTER TABLE [${tableName}] DROP COLUMN [${col}];`,
-      }))
-    );
-  }
-}
-
-async function processObjects(
-  options,
-  dbObjects,
-  projectObjects,
-  objectTypeName,
-  createRegex,
-  alterCommand,
-  sortObjects
-) {
-  const addedObjects = _.difference(Object.keys(projectObjects), Object.keys(dbObjects));
-  const bothObjects = _.intersection(Object.keys(projectObjects), Object.keys(dbObjects));
-
-  const addedSorted = sortObjects ? sortObjects(addedObjects, projectObjects) : addedObjects;
-
-  for (const addedObject of addedSorted) {
-    await executeAndLog(options, `Creating ${objectTypeName} ${addedObject}`, projectObjects[addedObject]);
-  }
-  for (const objectName of bothObjects) {
-    if (dbObjects[objectName].replace(createRegex, '') == projectObjects[objectName].replace(createRegex, '')) continue;
-    const sql = projectObjects[objectName].replace(createRegex, alterCommand);
-    await executeAndLog(options, `Altering ${objectTypeName} ${objectName}`, sql);
-  }
-}
-
-async function deploy(options) {
-  options.suggestions = [];
-
-  await processAddedTables(options);
-  await processAddedColumns(options);
-  await processTableData(options);
-  await processColumnTypeUpdate(options);
-  await addMissingReferences(options);
-  await processIndexes(options);
-  await detectTablesOnlyInDb(options);
-  await detectColumnsOnlyInDb(options);
-  await processObjects(
-    options,
-    options.databaseStructure.views,
-    options.projectStructure.views,
-    'view',
-    /create\s+view/i,
-    'ALTER VIEW',
-    sortViewsByDependency
-  );
-  await processObjects(
-    options,
-    options.databaseStructure.procedures,
-    options.projectStructure.procedures,
-    'procedure',
-    /create\s+procedure/i,
-    'ALTER PROCEDURE'
-  );
-  await processObjects(
-    options,
-    options.databaseStructure.functions,
-    options.projectStructure.functions,
-    'function',
-    /create\s+function/i,
-    'ALTER FUNCTION'
-  );
-
-  if (options.suggestions.length > 0) {
-    console.log(`Suggestions: ${options.suggestions.length}`);
-    for (const { message } of options.suggestions) {
-      console.log(message);
-    }
-
-    console.log('-------------------------------------------------------------');
-    for (const { sql } of options.suggestions) {
-      console.log(sql);
-      console.log('GO');
-    }
-  }
-
-  return options;
-}
-
-module.exports = deploy;

package/lib/clients/mssql/getsql.js

@@ -1,140 +0,0 @@
-const _ = require('lodash');
-const toposort = require('toposort');
-
-function getColumnDefinitionSql(tabledef, column, allowDefault = false) {
-  const dataType = column.type && column.type.toLowerCase() == 'json' ? 'nvarchar(max)' : column.type;
-  return (
-    `[${column.name}] ${dataType}${column.length ? '(' + (column.length < 0 ? 'MAX' : column.length) + ')' : ''} ` +
-    `${column.autoIncrement ? 'IDENTITY' : ''} ${column.notNull ? 'NOT NULL' : 'NULL'}` +
-    (allowDefault && column.default !== undefined
-      ? ` CONSTRAINT [DF_${tabledef.name}_${column.name}] DEFAULT ${column.default} `
-      : '')
-  );
-}
-
-function getCreateTableSql(tabledef) {
-  if (!tabledef.primaryKey) {
-    throw new Error(`Missing primary key in table ${tabledef.name}`);
-  }
-
-  const deflines = [
-    ...tabledef.columns.map(column => getColumnDefinitionSql(tabledef, column, true)),
-    `CONSTRAINT PK_${tabledef.name} PRIMARY KEY (${tabledef.primaryKey.map(x => `[${x}]`).join(',')})`,
-  ];
-  return `CREATE TABLE [${tabledef.name}] (\n${deflines.map(x => '  ' + x).join(',\n')}\n);\n`;
-}
-
-function getCreateColumnSql(tabledef, column) {
-  if (column.notNull && column.default !== undefined) {
-    const nullColumn = { ...column, notNull: false };
-    return [
-      `ALTER TABLE [${tabledef.name}] ADD ${getColumnDefinitionSql(tabledef, nullColumn)}`,
-      `ALTER TABLE [${tabledef.name}] ADD CONSTRAINT [DF_${tabledef.name}_${column.name}] DEFAULT` +
-        ` ${column.default} FOR [${column.name}]`,
-      `UPDATE [${tabledef.name}] SET [${column.name}]=${column.default}`,
-      `ALTER TABLE [${tabledef.name}] ALTER COLUMN ${getColumnDefinitionSql(tabledef, column)}`,
-    ];
-  }
-  return `ALTER TABLE [${tabledef.name}] ADD ${getColumnDefinitionSql(tabledef, column)}`;
-}
-
-function getCreateFkSql(tabledef, column, projectTables) {
-  const references = column.references;
-  const idcol = (projectTables[references] && projectTables[references].primaryKey[0]) || 'id';
-  return `ALTER TABLE [${tabledef.name}] ADD CONSTRAINT [FK_${tabledef.name}_${column.name}] FOREIGN KEY ([${column.name}]) REFERENCES [${references}]([${idcol}])`;
-}
-
-function getCreateIndexSql(prjIndex) {
-  return `CREATE ${prjIndex.isUnique ? 'UNIQUE' : ''} INDEX [${prjIndex.indexName}] ON [${
-    prjIndex.tableName
-  }] (${prjIndex.columns.map(x => `[${x.columnName}]`).join(',')}) ${
-    prjIndex.filterDefinition ? `WHERE ${prjIndex.filterDefinition}` : ''
-  }`;
-}
-
-function getProjectIndexesAsDatabase(projectTables) {
-  const projectIndexArray = _.flatten(
-    _.values(
-      _.mapValues(projectTables, table =>
-        (table.indexes || []).map(index => ({
-          indexName: index.name,
-          isUnique: index.unique || false,
-          filterDefinition: index.filter,
-          continueOnError: index.continueOnError,
-          tableName: table.name,
-          columns: index.columns.map(col => ({
-            columnName: col,
-            isIncludedColumn: false,
-          })),
-        }))
-      )
-    )
-  );
-  return projectIndexArray;
-}
-
-function sortViewsByDependency(viewNames, viewDict) {
-  const edges = [];
-  for (const viewName of viewNames) {
-    edges.push([viewName, null]);
-    const viewText = viewDict[viewName];
-    for (const otherView of viewNames) {
-      if (otherView === viewName) continue;
-      if ((' ' + viewText + ' ').match('[\\W]' + otherView + '[\\W]')) {
-        edges.push([otherView, viewName]);
-      }
-    }
-  }
-  return _.compact(toposort(edges));
-}
-
-function getSqlExpression(data) {
-  if (data == null) return 'NULL';
-  if (data === false) return '0';
-  if (data === true) return '1';
-  if (_.isNumber(data)) return data.toString();
-  return `'${data.replace(/'/g, "''")}'`;
-}
-
-function getFillTableSql(table) {
-  const keyCols = table.insertKey || table.primaryKey;
-  if (!keyCols) return null;
-  if (!table.data) return null;
-  const sql = table.data
-    .map(row => {
-      const keyCond = keyCols.map(col => `[${table.name}].[${col}]=${getSqlExpression(row[col])}`).join(' AND ');
-      const rowCols = Object.keys(row);
-      const notKeyCols = _.difference(rowCols, keyCols);
-      const updateCmd = notKeyCols.map(col => `[${col}]=${getSqlExpression(row[col])}`).join(',');
-      const rowColsCmd = rowCols.map(col => `[${col}]`).join(',');
-      const rowValuesCmd = rowCols.map(col => `${getSqlExpression(row[col])}`).join(',');
-      const cmd =
-        `IF (EXISTS(SELECT * FROM [${table.name}]` +
-        ` WHERE ${keyCond})) UPDATE [${table.name}]` +
-        ` SET ${updateCmd} WHERE ${keyCond}` +
-        ` ELSE INSERT INTO [${table.name}]` +
-        ` (${rowColsCmd}) VALUES (${rowValuesCmd});\n`;
-      return cmd;
-    })
-    .join('');
-  if (!sql) return null;
-
-  const identityColumn = table.columns.find(col => col.autoIncrement);
-  const sqlWithSetup =
-    identityColumn && keyCols.includes(identityColumn.name)
-      ? `SET IDENTITY_INSERT [${table.name}] ON;\n${sql}SET IDENTITY_INSERT [${table.name}] OFF;`
-      : sql;
-
-  return sqlWithSetup;
-}
-
-module.exports = {
-  getColumnDefinitionSql,
-  getCreateTableSql,
-  getCreateColumnSql,
-  getCreateFkSql,
-  getCreateIndexSql,
-  getProjectIndexesAsDatabase,
-  getFillTableSql,
-  sortViewsByDependency,
-};