dennii/dbgate
1
0
Fork 0
mirror of https://github.com/DeNNiiInc/dbgate.git synced 2026-04-18 02:06:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

filter parser connected

Browse Source
This commit is contained in:
Jan Prochazka
2020-03-12 17:52:19 +01:00
parent fc67ad0b0f
commit f86ad6ba1e
15 changed files with 356 additions and 1059 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
packages/engines/mssql/MsSqlAnalyser.js
View File

@@ -1,52 +1,176 @@
const fp = require("lodash/fp");
const _ = require("lodash");
const fp = require('lodash/fp');
const _ = require('lodash');
const DatabaseAnalayser = require("../default/DatabaseAnalyser");
const DatabaseAnalayser = require('../default/DatabaseAnalyser');
/** @returns {Promise<string>} */
async function loadQuery(pool, name) {
return await pool._nativeModules.fs.readFile(
pool._nativeModules.path.join(__dirname, name),
"utf-8"
);
return await pool._nativeModules.fs.readFile(pool._nativeModules.path.join(__dirname, name), 'utf-8');
}
const byTableFilter = table => x =>
x.pureName == table.pureName && x.schemaName == x.schemaName;
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"))
..._.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"
);
const grouped = _.groupBy(fkColumns.filter(byTableFilter(table)), 'constraintName');
return _.keys(grouped).map(constraintName => ({
constraintName,
constraintType: "foreignKey",
constraintType: 'foreignKey',
..._.pick(grouped[constraintName][0], [
"constraintName",
"schemaName",
"pureName",
"refSchemaName",
"refTableName",
"updateAction",
"deleteAction"
'constraintName',
'schemaName',
'pureName',
'refSchemaName',
'refTableName',
'updateAction',
'deleteAction',
]),
columns: grouped[constraintName].map(
fp.pick(["columnName", "refColumnName"])
)
columns: grouped[constraintName].map(fp.pick(['columnName', 'refColumnName'])),
}));
}
/** @returns {import('@dbgate/types').DbType} */
function detectType(col) {
switch (col.dataType) {
case 'binary':
return {
typeCode: 'string',
isBinary: true,
};
case 'image':
return {
typeCode: 'string',
isBinary: true,
isBlob: true,
};
case 'timestamp':
return {
typeCode: 'string',
};
case 'varbinary':
return {
typeCode: 'string',
length: col.maxLength,
isBinary: true,
isVarLength: true,
};
case 'bit':
return {
typeCode: 'logical',
};
case 'tinyint':
return {
typeCode: 'int',
bytes: 1,
};
case 'mediumint':
return {
typeCode: 'int',
bytes: 3,
};
case 'datetime':
return {
typeCode: 'datetime',
subType: 'datetime',
};
case 'time':
return {
typeCode: 'datetime',
subType: 'time',
};
case 'year':
return {
typeCode: 'datetime',
subType: 'year',
};
case 'date':
return {
typeCode: 'datetime',
subType: 'date',
};
case 'decimal':
case 'numeric':
return {
typeCode: 'numeric',
precision: col.precision,
scale: col.scale,
};
case 'float':
return { typeCode: 'float' };
case 'uniqueidentifier':
return { typeCode: 'string' };
case 'smallint':
return {
typeCode: 'int',
bytes: 2,
};
case 'int':
return {
typeCode: 'int',
bytes: 4,
};
case 'bigint':
return {
typeCode: 'int',
bytes: 8,
};
case 'real':
return { typeCode: 'float' };
case 'char':
return {
typeCode: 'string',
length: col.maxLength,
};
case 'nchar':
return { typeCode: 'string', length: col.maxLength, isUnicode: true };
case 'varchar':
return {
typeCode: 'string',
length: col.maxLength,
isVarLength: true,
};
case 'nvarchar':
return {
typeCode: 'string',
length: col.maxLength,
isVarLength: true,
isUnicode: true,
};
case 'text':
return {
typeCode: 'blob',
isText: true,
};
case 'ntext':
return {
typeCode: 'blob',
isText: true,
isUnicode: true,
};
case 'xml':
return {
typeCode: 'blob',
isXml: true,
};
}
return {
typeCode: 'generic',
sql: col.dataType,
};
}
class MsSqlAnalyser extends DatabaseAnalayser {
constructor(pool, driver) {
super(pool, driver);
@@ -61,26 +185,14 @@ class MsSqlAnalyser extends DatabaseAnalayser {
triggers = false
) {
let res = await loadQuery(this.pool, resFileName);
res = res.replace("=[OBJECT_ID_CONDITION]", " is not null");
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")
);
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,
@@ -89,10 +201,11 @@ class MsSqlAnalyser extends DatabaseAnalayser {
.map(({ isNullable, isIdentity, ...col }) => ({
...col,
notNull: !isNullable,
autoIncrement: !!isIdentity
autoIncrement: !!isIdentity,
commonType: detectType(col),
})),
primaryKey: extractPrimaryKeys(table, pkColumns.rows),
foreignKeys: extractForeignKeys(table, fkColumns.rows)
foreignKeys: extractForeignKeys(table, fkColumns.rows),
}));
}
}