dbgate-tools
Version:
Auxiliary tools for other DbGate packages.
249 lines (248 loc) • 8.88 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.driverBase = exports.runQueryFmt = exports.formatQueryWithoutParams = exports.runQueryOnDriver = exports.runCommandOnDriver = void 0;
const compact_1 = __importDefault(require("lodash/compact"));
const isString_1 = __importDefault(require("lodash/isString"));
const SqlDumper_1 = require("./SqlDumper");
const dbgate_query_splitter_1 = require("dbgate-query-splitter");
const dbgate_sqltree_1 = require("dbgate-sqltree");
const detectSqlFilterBehaviour_1 = require("./detectSqlFilterBehaviour");
const getLogger_1 = require("./getLogger");
const stringTools_1 = require("./stringTools");
const logger = (0, getLogger_1.getLogger)('driverBase');
const dialect = {
limitSelect: true,
rangeSelect: true,
topRecords: false,
offsetFetchRangeSyntax: true,
stringEscapeChar: "'",
fallbackDataType: 'nvarchar(max)',
quoteIdentifier(s) {
return s;
},
columnProperties: {
isSparse: false,
isPersisted: false,
},
defaultSchemaName: null,
};
async function runCommandOnDriver(pool, driver, cmd) {
const dmp = driver.createDumper();
if ((0, isString_1.default)(cmd)) {
dmp.put(cmd);
}
else {
cmd(dmp);
}
// console.log('CMD:', dmp.s);
await driver.query(pool, dmp.s, { discardResult: true });
}
exports.runCommandOnDriver = runCommandOnDriver;
async function runQueryOnDriver(pool, driver, cmd) {
const dmp = driver.createDumper();
if ((0, isString_1.default)(cmd)) {
dmp.put(cmd);
}
else {
cmd(dmp);
}
// console.log('QUERY:', dmp.s);
return await driver.query(pool, dmp.s);
}
exports.runQueryOnDriver = runQueryOnDriver;
function formatQueryWithoutParams(driver, sql) {
const dmp = driver.createDumper();
dmp.put(sql);
return dmp.s;
}
exports.formatQueryWithoutParams = formatQueryWithoutParams;
async function runQueryFmt(driver, conn, query, ...args) {
const dmp = driver.createDumper();
dmp.put(query, ...args);
await driver.query(conn, dmp.s);
}
exports.runQueryFmt = runQueryFmt;
exports.driverBase = {
analyserClass: null,
dumperClass: SqlDumper_1.SqlDumper,
dialect,
databaseEngineTypes: ['sql'],
supportedCreateDatabase: true,
async analyseFull(pool, version) {
const analyser = new this.analyserClass(pool, this, version);
return analyser.fullAnalysis();
},
async analyseSingleObject(pool, name, typeField = 'tables') {
const analyser = new this.analyserClass(pool, this);
return analyser.singleObjectAnalysis(name, typeField);
},
analyseSingleTable(pool, name) {
return this.analyseSingleObject(pool, name, 'tables');
},
async analyseIncremental(pool, structure, version) {
const analyser = new this.analyserClass(pool, this, version);
return analyser.incrementalAnalysis(structure);
},
createDumper(options = null) {
return new this.dumperClass(this, options);
},
async script(pool, sql, options) {
if ((options === null || options === void 0 ? void 0 : options.useTransaction) && this.supportsTransactions) {
runCommandOnDriver(pool, this, dmp => dmp.beginTransaction());
}
for (const sqlItem of (0, dbgate_query_splitter_1.splitQuery)(sql, this.getQuerySplitterOptions('script'))) {
try {
if (options === null || options === void 0 ? void 0 : options.logScriptItems) {
logger.info({ sql: (0, stringTools_1.getLimitedQuery)(sqlItem) }, 'DBGM-00131 Execute script item');
}
await this.query(pool, sqlItem, { discardResult: true, ...options === null || options === void 0 ? void 0 : options.queryOptions });
}
catch (err) {
if ((options === null || options === void 0 ? void 0 : options.useTransaction) && this.supportsTransactions) {
runCommandOnDriver(pool, this, dmp => dmp.rollbackTransaction());
}
throw err;
}
}
if ((options === null || options === void 0 ? void 0 : options.useTransaction) && this.supportsTransactions) {
runCommandOnDriver(pool, this, dmp => dmp.commitTransaction());
}
},
async operation(pool, operation, options) {
const { type } = operation;
switch (type) {
case 'createSchema':
await runCommandOnDriver(pool, this, dmp => dmp.createSchema(operation.schemaName));
break;
case 'dropSchema':
await runCommandOnDriver(pool, this, dmp => dmp.dropSchema(operation.schemaName));
break;
default:
throw new Error(`Operation type ${type} not supported`);
}
},
getNewObjectTemplates() {
if (this.databaseEngineTypes.includes('sql')) {
return [{ label: 'New view', sql: 'CREATE VIEW myview\nAS\nSELECT * FROM table1' }];
}
return [];
},
async loadFieldValues(pool, name, columnName, search, dataType) {
const dmp = this.createDumper();
let expr;
if (this.dialect.createColumnViewExpression) {
expr = this.dialect.createColumnViewExpression(columnName, dataType, { name }, 'value');
}
if (!expr) {
expr = {
exprType: 'column',
columnName,
alias: 'value',
};
}
const select = {
commandType: 'select',
distinct: true,
from: {
name,
},
columns: [expr],
orderBy: [
{
exprType: 'column',
columnName,
direction: 'ASC',
},
],
};
if (this.dialect.topRecords) {
select.topRecords = 100;
}
else {
select.range = { offset: 0, limit: 100 };
}
if (search) {
const tokens = (0, compact_1.default)(search.split(' ').map(x => x.trim()));
if (tokens.length > 0) {
// @ts-ignore
select.where = {
conditionType: 'and',
conditions: tokens.map(token => ({
conditionType: 'like',
left: {
exprType: 'column',
columnName,
},
right: {
exprType: 'value',
value: `%${token}%`,
},
})),
};
}
}
// @ts-ignore
(0, dbgate_sqltree_1.dumpSqlSelect)(dmp, select);
const resp = await this.query(pool, dmp.s);
return resp.rows;
},
readJsonQuery(pool, select, structure) {
const dmp = this.createDumper();
(0, dbgate_sqltree_1.dumpSqlSelect)(dmp, select);
return this.readQuery(pool, dmp.s, structure);
},
showConnectionField: (field, values) => false,
showConnectionTab: field => true,
getAccessTokenFromAuth: async (connection, req) => null,
getFilterBehaviour(dataType, standardFilterBehaviours) {
return (0, detectSqlFilterBehaviour_1.detectSqlFilterBehaviour)(dataType);
},
getCollectionExportQueryScript(collection, condition, sort) {
return null;
},
getCollectionExportQueryJson(collection, condition, sort) {
return null;
},
getScriptTemplates(objectTypeField) {
return [];
},
getScriptTemplateContent(scriptTemplate, props) {
return null;
},
dataEditorTypesBehaviour: {
parseSqlNull: true,
parseHexAsBuffer: true,
},
createSaveChangeSetScript(changeSet, dbinfo, defaultCreator) {
return defaultCreator(changeSet, dbinfo);
},
adaptDataType(dataType) {
return dataType;
},
adaptTableInfo(table) {
var _a;
return {
...table,
columns: (_a = table.columns) === null || _a === void 0 ? void 0 : _a.map(col => ({
...col,
dataType: this.adaptDataType(col.dataType),
})),
};
},
async listSchemas(pool) {
return null;
},
async writeQueryFromStream(dbhan, sql) {
return null;
},
getLogDbInfo(dbhan) {
return {
database: dbhan ? dbhan.database : undefined,
engine: this.engine,
conid: dbhan ? dbhan.conid : undefined,
};
},
};