@simplysm/sd-orm-common
Advanced tools
@simplysm/sd-orm-common - npm Package Compare versions
Comparing version 3.1.136 to 3.1.137
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var DbDefinitionUtil_1 = require("./util/DbDefinitionUtil"); | ||
| const DbDefinitionUtil_1 = require("./util/DbDefinitionUtil"); | ||
| function Table(def) { | ||
| return function (classType) { | ||
| DbDefinitionUtil_1.DbDefinitionUtil.mergeTableDef(classType, tslib_1.__assign({ name: classType.name }, def)); | ||
| return (classType) => { | ||
| DbDefinitionUtil_1.DbDefinitionUtil.mergeTableDef(classType, { | ||
| name: classType.name, | ||
| ...def | ||
| }); | ||
| }; | ||
@@ -12,7 +14,7 @@ } | ||
| function Column(columnDef) { | ||
| return function (object, propertyKey) { | ||
| return (object, propertyKey) => { | ||
| var _a; | ||
| var classType = object.constructor; | ||
| const classType = object.constructor; | ||
| DbDefinitionUtil_1.DbDefinitionUtil.addColumnDef(classType, { | ||
| propertyKey: propertyKey, | ||
| propertyKey, | ||
| name: (_a = columnDef.name, (_a !== null && _a !== void 0 ? _a : propertyKey)), | ||
@@ -24,3 +26,3 @@ dataType: columnDef.dataType, | ||
| description: columnDef.description, | ||
| typeFwd: function () { return Reflect.getMetadata("design:type", object, propertyKey); } | ||
| typeFwd: () => Reflect.getMetadata("design:type", object, propertyKey) | ||
| }); | ||
@@ -31,10 +33,10 @@ }; | ||
| function ForeignKey(columnNames, targetTypeFwd, description) { | ||
| return function (object, propertyKey) { | ||
| var classType = object.constructor; | ||
| return (object, propertyKey) => { | ||
| const classType = object.constructor; | ||
| DbDefinitionUtil_1.DbDefinitionUtil.addForeignKeyDef(classType, { | ||
| propertyKey: propertyKey, | ||
| propertyKey, | ||
| name: propertyKey, | ||
| columnPropertyKeys: columnNames, | ||
| description: description, | ||
| targetTypeFwd: targetTypeFwd | ||
| description, | ||
| targetTypeFwd | ||
| }); | ||
@@ -45,9 +47,9 @@ }; | ||
| function ForeignKeyTarget(sourceTypeFwd, foreignKeyPropertyKey, description) { | ||
| return function (object, propertyKey) { | ||
| var classType = object.constructor; | ||
| return (object, propertyKey) => { | ||
| const classType = object.constructor; | ||
| DbDefinitionUtil_1.DbDefinitionUtil.addForeignKeyTargetDef(classType, { | ||
| propertyKey: propertyKey, | ||
| propertyKey, | ||
| name: propertyKey, | ||
| sourceTypeFwd: sourceTypeFwd, | ||
| description: description, | ||
| sourceTypeFwd, | ||
| description, | ||
| foreignKeyPropertyKey: foreignKeyPropertyKey | ||
@@ -59,5 +61,5 @@ }); | ||
| function Index(def) { | ||
| return function (object, propertyKey) { | ||
| return (object, propertyKey) => { | ||
| var _a, _b, _c; | ||
| var classType = object.constructor; | ||
| const classType = object.constructor; | ||
| DbDefinitionUtil_1.DbDefinitionUtil.addIndexDef(classType, { | ||
@@ -64,0 +66,0 @@ name: (_a = def.name, (_a !== null && _a !== void 0 ? _a : propertyKey)), |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var decorator_1 = require("./decorator"); | ||
| var DbMigrationModel = (function () { | ||
| function DbMigrationModel() { | ||
| } | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ primaryKey: 1, description: "코드" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbMigrationModel.prototype, "code", void 0); | ||
| DbMigrationModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ name: "_migration", description: "마이그레이션" }) | ||
| ], DbMigrationModel); | ||
| return DbMigrationModel; | ||
| }()); | ||
| const tslib_1 = require("tslib"); | ||
| const decorator_1 = require("./decorator"); | ||
| let DbMigrationModel = class DbMigrationModel { | ||
| }; | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ primaryKey: 1, description: "코드" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbMigrationModel.prototype, "code", void 0); | ||
| DbMigrationModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ name: "_migration", description: "마이그레이션" }) | ||
| ], DbMigrationModel); | ||
| exports.DbMigrationModel = DbMigrationModel; | ||
| var DbDatabaseInfoModel = (function () { | ||
| function DbDatabaseInfoModel() { | ||
| } | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ description: "DB명" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbDatabaseInfoModel.prototype, "name", void 0); | ||
| DbDatabaseInfoModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ | ||
| database: "master", | ||
| schema: "dbo", | ||
| name: "sysdatabases", | ||
| description: "데이터베이스 정보" | ||
| }) | ||
| ], DbDatabaseInfoModel); | ||
| return DbDatabaseInfoModel; | ||
| }()); | ||
| let DbDatabaseInfoModel = class DbDatabaseInfoModel { | ||
| }; | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ description: "DB명" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbDatabaseInfoModel.prototype, "name", void 0); | ||
| DbDatabaseInfoModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ | ||
| database: "master", | ||
| schema: "dbo", | ||
| name: "sysdatabases", | ||
| description: "데이터베이스 정보" | ||
| }) | ||
| ], DbDatabaseInfoModel); | ||
| exports.DbDatabaseInfoModel = DbDatabaseInfoModel; | ||
| var DbTableInfoModel = (function () { | ||
| function DbTableInfoModel() { | ||
| } | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ name: "TABLE_NAME", description: "테이블명" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbTableInfoModel.prototype, "name", void 0); | ||
| DbTableInfoModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ | ||
| schema: "INFORMATION_SCHEMA", | ||
| name: "TABLES", | ||
| description: "테이블" | ||
| }) | ||
| ], DbTableInfoModel); | ||
| return DbTableInfoModel; | ||
| }()); | ||
| let DbTableInfoModel = class DbTableInfoModel { | ||
| }; | ||
| tslib_1.__decorate([ | ||
| decorator_1.Column({ name: "TABLE_NAME", description: "테이블명" }), | ||
| tslib_1.__metadata("design:type", String) | ||
| ], DbTableInfoModel.prototype, "name", void 0); | ||
| DbTableInfoModel = tslib_1.__decorate([ | ||
| decorator_1.Table({ | ||
| schema: "INFORMATION_SCHEMA", | ||
| name: "TABLES", | ||
| description: "테이블" | ||
| }) | ||
| ], DbTableInfoModel); | ||
| exports.DbTableInfoModel = DbTableInfoModel; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var Queryable_1 = require("./Queryable"); | ||
| var model_1 = require("../model"); | ||
| var sorm_1 = require("./sorm"); | ||
| var DbDefinitionUtil_1 = require("../util/DbDefinitionUtil"); | ||
| var QueryUtil_1 = require("../util/QueryUtil"); | ||
| var DbContext = (function () { | ||
| function DbContext(_executor) { | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| const Queryable_1 = require("./Queryable"); | ||
| const model_1 = require("../model"); | ||
| const sorm_1 = require("./sorm"); | ||
| const DbDefinitionUtil_1 = require("../util/DbDefinitionUtil"); | ||
| const QueryUtil_1 = require("../util/QueryUtil"); | ||
| class DbContext { | ||
| constructor(_executor) { | ||
| this._executor = _executor; | ||
@@ -19,445 +18,295 @@ this.status = "ready"; | ||
| } | ||
| DbContext.prototype.connectWithoutTransactionAsync = function (callback) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var result, err_1; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: return [4, this._executor.connectAsync()]; | ||
| case 1: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| _a.label = 2; | ||
| case 2: | ||
| _a.trys.push([2, 4, , 6]); | ||
| return [4, callback()]; | ||
| case 3: | ||
| result = _a.sent(); | ||
| return [3, 6]; | ||
| case 4: | ||
| err_1 = _a.sent(); | ||
| return [4, this._executor.closeAsync()]; | ||
| case 5: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| throw err_1; | ||
| case 6: return [4, this._executor.closeAsync()]; | ||
| case 7: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| return [2, result]; | ||
| async connectWithoutTransactionAsync(callback) { | ||
| await this._executor.connectAsync(); | ||
| this.status = "connect"; | ||
| let result; | ||
| try { | ||
| result = await callback(); | ||
| } | ||
| catch (err) { | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| throw err; | ||
| } | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| return result; | ||
| } | ||
| async connectAsync(fn) { | ||
| await this._executor.connectAsync(); | ||
| this.status = "connect"; | ||
| await this._executor.beginTransactionAsync(); | ||
| this.status = "transact"; | ||
| let result; | ||
| try { | ||
| result = await fn(); | ||
| await this._executor.commitTransactionAsync(); | ||
| this.status = "connect"; | ||
| } | ||
| catch (err) { | ||
| try { | ||
| await this._executor.rollbackTransactionAsync(); | ||
| this.status = "connect"; | ||
| } | ||
| catch (err1) { | ||
| if (!err1.message.includes("ROLLBACK") || !err1.message.includes("BEGIN")) { | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| throw err1; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.prototype.connectAsync = function (fn) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var result, err_2, err1_1; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: return [4, this._executor.connectAsync()]; | ||
| case 1: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| return [4, this._executor.beginTransactionAsync()]; | ||
| case 2: | ||
| _a.sent(); | ||
| this.status = "transact"; | ||
| _a.label = 3; | ||
| case 3: | ||
| _a.trys.push([3, 6, , 14]); | ||
| return [4, fn()]; | ||
| case 4: | ||
| result = _a.sent(); | ||
| return [4, this._executor.commitTransactionAsync()]; | ||
| case 5: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| return [3, 14]; | ||
| case 6: | ||
| err_2 = _a.sent(); | ||
| _a.label = 7; | ||
| case 7: | ||
| _a.trys.push([7, 9, , 12]); | ||
| return [4, this._executor.rollbackTransactionAsync()]; | ||
| case 8: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| return [3, 12]; | ||
| case 9: | ||
| err1_1 = _a.sent(); | ||
| if (!(!err1_1.message.includes("ROLLBACK") || !err1_1.message.includes("BEGIN"))) return [3, 11]; | ||
| return [4, this._executor.closeAsync()]; | ||
| case 10: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| throw err1_1; | ||
| case 11: return [3, 12]; | ||
| case 12: return [4, this._executor.closeAsync()]; | ||
| case 13: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| throw err_2; | ||
| case 14: return [4, this._executor.closeAsync()]; | ||
| case 15: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| return [2, result]; | ||
| } | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| throw err; | ||
| } | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| return result; | ||
| } | ||
| async transAsync(fn) { | ||
| if (this.status === "transact") { | ||
| throw new Error("이미 TRANSACTION 상태 입니다."); | ||
| } | ||
| await this._executor.beginTransactionAsync(); | ||
| this.status = "transact"; | ||
| let result; | ||
| try { | ||
| result = await fn(); | ||
| await this._executor.commitTransactionAsync(); | ||
| this.status = "connect"; | ||
| } | ||
| catch (err) { | ||
| try { | ||
| await this._executor.rollbackTransactionAsync(); | ||
| this.status = "connect"; | ||
| } | ||
| catch (err1) { | ||
| if (!err1.message.includes("ROLLBACK") || !err1.message.includes("BEGIN")) { | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| throw err1; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.prototype.transAsync = function (fn) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var result, err_3, err1_2; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| if (this.status === "transact") { | ||
| throw new Error("이미 TRANSACTION 상태 입니다."); | ||
| } | ||
| return [4, this._executor.beginTransactionAsync()]; | ||
| case 1: | ||
| _a.sent(); | ||
| this.status = "transact"; | ||
| _a.label = 2; | ||
| case 2: | ||
| _a.trys.push([2, 5, , 13]); | ||
| return [4, fn()]; | ||
| case 3: | ||
| result = _a.sent(); | ||
| return [4, this._executor.commitTransactionAsync()]; | ||
| case 4: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| return [3, 13]; | ||
| case 5: | ||
| err_3 = _a.sent(); | ||
| _a.label = 6; | ||
| case 6: | ||
| _a.trys.push([6, 8, , 11]); | ||
| return [4, this._executor.rollbackTransactionAsync()]; | ||
| case 7: | ||
| _a.sent(); | ||
| this.status = "connect"; | ||
| return [3, 11]; | ||
| case 8: | ||
| err1_2 = _a.sent(); | ||
| if (!(!err1_2.message.includes("ROLLBACK") || !err1_2.message.includes("BEGIN"))) return [3, 10]; | ||
| return [4, this._executor.closeAsync()]; | ||
| case 9: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| throw err1_2; | ||
| case 10: return [3, 11]; | ||
| case 11: return [4, this._executor.closeAsync()]; | ||
| case 12: | ||
| _a.sent(); | ||
| this.status = "ready"; | ||
| throw err_3; | ||
| case 13: return [2, result]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.prototype.executeDefsAsync = function (defs, options) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: return [4, this._executor.executeDefsAsync(defs, options)]; | ||
| case 1: return [2, _a.sent()]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.prototype.executePreparedAsync = function () { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var result, resultTmp, i; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| if (this.prepareDefs.length < 1) { | ||
| return [2, []]; | ||
| } | ||
| result = []; | ||
| return [4, this.executeDefsAsync(this.prepareDefs.map(function (item) { return item.def; }), this.prepareDefs.map(function (item) { return item.option; }))]; | ||
| case 1: | ||
| resultTmp = _a.sent(); | ||
| for (i = 0; i < resultTmp.length; i++) { | ||
| if (this.prepareDefs[i].isRealResult) { | ||
| result.push(resultTmp[i]); | ||
| } | ||
| } | ||
| this.prepareDefs = []; | ||
| DbContext.selectCache.clear(); | ||
| return [2, result]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.prototype.initializeAsync = function (dbs, force) { | ||
| } | ||
| await this._executor.closeAsync(); | ||
| this.status = "ready"; | ||
| throw err; | ||
| } | ||
| return result; | ||
| } | ||
| async executeDefsAsync(defs, options) { | ||
| return await this._executor.executeDefsAsync(defs, options); | ||
| } | ||
| async executePreparedAsync() { | ||
| if (this.prepareDefs.length < 1) { | ||
| return []; | ||
| } | ||
| const result = []; | ||
| const resultTmp = await this.executeDefsAsync(this.prepareDefs.map((item) => item.def), this.prepareDefs.map((item) => item.option)); | ||
| for (let i = 0; i < resultTmp.length; i++) { | ||
| if (this.prepareDefs[i].isRealResult) { | ||
| result.push(resultTmp[i]); | ||
| } | ||
| } | ||
| this.prepareDefs = []; | ||
| DbContext.selectCache.clear(); | ||
| return result; | ||
| } | ||
| async initializeAsync(dbs, force) { | ||
| var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k; | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var isDbExists, hasMigrationTable, dbMigrationCodes_1, migrations_2, _i, migrations_1, migration, dbNames, queryDefsList, _l, dbNames_1, dbName, tableDefs, createTableQueryDefs, _m, tableDefs_1, tableDef, addPKQueryDefs, _o, tableDefs_2, tableDef, addFkQueryDefs, _loop_1, this_1, _p, tableDefs_3, tableDef, createIndexQueryDefs, _loop_2, this_2, _q, tableDefs_4, tableDef, migrationInsertQueryDefs, _r, _s, migration, _t, queryDefsList_1, queryDefs; | ||
| var _this = this; | ||
| return tslib_1.__generator(this, function (_u) { | ||
| switch (_u.label) { | ||
| case 0: | ||
| if (force && this.status === "transact") { | ||
| throw new Error("DB 강제 초기화는 트랜젝션 상에서는 동작하지 못합니다.\nconnect 대신에 connectWithoutTransaction 로 연결하여 시도하세요."); | ||
| } | ||
| if (!!force) return [3, 11]; | ||
| return [4, this._databaseInfo | ||
| .where(function (item) { return [ | ||
| sorm_1.sorm.equal(item.name, _this.schema.database) | ||
| ]; }) | ||
| .countAsync()]; | ||
| case 1: | ||
| isDbExists = (_u.sent()) > 0; | ||
| if (!isDbExists) return [3, 11]; | ||
| return [4, this._tableInfo | ||
| .where(function (item) { return [ | ||
| sorm_1.sorm.equal(item.name, "_migration") | ||
| ]; }) | ||
| .countAsync()]; | ||
| case 2: | ||
| hasMigrationTable = (_u.sent()) > 0; | ||
| if (!hasMigrationTable) return [3, 10]; | ||
| return [4, this.migration | ||
| .select(function (item) { return ({ | ||
| code: item.code | ||
| }); }) | ||
| .resultAsync()]; | ||
| case 3: | ||
| dbMigrationCodes_1 = (_u.sent()).map(function (item) { return item.code; }); | ||
| migrations_2 = this.migrations | ||
| .filter(function (item) { return !dbMigrationCodes_1.includes(item.name); }) | ||
| .orderBy(function (item) { return item.name; }); | ||
| if (!(migrations_2.length > 0)) return [3, 10]; | ||
| if (!(this.status !== "transact")) return [3, 5]; | ||
| return [4, this.transAsync(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { | ||
| var _i, migrations_3, migration; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| _i = 0, migrations_3 = migrations_2; | ||
| _a.label = 1; | ||
| case 1: | ||
| if (!(_i < migrations_3.length)) return [3, 5]; | ||
| migration = migrations_3[_i]; | ||
| return [4, new migration().up(this)]; | ||
| case 2: | ||
| _a.sent(); | ||
| return [4, this.migration.insertAsync({ | ||
| code: migration.name | ||
| })]; | ||
| case 3: | ||
| _a.sent(); | ||
| _a.label = 4; | ||
| case 4: | ||
| _i++; | ||
| return [3, 1]; | ||
| case 5: return [2]; | ||
| } | ||
| }); | ||
| }); })]; | ||
| case 4: | ||
| _u.sent(); | ||
| return [3, 10]; | ||
| case 5: | ||
| _i = 0, migrations_1 = migrations_2; | ||
| _u.label = 6; | ||
| case 6: | ||
| if (!(_i < migrations_1.length)) return [3, 10]; | ||
| migration = migrations_1[_i]; | ||
| return [4, new migration().up(this)]; | ||
| case 7: | ||
| _u.sent(); | ||
| return [4, this.migration.insertAsync({ | ||
| code: migration.name | ||
| })]; | ||
| case 8: | ||
| _u.sent(); | ||
| _u.label = 9; | ||
| case 9: | ||
| _i++; | ||
| return [3, 6]; | ||
| case 10: return [2, false]; | ||
| case 11: | ||
| dbNames = (dbs !== null && dbs !== void 0 ? dbs : [this.schema.database]); | ||
| if (dbNames.length < 1) { | ||
| throw new Error("생성할 데이터베이스가 없습니다."); | ||
| } | ||
| queryDefsList = []; | ||
| for (_l = 0, dbNames_1 = dbNames; _l < dbNames_1.length; _l++) { | ||
| dbName = dbNames_1[_l]; | ||
| queryDefsList.push([ | ||
| { | ||
| type: "clearDatabaseIfExists", | ||
| database: dbName | ||
| }, | ||
| { | ||
| type: "createDatabaseIfNotExists", | ||
| database: dbName | ||
| if (force && this.status === "transact") { | ||
| throw new Error("DB 강제 초기화는 트랜젝션 상에서는 동작하지 못합니다.\nconnect 대신에 connectWithoutTransaction 로 연결하여 시도하세요."); | ||
| } | ||
| if (!force) { | ||
| const isDbExists = (await this._databaseInfo | ||
| .where((item) => [ | ||
| sorm_1.sorm.equal(item.name, this.schema.database) | ||
| ]) | ||
| .countAsync()) > 0; | ||
| if (isDbExists) { | ||
| const hasMigrationTable = (await this._tableInfo | ||
| .where((item) => [ | ||
| sorm_1.sorm.equal(item.name, "_migration") | ||
| ]) | ||
| .countAsync()) > 0; | ||
| if (hasMigrationTable) { | ||
| const dbMigrationCodes = (await this.migration | ||
| .select((item) => ({ | ||
| code: item.code | ||
| })) | ||
| .resultAsync()).map((item) => item.code); | ||
| const migrations = this.migrations | ||
| .filter((item) => !dbMigrationCodes.includes(item.name)) | ||
| .orderBy((item) => item.name); | ||
| if (migrations.length > 0) { | ||
| if (this.status !== "transact") { | ||
| await this.transAsync(async () => { | ||
| for (const migration of migrations) { | ||
| await new migration().up(this); | ||
| await this.migration.insertAsync({ | ||
| code: migration.name | ||
| }); | ||
| } | ||
| ]); | ||
| } | ||
| tableDefs = Object.keys(this) | ||
| .filter(function (key) { return !key.startsWith("_"); }) | ||
| .map(function (key) { return _this[key]; }) | ||
| .ofType(Queryable_1.Queryable) | ||
| .map(function (qr) { return DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(qr.tableType); }) | ||
| .filter(function (item) { return !item.database || dbNames.includes(item.database); }) | ||
| .filterExists(); | ||
| createTableQueryDefs = []; | ||
| for (_m = 0, tableDefs_1 = tableDefs; _m < tableDefs_1.length; _m++) { | ||
| tableDef = tableDefs_1[_m]; | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error("'" + tableDef.name + "'\uC758 \uCEEC\uB7FC \uC124\uC815\uC774 \uC798\uBABB\uB418\uC5C8\uC2B5\uB2C8\uB2E4."); | ||
| } | ||
| createTableQueryDefs.push({ | ||
| type: "createTable", | ||
| table: { | ||
| database: (_a = tableDef.database, (_a !== null && _a !== void 0 ? _a : this.schema.database)), | ||
| schema: (_b = tableDef.schema, (_b !== null && _b !== void 0 ? _b : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| columns: tableDef.columns.map(function (col) { | ||
| var _a; | ||
| return sd_core_common_1.ObjectUtil.clearUndefined({ | ||
| name: col.name, | ||
| dataType: (_a = col.dataType, (_a !== null && _a !== void 0 ? _a : QueryUtil_1.QueryUtil.getDataType(col.typeFwd()))), | ||
| autoIncrement: col.autoIncrement, | ||
| nullable: col.nullable | ||
| }); | ||
| }) | ||
| }); | ||
| } | ||
| queryDefsList.push(createTableQueryDefs); | ||
| addPKQueryDefs = []; | ||
| for (_o = 0, tableDefs_2 = tableDefs; _o < tableDefs_2.length; _o++) { | ||
| tableDef = tableDefs_2[_o]; | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error("'" + tableDef.name + "'\uC758 \uCEEC\uB7FC \uC124\uC815\uC774 \uC798\uBABB\uB418\uC5C8\uC2B5\uB2C8\uB2E4."); | ||
| } | ||
| addPKQueryDefs.push({ | ||
| type: "addPrimaryKey", | ||
| table: { | ||
| database: (_c = tableDef.database, (_c !== null && _c !== void 0 ? _c : this.schema.database)), | ||
| schema: (_d = tableDef.schema, (_d !== null && _d !== void 0 ? _d : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| primaryKeys: tableDef.columns | ||
| .filter(function (item) { return item.primaryKey !== undefined; }) | ||
| .orderBy(function (item) { return item.primaryKey; }) | ||
| .map(function (item) { return ({ | ||
| column: item.name, | ||
| orderBy: "ASC" | ||
| }); }) | ||
| }); | ||
| } | ||
| queryDefsList.push(addPKQueryDefs); | ||
| addFkQueryDefs = []; | ||
| _loop_1 = function (tableDef) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error("'" + tableDef.name + "'\uC758 \uCEEC\uB7FC \uC124\uC815\uC774 \uC798\uBABB\uB418\uC5C8\uC2B5\uB2C8\uB2E4."); | ||
| } | ||
| for (var _i = 0, _a = tableDef.foreignKeys; _i < _a.length; _i++) { | ||
| var fkDef = _a[_i]; | ||
| var targetTableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fkDef.targetTypeFwd()); | ||
| if (targetTableDef.columns.length < 1) { | ||
| throw new Error(targetTableDef.name + "\uC758 \uCEEC\uB7FC \uC124\uC815\uC774 \uC798\uBABB\uB418\uC5C8\uC2B5\uB2C8\uB2E4."); | ||
| } | ||
| var targetPkNames = targetTableDef.columns | ||
| .filter(function (item) { return item.primaryKey !== undefined; }) | ||
| .orderBy(function (item) { return item.primaryKey; }) | ||
| .map(function (item) { return item.name; }); | ||
| addFkQueryDefs.push({ | ||
| type: "addForeignKey", | ||
| table: { | ||
| database: (_e = tableDef.database, (_e !== null && _e !== void 0 ? _e : this_1.schema.database)), | ||
| schema: (_f = tableDef.schema, (_f !== null && _f !== void 0 ? _f : this_1.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| foreignKey: { | ||
| name: fkDef.name, | ||
| fkColumns: fkDef.columnPropertyKeys.map(function (propKey) { return tableDef.columns.single(function (col) { return col.propertyKey === propKey; }).name; }), | ||
| targetTable: { | ||
| database: (_g = targetTableDef.database, (_g !== null && _g !== void 0 ? _g : this_1.schema.database)), | ||
| schema: (_h = targetTableDef.schema, (_h !== null && _h !== void 0 ? _h : this_1.schema.schema)), | ||
| name: targetTableDef.name | ||
| }, | ||
| targetPkColumns: targetPkNames | ||
| } | ||
| else { | ||
| for (const migration of migrations) { | ||
| await new migration().up(this); | ||
| await this.migration.insertAsync({ | ||
| code: migration.name | ||
| }); | ||
| } | ||
| }; | ||
| this_1 = this; | ||
| for (_p = 0, tableDefs_3 = tableDefs; _p < tableDefs_3.length; _p++) { | ||
| tableDef = tableDefs_3[_p]; | ||
| _loop_1(tableDef); | ||
| } | ||
| queryDefsList.push(addFkQueryDefs); | ||
| createIndexQueryDefs = []; | ||
| _loop_2 = function (tableDef) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error("'" + tableDef.name + "'\uC758 \uCEEC\uB7FC \uC124\uC815\uC774 \uC798\uBABB\uB418\uC5C8\uC2B5\uB2C8\uB2E4."); | ||
| } | ||
| for (var _i = 0, _a = tableDef.indexes; _i < _a.length; _i++) { | ||
| var indexDef = _a[_i]; | ||
| createIndexQueryDefs.push({ | ||
| type: "createIndex", | ||
| table: { | ||
| database: (_j = tableDef.database, (_j !== null && _j !== void 0 ? _j : this_2.schema.database)), | ||
| schema: (_k = tableDef.schema, (_k !== null && _k !== void 0 ? _k : this_2.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| index: { | ||
| name: indexDef.name, | ||
| columns: indexDef.columns.orderBy(function (item) { return item.order; }).map(function (item) { return ({ | ||
| name: tableDef.columns.single(function (col) { return col.propertyKey === item.columnPropertyKey; }).name, | ||
| orderBy: item.orderBy | ||
| }); }) | ||
| } | ||
| }); | ||
| } | ||
| }; | ||
| this_2 = this; | ||
| for (_q = 0, tableDefs_4 = tableDefs; _q < tableDefs_4.length; _q++) { | ||
| tableDef = tableDefs_4[_q]; | ||
| _loop_2(tableDef); | ||
| } | ||
| queryDefsList.push(createIndexQueryDefs); | ||
| migrationInsertQueryDefs = []; | ||
| for (_r = 0, _s = this.migrations.orderBy(function (item) { return item.name; }); _r < _s.length; _r++) { | ||
| migration = _s[_r]; | ||
| migrationInsertQueryDefs.push({ | ||
| type: "insert", | ||
| from: "[" + this.schema.database + "].[" + this.schema.schema + "].[_migration]", | ||
| record: { | ||
| "[code]": "N'" + migration.name + "'" | ||
| } | ||
| }); | ||
| } | ||
| queryDefsList.push(migrationInsertQueryDefs); | ||
| _t = 0, queryDefsList_1 = queryDefsList; | ||
| _u.label = 12; | ||
| case 12: | ||
| if (!(_t < queryDefsList_1.length)) return [3, 15]; | ||
| queryDefs = queryDefsList_1[_t]; | ||
| return [4, this.executeDefsAsync(queryDefs)]; | ||
| case 13: | ||
| _u.sent(); | ||
| _u.label = 14; | ||
| case 14: | ||
| _t++; | ||
| return [3, 12]; | ||
| case 15: return [2, true]; | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| const dbNames = (dbs !== null && dbs !== void 0 ? dbs : [this.schema.database]); | ||
| if (dbNames.length < 1) { | ||
| throw new Error("생성할 데이터베이스가 없습니다."); | ||
| } | ||
| const queryDefsList = []; | ||
| for (const dbName of dbNames) { | ||
| queryDefsList.push([ | ||
| { | ||
| type: "clearDatabaseIfExists", | ||
| database: dbName | ||
| }, | ||
| { | ||
| type: "createDatabaseIfNotExists", | ||
| database: dbName | ||
| } | ||
| ]); | ||
| } | ||
| const tableDefs = Object.keys(this) | ||
| .filter((key) => !key.startsWith("_")) | ||
| .map((key) => this[key]) | ||
| .ofType(Queryable_1.Queryable) | ||
| .map((qr) => DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(qr.tableType)) | ||
| .filter((item) => !item.database || dbNames.includes(item.database)) | ||
| .filterExists(); | ||
| const createTableQueryDefs = []; | ||
| for (const tableDef of tableDefs) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`); | ||
| } | ||
| createTableQueryDefs.push({ | ||
| type: "createTable", | ||
| table: { | ||
| database: (_a = tableDef.database, (_a !== null && _a !== void 0 ? _a : this.schema.database)), | ||
| schema: (_b = tableDef.schema, (_b !== null && _b !== void 0 ? _b : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| columns: tableDef.columns.map((col) => { | ||
| var _a; | ||
| return sd_core_common_1.ObjectUtil.clearUndefined({ | ||
| name: col.name, | ||
| dataType: (_a = col.dataType, (_a !== null && _a !== void 0 ? _a : QueryUtil_1.QueryUtil.getDataType(col.typeFwd()))), | ||
| autoIncrement: col.autoIncrement, | ||
| nullable: col.nullable | ||
| }); | ||
| }) | ||
| }); | ||
| }); | ||
| }; | ||
| DbContext.selectCache = new Map(); | ||
| return DbContext; | ||
| }()); | ||
| } | ||
| queryDefsList.push(createTableQueryDefs); | ||
| const addPKQueryDefs = []; | ||
| for (const tableDef of tableDefs) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`); | ||
| } | ||
| addPKQueryDefs.push({ | ||
| type: "addPrimaryKey", | ||
| table: { | ||
| database: (_c = tableDef.database, (_c !== null && _c !== void 0 ? _c : this.schema.database)), | ||
| schema: (_d = tableDef.schema, (_d !== null && _d !== void 0 ? _d : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| primaryKeys: tableDef.columns | ||
| .filter((item) => item.primaryKey !== undefined) | ||
| .orderBy((item) => item.primaryKey) | ||
| .map((item) => ({ | ||
| column: item.name, | ||
| orderBy: "ASC" | ||
| })) | ||
| }); | ||
| } | ||
| queryDefsList.push(addPKQueryDefs); | ||
| const addFkQueryDefs = []; | ||
| for (const tableDef of tableDefs) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`); | ||
| } | ||
| for (const fkDef of tableDef.foreignKeys) { | ||
| const targetTableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fkDef.targetTypeFwd()); | ||
| if (targetTableDef.columns.length < 1) { | ||
| throw new Error(`${targetTableDef.name}의 컬럼 설정이 잘못되었습니다.`); | ||
| } | ||
| const targetPkNames = targetTableDef.columns | ||
| .filter((item) => item.primaryKey !== undefined) | ||
| .orderBy((item) => item.primaryKey) | ||
| .map((item) => item.name); | ||
| addFkQueryDefs.push({ | ||
| type: "addForeignKey", | ||
| table: { | ||
| database: (_e = tableDef.database, (_e !== null && _e !== void 0 ? _e : this.schema.database)), | ||
| schema: (_f = tableDef.schema, (_f !== null && _f !== void 0 ? _f : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| foreignKey: { | ||
| name: fkDef.name, | ||
| fkColumns: fkDef.columnPropertyKeys.map((propKey) => tableDef.columns.single((col) => col.propertyKey === propKey).name), | ||
| targetTable: { | ||
| database: (_g = targetTableDef.database, (_g !== null && _g !== void 0 ? _g : this.schema.database)), | ||
| schema: (_h = targetTableDef.schema, (_h !== null && _h !== void 0 ? _h : this.schema.schema)), | ||
| name: targetTableDef.name | ||
| }, | ||
| targetPkColumns: targetPkNames | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| queryDefsList.push(addFkQueryDefs); | ||
| const createIndexQueryDefs = []; | ||
| for (const tableDef of tableDefs) { | ||
| if (tableDef.columns.length < 1) { | ||
| throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`); | ||
| } | ||
| for (const indexDef of tableDef.indexes) { | ||
| createIndexQueryDefs.push({ | ||
| type: "createIndex", | ||
| table: { | ||
| database: (_j = tableDef.database, (_j !== null && _j !== void 0 ? _j : this.schema.database)), | ||
| schema: (_k = tableDef.schema, (_k !== null && _k !== void 0 ? _k : this.schema.schema)), | ||
| name: tableDef.name | ||
| }, | ||
| index: { | ||
| name: indexDef.name, | ||
| columns: indexDef.columns.orderBy((item) => item.order).map((item) => ({ | ||
| name: tableDef.columns.single((col) => col.propertyKey === item.columnPropertyKey).name, | ||
| orderBy: item.orderBy | ||
| })) | ||
| } | ||
| }); | ||
| } | ||
| } | ||
| queryDefsList.push(createIndexQueryDefs); | ||
| const migrationInsertQueryDefs = []; | ||
| for (const migration of this.migrations.orderBy((item) => item.name)) { | ||
| migrationInsertQueryDefs.push({ | ||
| type: "insert", | ||
| from: `[${this.schema.database}].[${this.schema.schema}].[_migration]`, | ||
| record: { | ||
| "[code]": `N'${migration.name}'` | ||
| } | ||
| }); | ||
| } | ||
| queryDefsList.push(migrationInsertQueryDefs); | ||
| for (const queryDefs of queryDefsList) { | ||
| await this.executeDefsAsync(queryDefs); | ||
| } | ||
| return true; | ||
| } | ||
| } | ||
| exports.DbContext = DbContext; | ||
| DbContext.selectCache = new Map(); | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var QueryUtil_1 = require("../util/QueryUtil"); | ||
| var DbContext_1 = require("./DbContext"); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var DbDefinitionUtil_1 = require("../util/DbDefinitionUtil"); | ||
| var QueryUnit_1 = require("./QueryUnit"); | ||
| var sorm_1 = require("./sorm"); | ||
| var Queryable = (function () { | ||
| function Queryable(_db, arg1, arg2, arg3, arg4) { | ||
| const QueryUtil_1 = require("../util/QueryUtil"); | ||
| const DbContext_1 = require("./DbContext"); | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| const DbDefinitionUtil_1 = require("../util/DbDefinitionUtil"); | ||
| const QueryUnit_1 = require("./QueryUnit"); | ||
| const sorm_1 = require("./sorm"); | ||
| class Queryable { | ||
| constructor(_db, arg1, arg2, arg3, arg4) { | ||
| var _a, _b; | ||
@@ -31,11 +30,10 @@ this._db = _db; | ||
| this._as = arg2; | ||
| var tableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(this.tableType); | ||
| const tableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(this.tableType); | ||
| if (!tableDef) { | ||
| throw new Error("'" + this.tableType.name + "'\uC5D0 '@Table()'\uC774 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."); | ||
| throw new Error(`'${this.tableType.name}'에 '@Table()'이 지정되지 않았습니다.`); | ||
| } | ||
| this._tableDef = tableDef; | ||
| this._entity = {}; | ||
| for (var _i = 0, _c = this._tableDef.columns; _i < _c.length; _i++) { | ||
| var colDef = _c[_i]; | ||
| this._entity[colDef.propertyKey] = new QueryUnit_1.QueryUnit(colDef.typeFwd(), "[TBL" + (this._as ? "." + this._as : "") + "].[" + colDef.name + "]"); | ||
| for (const colDef of this._tableDef.columns) { | ||
| this._entity[colDef.propertyKey] = new QueryUnit_1.QueryUnit(colDef.typeFwd(), `[TBL${this._as ? `.${this._as}` : ""}].[${colDef.name}]`); | ||
| } | ||
@@ -56,66 +54,63 @@ this._def = { | ||
| } | ||
| Queryable.union = function (qrs, as) { | ||
| var db = qrs[0]._db; | ||
| var cqrs = qrs.map(function (item) { return new Queryable(db, item); }); | ||
| var entity = {}; | ||
| for (var _i = 0, _a = Object.keys(cqrs[0]._entity); _i < _a.length; _i++) { | ||
| var entityKey = _a[_i]; | ||
| var entityValue = cqrs[0]._entity[entityKey]; | ||
| static union(qrs, as) { | ||
| const db = qrs[0]._db; | ||
| const cqrs = qrs.map((item) => new Queryable(db, item)); | ||
| const entity = {}; | ||
| for (const entityKey of Object.keys(cqrs[0]._entity)) { | ||
| const entityValue = cqrs[0]._entity[entityKey]; | ||
| if (!QueryUtil_1.QueryUtil.canGetQueryValue(entityValue)) { | ||
| throw new Error("단일계층 이상의 구조를 가진 'queryable' 은 UNION 할 수 없습니다. select 를 통해 단일계층으로 만드세요."); | ||
| } | ||
| entity[entityKey] = new QueryUnit_1.QueryUnit(QueryUtil_1.QueryUtil.getQueryValueType(entityValue), "[TBL" + (as ? "." + as : "") + "].[" + entityKey + "]"); | ||
| entity[entityKey] = new QueryUnit_1.QueryUnit(QueryUtil_1.QueryUtil.getQueryValueType(entityValue), `[TBL${as ? "." + as : ""}].[${entityKey}]`); | ||
| } | ||
| var from = cqrs.map(function (item) { return item.getSelectDef(); }); | ||
| return new Queryable(db, undefined, as, entity, { from: from }); | ||
| }; | ||
| Queryable.prototype.select = function (fwd) { | ||
| var newEntity = fwd(this._entity); | ||
| const from = cqrs.map((item) => item.getSelectDef()); | ||
| return new Queryable(db, undefined, as, entity, { from }); | ||
| } | ||
| select(fwd) { | ||
| const newEntity = fwd(this._entity); | ||
| return new Queryable(this._db, this, newEntity); | ||
| }; | ||
| Queryable.prototype.where = function (predicate) { | ||
| var result = new Queryable(this._db, this); | ||
| var where = sorm_1.sorm.and(predicate(this._entity)); | ||
| } | ||
| where(predicate) { | ||
| const result = new Queryable(this._db, this); | ||
| const where = sorm_1.sorm.and(predicate(this._entity)); | ||
| result._def.where = result._def.where ? sorm_1.sorm.and([result._def.where, where]) : where; | ||
| return result; | ||
| }; | ||
| Queryable.prototype.distinct = function () { | ||
| var result = new Queryable(this._db, this); | ||
| } | ||
| distinct() { | ||
| const result = new Queryable(this._db, this); | ||
| result._def.distinct = true; | ||
| return result; | ||
| }; | ||
| Queryable.prototype.top = function (count) { | ||
| var result = new Queryable(this._db, this); | ||
| } | ||
| top(count) { | ||
| const result = new Queryable(this._db, this); | ||
| result._def.top = count; | ||
| return result; | ||
| }; | ||
| Queryable.prototype.orderBy = function (fwd, desc) { | ||
| } | ||
| orderBy(fwd, desc) { | ||
| var _a; | ||
| var result = new Queryable(this._db, this); | ||
| const result = new Queryable(this._db, this); | ||
| result._def.orderBy = (_a = result._def.orderBy, (_a !== null && _a !== void 0 ? _a : [])); | ||
| result._def.orderBy.push([QueryUtil_1.QueryUtil.getQueryValue(fwd(this._entity)), (desc ? "DESC" : "ASC")]); | ||
| return result; | ||
| }; | ||
| Queryable.prototype.limit = function (skip, take) { | ||
| var result = new Queryable(this._db, this); | ||
| } | ||
| limit(skip, take) { | ||
| const result = new Queryable(this._db, this); | ||
| result._def.limit = [skip, take]; | ||
| return result; | ||
| }; | ||
| Queryable.prototype.groupBy = function (fwd) { | ||
| var result = new Queryable(this._db, this); | ||
| result._def.groupBy = fwd(this._entity).map(function (item) { return QueryUtil_1.QueryUtil.getQueryValue(item); }); | ||
| } | ||
| groupBy(fwd) { | ||
| const result = new Queryable(this._db, this); | ||
| result._def.groupBy = fwd(this._entity).map((item) => QueryUtil_1.QueryUtil.getQueryValue(item)); | ||
| return result; | ||
| }; | ||
| Queryable.prototype.having = function (predicate) { | ||
| } | ||
| having(predicate) { | ||
| var _a; | ||
| var _b; | ||
| var result = new Queryable(this._db, this); | ||
| result._def.having = (_b = result._def.having, (_b !== null && _b !== void 0 ? _b : [])); | ||
| (_a = result._def.having).push.apply(_a, sorm_1.sorm.and(predicate(this._entity))); | ||
| const result = new Queryable(this._db, this); | ||
| result._def.having = (_a = result._def.having, (_a !== null && _a !== void 0 ? _a : [])); | ||
| result._def.having.push(...sorm_1.sorm.and(predicate(this._entity))); | ||
| return result; | ||
| }; | ||
| Queryable.prototype.join = function (joinTypeOrQrs, as, fwd, isSingle) { | ||
| } | ||
| join(joinTypeOrQrs, as, fwd, isSingle) { | ||
| var _a; | ||
| var _b; | ||
| var joinTableQueryable; | ||
| let joinTableQueryable; | ||
| if (joinTypeOrQrs instanceof Array) { | ||
@@ -127,86 +122,86 @@ joinTableQueryable = Queryable.union(joinTypeOrQrs, as); | ||
| } | ||
| var joinQueryable = fwd(joinTableQueryable, this._entity); | ||
| var joinEntity = joinQueryable._entity; | ||
| var result = new Queryable(this._db, this, tslib_1.__assign(tslib_1.__assign({}, this._entity), (_a = {}, _a[as] = isSingle ? joinEntity : [joinEntity], _a))); | ||
| result._def.join = (_b = result._def.join, (_b !== null && _b !== void 0 ? _b : [])); | ||
| result._def.join.push(tslib_1.__assign(tslib_1.__assign({}, joinQueryable.getSelectDef()), { isSingle: !!isSingle })); | ||
| const joinQueryable = fwd(joinTableQueryable, this._entity); | ||
| const joinEntity = joinQueryable._entity; | ||
| const result = new Queryable(this._db, this, { | ||
| ...this._entity, | ||
| [as]: isSingle ? joinEntity : [joinEntity] | ||
| }); | ||
| result._def.join = (_a = result._def.join, (_a !== null && _a !== void 0 ? _a : [])); | ||
| result._def.join.push({ | ||
| ...joinQueryable.getSelectDef(), | ||
| isSingle: !!isSingle | ||
| }); | ||
| return result; | ||
| }; | ||
| Queryable.prototype.include = function (targetFwd) { | ||
| } | ||
| include(targetFwd) { | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 include 를 사용할 수 없습니다."); | ||
| } | ||
| var parsed = sd_core_common_1.FunctionUtil.parse(targetFwd); | ||
| var itemParamName = parsed.params[0]; | ||
| var tableChainedName = parsed.returnContent | ||
| .replace(new RegExp(itemParamName + "\\."), "") | ||
| const parsed = sd_core_common_1.FunctionUtil.parse(targetFwd); | ||
| const itemParamName = parsed.params[0]; | ||
| const tableChainedName = parsed.returnContent | ||
| .replace(new RegExp(`${itemParamName}\\.`), "") | ||
| .replace(/\[0]/g, "") | ||
| .trim(); | ||
| var chain = tableChainedName.split("."); | ||
| var result = this; | ||
| var tableDef = this._tableDef; | ||
| var asChainArr = []; | ||
| var _loop_1 = function (fkName) { | ||
| const chain = tableChainedName.split("."); | ||
| let result = this; | ||
| let tableDef = this._tableDef; | ||
| const asChainArr = []; | ||
| for (const fkName of chain) { | ||
| asChainArr.push(fkName); | ||
| var as = asChainArr.join("."); | ||
| var fkDef = tableDef.foreignKeys.single(function (item) { return item.propertyKey === fkName; }); | ||
| var fktDef = tableDef.foreignKeyTargets.single(function (item) { return item.propertyKey === fkName; }); | ||
| const as = asChainArr.join("."); | ||
| const fkDef = tableDef.foreignKeys.single((item) => item.propertyKey === fkName); | ||
| const fktDef = tableDef.foreignKeyTargets.single((item) => item.propertyKey === fkName); | ||
| if (!fkDef && !fktDef) { | ||
| throw new Error("'" + tableDef.name + "." + fkName + "'\uC5D0 '@ForeignKey()'\uB098 '@ForeignKeyTarget()'\uC774 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."); | ||
| throw new Error(`'${tableDef.name}.${fkName}'에 '@ForeignKey()'나 '@ForeignKeyTarget()'이 지정되지 않았습니다.`); | ||
| } | ||
| if (fkDef) { | ||
| var fkTargetType = fkDef.targetTypeFwd(); | ||
| var fkTargetTableDef_1 = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fkTargetType); | ||
| if (fkDef.columnPropertyKeys.length !== fkTargetTableDef_1.columns.filter(function (item) { return item.primaryKey !== undefined; }).length) { | ||
| throw new Error("'" + tableDef.name + "." + fkName + "'\uC758 FK \uC124\uC815\uACFC '" + fkTargetTableDef_1.name + "'\uC758 PK \uC124\uC815\uC758 \uAE38\uC774\uAC00 \uB2E4\uB985\uB2C8\uB2E4."); | ||
| const fkTargetType = fkDef.targetTypeFwd(); | ||
| const fkTargetTableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fkTargetType); | ||
| if (fkDef.columnPropertyKeys.length !== fkTargetTableDef.columns.filter((item) => item.primaryKey !== undefined).length) { | ||
| throw new Error(`'${tableDef.name}.${fkName}'의 FK 설정과 '${fkTargetTableDef.name}'의 PK 설정의 길이가 다릅니다.`); | ||
| } | ||
| result = result.join(fkTargetType, as, function (q, en) { return q.where(function (item) { | ||
| var whereQuery = []; | ||
| for (var i = 0; i < fkDef.columnPropertyKeys.length; i++) { | ||
| whereQuery.push(sorm_1.sorm.equal(item[fkTargetTableDef_1.columns[i].propertyKey], en[fkDef.columnPropertyKeys[i]])); | ||
| result = result.join(fkTargetType, as, (q, en) => q.where((item) => { | ||
| const whereQuery = []; | ||
| for (let i = 0; i < fkDef.columnPropertyKeys.length; i++) { | ||
| whereQuery.push(sorm_1.sorm.equal(item[fkTargetTableDef.columns[i].propertyKey], en[fkDef.columnPropertyKeys[i]])); | ||
| } | ||
| return whereQuery; | ||
| }); }, true); | ||
| tableDef = fkTargetTableDef_1; | ||
| }), true); | ||
| tableDef = fkTargetTableDef; | ||
| } | ||
| else if (fktDef) { | ||
| var fktSourceType = fktDef.sourceTypeFwd(); | ||
| var fktSourceTableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fktSourceType); | ||
| var fktSourceFkDef_1 = fktSourceTableDef.foreignKeys.single(function (item) { return item.propertyKey === fktDef.foreignKeyPropertyKey; }); | ||
| if (!fktSourceFkDef_1) { | ||
| throw new Error("'" + fktSourceTableDef.name + "." + fktDef.foreignKeyPropertyKey + "'\uC5D0 '@ForeignKey()'\uAC00 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."); | ||
| const fktSourceType = fktDef.sourceTypeFwd(); | ||
| const fktSourceTableDef = DbDefinitionUtil_1.DbDefinitionUtil.getTableDef(fktSourceType); | ||
| const fktSourceFkDef = fktSourceTableDef.foreignKeys.single((item) => item.propertyKey === fktDef.foreignKeyPropertyKey); | ||
| if (!fktSourceFkDef) { | ||
| throw new Error(`'${fktSourceTableDef.name}.${fktDef.foreignKeyPropertyKey}'에 '@ForeignKey()'가 지정되지 않았습니다.`); | ||
| } | ||
| if (fktSourceFkDef_1.columnPropertyKeys.length !== tableDef.columns.filter(function (item) { return item.primaryKey !== undefined; }).length) { | ||
| throw new Error("'" + fktSourceTableDef.name + "." + fktDef.foreignKeyPropertyKey + "'\uC758 FK \uC124\uC815\uACFC '" + tableDef.name + "'\uC758 PK \uC124\uC815\uC758 \uAE38\uC774\uAC00 \uB2E4\uB985\uB2C8\uB2E4."); | ||
| if (fktSourceFkDef.columnPropertyKeys.length !== tableDef.columns.filter((item) => item.primaryKey !== undefined).length) { | ||
| throw new Error(`'${fktSourceTableDef.name}.${fktDef.foreignKeyPropertyKey}'의 FK 설정과 '${tableDef.name}'의 PK 설정의 길이가 다릅니다.`); | ||
| } | ||
| result = result.join(fktSourceType, as, function (q, en) { return q.where(function (item) { | ||
| var whereQuery = []; | ||
| for (var i = 0; i < fktSourceFkDef_1.columnPropertyKeys.length; i++) { | ||
| whereQuery.push(sorm_1.sorm.equal(item[fktSourceFkDef_1.columnPropertyKeys[i]], en[tableDef.columns[i].propertyKey])); | ||
| result = result.join(fktSourceType, as, (q, en) => q.where((item) => { | ||
| const whereQuery = []; | ||
| for (let i = 0; i < fktSourceFkDef.columnPropertyKeys.length; i++) { | ||
| whereQuery.push(sorm_1.sorm.equal(item[fktSourceFkDef.columnPropertyKeys[i]], en[tableDef.columns[i].propertyKey])); | ||
| } | ||
| return whereQuery; | ||
| }); }); | ||
| })); | ||
| tableDef = fktSourceTableDef; | ||
| } | ||
| }; | ||
| for (var _i = 0, chain_1 = chain; _i < chain_1.length; _i++) { | ||
| var fkName = chain_1[_i]; | ||
| _loop_1(fkName); | ||
| } | ||
| return result; | ||
| }; | ||
| Queryable.prototype.search = function (fwd, searchText) { | ||
| } | ||
| search(fwd, searchText) { | ||
| var _a; | ||
| var result = new Queryable(this._db, this); | ||
| var splitSearchText = searchText.trim().split(" ") | ||
| .map(function (item) { return item.trim(); }) | ||
| .filter(function (item) { return !!item; }); | ||
| let result = new Queryable(this._db, this); | ||
| const splitSearchText = searchText.trim().split(" ") | ||
| .map((item) => item.trim()) | ||
| .filter((item) => !!item); | ||
| result = result | ||
| .where(function (item) { | ||
| var orArr = []; | ||
| var fields = fwd(item); | ||
| for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) { | ||
| var field = fields_1[_i]; | ||
| for (var _a = 0, splitSearchText_1 = splitSearchText; _a < splitSearchText_1.length; _a++) { | ||
| var text = splitSearchText_1[_a]; | ||
| .where((item) => { | ||
| const orArr = []; | ||
| const fields = fwd(item); | ||
| for (const field of fields) { | ||
| for (const text of splitSearchText) { | ||
| orArr.push(sorm_1.sorm.includes(field, text)); | ||
@@ -217,27 +212,25 @@ } | ||
| }); | ||
| result = result.select(function (item) { | ||
| var fields = fwd(item); | ||
| var countQuery = []; | ||
| for (var _i = 0, fields_2 = fields; _i < fields_2.length; _i++) { | ||
| var field = fields_2[_i]; | ||
| countQuery.push.apply(countQuery, [sorm_1.sorm.case(sorm_1.sorm.includes(field, searchText), 10000).else(0), "+"]); | ||
| result = result.select((item) => { | ||
| const fields = fwd(item); | ||
| let countQuery = []; | ||
| for (const field of fields) { | ||
| countQuery.push(...[sorm_1.sorm.case(sorm_1.sorm.includes(field, searchText), 10000).else(0), "+"]); | ||
| } | ||
| for (var _a = 0, fields_3 = fields; _a < fields_3.length; _a++) { | ||
| var field = fields_3[_a]; | ||
| var andArr = []; | ||
| for (var _b = 0, splitSearchText_2 = splitSearchText; _b < splitSearchText_2.length; _b++) { | ||
| var text = splitSearchText_2[_b]; | ||
| for (const field of fields) { | ||
| const andArr = []; | ||
| for (const text of splitSearchText) { | ||
| andArr.push(sorm_1.sorm.includes(field, text)); | ||
| } | ||
| countQuery.push.apply(countQuery, [sorm_1.sorm.case(sorm_1.sorm.and(andArr), 100).else(0), "+"]); | ||
| countQuery.push(...[sorm_1.sorm.case(sorm_1.sorm.and(andArr), 100).else(0), "+"]); | ||
| } | ||
| for (var _c = 0, fields_4 = fields; _c < fields_4.length; _c++) { | ||
| var field = fields_4[_c]; | ||
| for (var _d = 0, splitSearchText_3 = splitSearchText; _d < splitSearchText_3.length; _d++) { | ||
| var text = splitSearchText_3[_d]; | ||
| countQuery.push.apply(countQuery, [sorm_1.sorm.case(sorm_1.sorm.includes(field, text), 1).else(0), "+"]); | ||
| for (const field of fields) { | ||
| for (const text of splitSearchText) { | ||
| countQuery.push(...[sorm_1.sorm.case(sorm_1.sorm.includes(field, text), 1).else(0), "+"]); | ||
| } | ||
| } | ||
| countQuery = countQuery.slice(0, -1); | ||
| return tslib_1.__assign(tslib_1.__assign({}, item), { __search_order: new QueryUnit_1.QueryUnit(Number, countQuery) }); | ||
| return { | ||
| ...item, | ||
| __search_order: new QueryUnit_1.QueryUnit(Number, countQuery) | ||
| }; | ||
| }); | ||
@@ -247,26 +240,25 @@ result._def.orderBy = (_a = result._def.orderBy, (_a !== null && _a !== void 0 ? _a : [])); | ||
| return result; | ||
| }; | ||
| Queryable.prototype.wrap = function (tableType) { | ||
| var entity = this._generateSubEntity(this._entity, this._as); | ||
| } | ||
| wrap(tableType) { | ||
| const entity = this._generateSubEntity(this._entity, this._as); | ||
| return new Queryable(this._db, tableType, this._as, entity, { | ||
| from: this.getSelectDef() | ||
| }); | ||
| }; | ||
| Queryable.prototype.getSelectDef = function () { | ||
| var result = {}; | ||
| } | ||
| getSelectDef() { | ||
| const result = {}; | ||
| result.from = this._def.from; | ||
| result.as = "[TBL" + (this._as ? "." + this._as : "") + "]"; | ||
| result.as = `[TBL${this._as ? `.${this._as}` : ""}]`; | ||
| result.select = {}; | ||
| var addSelectValue = function (key, value) { | ||
| const addSelectValue = (key, value) => { | ||
| if (QueryUtil_1.QueryUtil.canGetQueryValue(value)) { | ||
| result.select["[" + key + "]"] = QueryUtil_1.QueryUtil.getQueryValue(value); | ||
| result.select[`[${key}]`] = QueryUtil_1.QueryUtil.getQueryValue(value); | ||
| } | ||
| else if (value instanceof Array) { | ||
| if (value.some(function (item) { return QueryUtil_1.QueryUtil.canGetQueryValue(item); })) { | ||
| if (value.some((item) => QueryUtil_1.QueryUtil.canGetQueryValue(item))) { | ||
| throw new Error("SELECT 에 입력할 수 없는 정보가 입력되었습니다. (sorm.equal 등은 sorm.is 로 wrapping 해 주어야 사용할 수 있습니다.)"); | ||
| } | ||
| else { | ||
| for (var _i = 0, _a = Object.keys(value[0]); _i < _a.length; _i++) { | ||
| var subKey = _a[_i]; | ||
| addSelectValue(key + "." + subKey, value[0][subKey]); | ||
| for (const subKey of Object.keys(value[0])) { | ||
| addSelectValue(`${key}.${subKey}`, value[0][subKey]); | ||
| } | ||
@@ -276,10 +268,8 @@ } | ||
| else { | ||
| for (var _b = 0, _c = Object.keys(value); _b < _c.length; _b++) { | ||
| var subKey = _c[_b]; | ||
| addSelectValue(key + "." + subKey, value[subKey]); | ||
| for (const subKey of Object.keys(value)) { | ||
| addSelectValue(`${key}.${subKey}`, value[subKey]); | ||
| } | ||
| } | ||
| }; | ||
| for (var _i = 0, _a = Object.keys(this._entity); _i < _a.length; _i++) { | ||
| var entityKey = _a[_i]; | ||
| for (const entityKey of Object.keys(this._entity)) { | ||
| addSelectValue(entityKey, this._entity[entityKey]); | ||
@@ -298,3 +288,3 @@ } | ||
| } | ||
| if (this._def.limit && this._def.join && this._def.join.some(function (item) { return !item.isSingle; })) { | ||
| if (this._def.limit && this._def.join && this._def.join.some((item) => !item.isSingle)) { | ||
| throw new Error("다수의 'RECORD'를 'JOIN'하는 쿼리를 사용한 이후에는 'LIMIT'을 사용할 수 없습니다. 'LIMIT'을 먼저 사용하고, 'WRAP'한 이후에 'JOIN' 하시기 바랍니다."); | ||
@@ -306,10 +296,9 @@ } | ||
| return sd_core_common_1.ObjectUtil.clearUndefined(result); | ||
| }; | ||
| Queryable.prototype._generateSubEntity = function (fromEntity, parentAs) { | ||
| var result = {}; | ||
| for (var _i = 0, _a = Object.keys(fromEntity); _i < _a.length; _i++) { | ||
| var key = _a[_i]; | ||
| var entityValue = fromEntity[key]; | ||
| } | ||
| _generateSubEntity(fromEntity, parentAs) { | ||
| const result = {}; | ||
| for (const key of Object.keys(fromEntity)) { | ||
| const entityValue = fromEntity[key]; | ||
| if (QueryUtil_1.QueryUtil.canGetQueryValue(entityValue)) { | ||
| result[key] = new QueryUnit_1.QueryUnit(QueryUtil_1.QueryUtil.getQueryValueType(entityValue), "[TBL" + (parentAs ? "." + parentAs : "") + "].[" + key + "]"); | ||
| result[key] = new QueryUnit_1.QueryUnit(QueryUtil_1.QueryUtil.getQueryValueType(entityValue), "[TBL" + (parentAs ? `.${parentAs}` : "") + "].[" + key + "]"); | ||
| } | ||
@@ -326,4 +315,4 @@ else if (entityValue instanceof Array) { | ||
| return result; | ||
| }; | ||
| Queryable.prototype.getInsertDef = function (obj) { | ||
| } | ||
| getInsertDef(obj) { | ||
| if (this._def.join !== undefined) { | ||
@@ -359,6 +348,5 @@ throw new Error("INSERT 와 JOIN 를 함께 사용할 수 없습니다."); | ||
| } | ||
| var record = {}; | ||
| for (var _i = 0, _a = Object.keys(obj); _i < _a.length; _i++) { | ||
| var key = _a[_i]; | ||
| record["[" + key + "]"] = QueryUtil_1.QueryUtil.getQueryValue(obj[key]); | ||
| const record = {}; | ||
| for (const key of Object.keys(obj)) { | ||
| record[`[${key}]`] = QueryUtil_1.QueryUtil.getQueryValue(obj[key]); | ||
| } | ||
@@ -368,6 +356,6 @@ return { | ||
| output: ["INSERTED.*"], | ||
| record: record | ||
| record | ||
| }; | ||
| }; | ||
| Queryable.prototype.getUpdateDef = function (arg) { | ||
| } | ||
| getUpdateDef(arg) { | ||
| if (typeof this._def.from !== "string") { | ||
@@ -391,7 +379,6 @@ throw new Error("UPDATE 할 TABLE 을 정확히 지정해야 합니다."); | ||
| } | ||
| var recordEntity = typeof arg === "function" ? arg(this._entity) : arg; | ||
| var record = {}; | ||
| for (var _i = 0, _a = Object.keys(recordEntity); _i < _a.length; _i++) { | ||
| var key = _a[_i]; | ||
| record["[" + key + "]"] = QueryUtil_1.QueryUtil.getQueryValue(recordEntity[key]); | ||
| const recordEntity = typeof arg === "function" ? arg(this._entity) : arg; | ||
| const record = {}; | ||
| for (const key of Object.keys(recordEntity)) { | ||
| record[`[${key}]`] = QueryUtil_1.QueryUtil.getQueryValue(recordEntity[key]); | ||
| } | ||
@@ -401,10 +388,10 @@ return sd_core_common_1.ObjectUtil.clearUndefined({ | ||
| from: this._def.from, | ||
| record: record, | ||
| record, | ||
| output: ["INSERTED.*"], | ||
| as: "[TBL" + (this._as ? "." + this._as : "") + "]", | ||
| as: `[TBL${this._as ? `.${this._as}` : ""}]`, | ||
| join: this._def.join, | ||
| where: this._def.where | ||
| }); | ||
| }; | ||
| Queryable.prototype.getUpsertDef = function (updateObjOrFwd, insertObj) { | ||
| } | ||
| getUpsertDef(updateObjOrFwd, insertObj) { | ||
| if (this._def.join !== undefined) { | ||
@@ -440,13 +427,11 @@ throw new Error("INSERT 와 JOIN 를 함께 사용할 수 없습니다."); | ||
| } | ||
| var updateRecordEntity = typeof updateObjOrFwd === "function" ? updateObjOrFwd(this._entity) : updateObjOrFwd; | ||
| var updateRecord = {}; | ||
| for (var _i = 0, _a = Object.keys(updateRecordEntity); _i < _a.length; _i++) { | ||
| var key = _a[_i]; | ||
| updateRecord["[" + key + "]"] = QueryUtil_1.QueryUtil.getQueryValue(updateRecordEntity[key]); | ||
| const updateRecordEntity = typeof updateObjOrFwd === "function" ? updateObjOrFwd(this._entity) : updateObjOrFwd; | ||
| const updateRecord = {}; | ||
| for (const key of Object.keys(updateRecordEntity)) { | ||
| updateRecord[`[${key}]`] = QueryUtil_1.QueryUtil.getQueryValue(updateRecordEntity[key]); | ||
| } | ||
| var insertRecord = {}; | ||
| let insertRecord = {}; | ||
| if (insertObj) { | ||
| for (var _b = 0, _c = Object.keys(insertObj); _b < _c.length; _b++) { | ||
| var key = _c[_b]; | ||
| insertRecord["[" + key + "]"] = QueryUtil_1.QueryUtil.getQueryValue(insertObj[key]); | ||
| for (const key of Object.keys(insertObj)) { | ||
| insertRecord[`[${key}]`] = QueryUtil_1.QueryUtil.getQueryValue(insertObj[key]); | ||
| } | ||
@@ -459,10 +444,10 @@ } | ||
| from: this._def.from, | ||
| as: "[TBL" + (this._as ? "." + this._as : "") + "]", | ||
| as: `[TBL${this._as ? `.${this._as}` : ""}]`, | ||
| where: this._def.where, | ||
| updateRecord: updateRecord, | ||
| insertRecord: insertRecord, | ||
| updateRecord, | ||
| insertRecord, | ||
| output: ["INSERTED.*"] | ||
| }); | ||
| }; | ||
| Queryable.prototype.getDeleteDef = function () { | ||
| } | ||
| getDeleteDef() { | ||
| if (typeof this._def.from !== "string") { | ||
@@ -493,170 +478,146 @@ throw new Error("INSERT 할 TABLE 을 정확히 지정해야 합니다."); | ||
| output: ["DELETED.*"], | ||
| as: "[TBL" + (this._as ? "." + this._as : "") + "]", | ||
| as: `[TBL${this._as ? `.${this._as}` : ""}]`, | ||
| join: this._def.join, | ||
| where: this._def.where | ||
| }); | ||
| }; | ||
| Queryable.prototype.resultAsync = function () { | ||
| } | ||
| async resultAsync() { | ||
| var _a; | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var def, cacheKey, cacheValue, err_1, results, timeout; | ||
| return tslib_1.__generator(this, function (_b) { | ||
| switch (_b.label) { | ||
| case 0: | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| def = this.getSelectDef(); | ||
| cacheKey = sd_core_common_1.JsonConvert.stringify(def); | ||
| if (!DbContext_1.DbContext.selectCache.has(cacheKey)) return [3, 4]; | ||
| _b.label = 1; | ||
| case 1: | ||
| _b.trys.push([1, 3, , 4]); | ||
| return [4, sd_core_common_1.Wait.true(function () { return DbContext_1.DbContext.selectCache.get(cacheKey) !== undefined; }, undefined, 30000)]; | ||
| case 2: | ||
| _b.sent(); | ||
| cacheValue = DbContext_1.DbContext.selectCache.get(cacheKey); | ||
| clearTimeout(cacheValue.timeout); | ||
| cacheValue.timeout = setTimeout(function () { | ||
| DbContext_1.DbContext.selectCache.delete(cacheKey); | ||
| }, 1000); | ||
| return [2, cacheValue.result]; | ||
| case 3: | ||
| err_1 = _b.sent(); | ||
| console.error(err_1); | ||
| return [3, 4]; | ||
| case 4: | ||
| DbContext_1.DbContext.selectCache.set(cacheKey, undefined); | ||
| return [4, this._db.executeDefsAsync([tslib_1.__assign({ type: "select" }, def)], [this._getParseOption()])]; | ||
| case 5: | ||
| results = _b.sent(); | ||
| timeout = setTimeout(function () { | ||
| DbContext_1.DbContext.selectCache.delete(cacheKey); | ||
| }, 1000); | ||
| DbContext_1.DbContext.selectCache.set(cacheKey, { result: (_a = results[0], (_a !== null && _a !== void 0 ? _a : [])), timeout: timeout }); | ||
| return [2, results[0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.singleAsync = function () { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var result; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: return [4, this.top(2).resultAsync()]; | ||
| case 1: | ||
| result = _a.sent(); | ||
| if (result.length > 1) { | ||
| throw new Error("복수의 쿼리결과가 있습니다."); | ||
| } | ||
| return [2, result[0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.countAsync = function () { | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| const def = this.getSelectDef(); | ||
| const cacheKey = sd_core_common_1.JsonConvert.stringify(def); | ||
| if (DbContext_1.DbContext.selectCache.has(cacheKey)) { | ||
| try { | ||
| await sd_core_common_1.Wait.true(() => DbContext_1.DbContext.selectCache.get(cacheKey) !== undefined, undefined, 30000); | ||
| const cacheValue = DbContext_1.DbContext.selectCache.get(cacheKey); | ||
| clearTimeout(cacheValue.timeout); | ||
| cacheValue.timeout = setTimeout(() => { | ||
| DbContext_1.DbContext.selectCache.delete(cacheKey); | ||
| }, 1000); | ||
| return cacheValue.result; | ||
| } | ||
| catch (err) { | ||
| console.error(err); | ||
| } | ||
| } | ||
| DbContext_1.DbContext.selectCache.set(cacheKey, undefined); | ||
| const results = await this._db.executeDefsAsync([{ type: "select", ...def }], [this._getParseOption()]); | ||
| const timeout = setTimeout(() => { | ||
| DbContext_1.DbContext.selectCache.delete(cacheKey); | ||
| }, 1000); | ||
| DbContext_1.DbContext.selectCache.set(cacheKey, { result: (_a = results[0], (_a !== null && _a !== void 0 ? _a : [])), timeout }); | ||
| return results[0]; | ||
| } | ||
| async singleAsync() { | ||
| const result = await this.top(2).resultAsync(); | ||
| if (result.length > 1) { | ||
| throw new Error("복수의 쿼리결과가 있습니다."); | ||
| } | ||
| return result[0]; | ||
| } | ||
| async countAsync() { | ||
| var _a, _b; | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var item; | ||
| return tslib_1.__generator(this, function (_c) { | ||
| switch (_c.label) { | ||
| case 0: return [4, this | ||
| .select(function () { return ({ cnt: new QueryUnit_1.QueryUnit(Number, "COUNT(*)") }); }) | ||
| .singleAsync()]; | ||
| case 1: | ||
| item = _c.sent(); | ||
| return [2, (_b = (_a = item) === null || _a === void 0 ? void 0 : _a.cnt, (_b !== null && _b !== void 0 ? _b : 0))]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.insertAsync = function (record) { | ||
| const item = await this | ||
| .select(() => ({ cnt: new QueryUnit_1.QueryUnit(Number, "COUNT(*)") })) | ||
| .singleAsync(); | ||
| return (_b = (_a = item) === null || _a === void 0 ? void 0 : _a.cnt, (_b !== null && _b !== void 0 ? _b : 0)); | ||
| } | ||
| async insertAsync(record) { | ||
| var _a, _b, _c, _d; | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var aiColNames, hasAutoIncreaseColumnValue, queryDef, parseOption; | ||
| return tslib_1.__generator(this, function (_e) { | ||
| switch (_e.label) { | ||
| case 0: | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 테이블의 정보를 가져올 수 없습니다."); | ||
| } | ||
| aiColNames = this._tableDef.columns.filter(function (item) { return item.autoIncrement; }).map(function (item) { return item.name; }); | ||
| hasAutoIncreaseColumnValue = Object.keys(record).some(function (item) { return aiColNames.includes(item); }); | ||
| queryDef = this.getInsertDef(record); | ||
| parseOption = this._getParseOption(); | ||
| if (!hasAutoIncreaseColumnValue) return [3, 2]; | ||
| return [4, this._db.executeDefsAsync([ | ||
| tslib_1.__assign({ type: "configIdentityInsert" }, { | ||
| table: { | ||
| database: (_a = this._tableDef.database, (_a !== null && _a !== void 0 ? _a : this._db.schema.database)), | ||
| schema: (_b = this._tableDef.schema, (_b !== null && _b !== void 0 ? _b : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "on" | ||
| }), | ||
| tslib_1.__assign({ type: "insert" }, queryDef), | ||
| tslib_1.__assign({ type: "configIdentityInsert" }, { | ||
| table: { | ||
| database: (_c = this._tableDef.database, (_c !== null && _c !== void 0 ? _c : this._db.schema.database)), | ||
| schema: (_d = this._tableDef.schema, (_d !== null && _d !== void 0 ? _d : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "off" | ||
| }) | ||
| ], [undefined, parseOption, undefined])]; | ||
| case 1: return [2, (_e.sent())[1][0]]; | ||
| case 2: return [4, this._db.executeDefsAsync([tslib_1.__assign({ type: "insert" }, queryDef)], [parseOption])]; | ||
| case 3: return [2, (_e.sent())[0][0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.insertPrepare = function (record) { | ||
| var _a; | ||
| var _b, _c, _d, _e; | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 테이블의 정보를 가져올 수 없습니다."); | ||
| } | ||
| var aiColNames = this._tableDef.columns.filter(function (item) { return item.autoIncrement; }).map(function (item) { return item.name; }); | ||
| var hasAutoIncreaseColumnValue = Object.keys(record).some(function (item) { return aiColNames.includes(item); }); | ||
| var queryDef = this.getInsertDef(record); | ||
| var parseOption = this._getParseOption(); | ||
| const aiColNames = this._tableDef.columns.filter((item) => item.autoIncrement).map((item) => item.name); | ||
| const hasAutoIncreaseColumnValue = Object.keys(record).some((item) => aiColNames.includes(item)); | ||
| const queryDef = this.getInsertDef(record); | ||
| const parseOption = this._getParseOption(); | ||
| if (hasAutoIncreaseColumnValue) { | ||
| (_a = this._db.prepareDefs).push.apply(_a, [ | ||
| return (await this._db.executeDefsAsync([ | ||
| { | ||
| def: tslib_1.__assign({ type: "configIdentityInsert" }, { | ||
| type: "configIdentityInsert", | ||
| ...{ | ||
| table: { | ||
| database: (_b = this._tableDef.database, (_b !== null && _b !== void 0 ? _b : this._db.schema.database)), | ||
| schema: (_c = this._tableDef.schema, (_c !== null && _c !== void 0 ? _c : this._db.schema.schema)), | ||
| database: (_a = this._tableDef.database, (_a !== null && _a !== void 0 ? _a : this._db.schema.database)), | ||
| schema: (_b = this._tableDef.schema, (_b !== null && _b !== void 0 ? _b : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "on" | ||
| }), | ||
| option: undefined, | ||
| isRealResult: false | ||
| } | ||
| }, | ||
| { | ||
| def: tslib_1.__assign({ type: "insert" }, queryDef), | ||
| option: parseOption, | ||
| isRealResult: true | ||
| type: "insert", | ||
| ...queryDef | ||
| }, | ||
| { | ||
| def: tslib_1.__assign({ type: "configIdentityInsert" }, { | ||
| type: "configIdentityInsert", | ||
| ...{ | ||
| table: { | ||
| database: (_d = this._tableDef.database, (_d !== null && _d !== void 0 ? _d : this._db.schema.database)), | ||
| schema: (_e = this._tableDef.schema, (_e !== null && _e !== void 0 ? _e : this._db.schema.schema)), | ||
| database: (_c = this._tableDef.database, (_c !== null && _c !== void 0 ? _c : this._db.schema.database)), | ||
| schema: (_d = this._tableDef.schema, (_d !== null && _d !== void 0 ? _d : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "off" | ||
| }), | ||
| } | ||
| } | ||
| ], [undefined, parseOption, undefined]))[1][0]; | ||
| } | ||
| return (await this._db.executeDefsAsync([{ type: "insert", ...queryDef }], [parseOption]))[0][0]; | ||
| } | ||
| insertPrepare(record) { | ||
| var _a, _b, _c, _d; | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 테이블의 정보를 가져올 수 없습니다."); | ||
| } | ||
| const aiColNames = this._tableDef.columns.filter((item) => item.autoIncrement).map((item) => item.name); | ||
| const hasAutoIncreaseColumnValue = Object.keys(record).some((item) => aiColNames.includes(item)); | ||
| const queryDef = this.getInsertDef(record); | ||
| const parseOption = this._getParseOption(); | ||
| if (hasAutoIncreaseColumnValue) { | ||
| this._db.prepareDefs.push(...[ | ||
| { | ||
| def: { | ||
| type: "configIdentityInsert", | ||
| ...{ | ||
| table: { | ||
| database: (_a = this._tableDef.database, (_a !== null && _a !== void 0 ? _a : this._db.schema.database)), | ||
| schema: (_b = this._tableDef.schema, (_b !== null && _b !== void 0 ? _b : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "on" | ||
| } | ||
| }, | ||
| option: undefined, | ||
| isRealResult: false | ||
| }, | ||
| { | ||
| def: { | ||
| type: "insert", | ||
| ...queryDef | ||
| }, | ||
| option: parseOption, | ||
| isRealResult: true | ||
| }, | ||
| { | ||
| def: { | ||
| type: "configIdentityInsert", | ||
| ...{ | ||
| table: { | ||
| database: (_c = this._tableDef.database, (_c !== null && _c !== void 0 ? _c : this._db.schema.database)), | ||
| schema: (_d = this._tableDef.schema, (_d !== null && _d !== void 0 ? _d : this._db.schema.schema)), | ||
| name: this._tableDef.name | ||
| }, | ||
| state: "off" | ||
| } | ||
| }, | ||
| option: undefined, | ||
| isRealResult: false | ||
| } | ||
@@ -667,3 +628,6 @@ ]); | ||
| this._db.prepareDefs.push({ | ||
| def: tslib_1.__assign({ type: "insert" }, queryDef), | ||
| def: { | ||
| type: "insert", | ||
| ...queryDef | ||
| }, | ||
| option: parseOption, | ||
@@ -673,27 +637,4 @@ isRealResult: true | ||
| } | ||
| }; | ||
| Queryable.prototype.updateAsync = function (arg) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var queryDef, parseOption; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| queryDef = this.getUpdateDef(arg); | ||
| parseOption = this._getParseOption(); | ||
| return [4, this._db.executeDefsAsync([tslib_1.__assign({ type: "update" }, queryDef)], [{ | ||
| columns: parseOption.columns | ||
| }])]; | ||
| case 1: return [2, (_a.sent())[0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.updatePrepare = function (arg) { | ||
| } | ||
| async updateAsync(arg) { | ||
| if (!this._db) { | ||
@@ -705,6 +646,23 @@ throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| var queryDef = this.getUpdateDef(arg); | ||
| var parseOption = this._getParseOption(); | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| const queryDef = this.getUpdateDef(arg); | ||
| const parseOption = this._getParseOption(); | ||
| return (await this._db.executeDefsAsync([{ type: "update", ...queryDef }], [{ | ||
| columns: parseOption.columns | ||
| }]))[0]; | ||
| } | ||
| updatePrepare(arg) { | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| const queryDef = this.getUpdateDef(arg); | ||
| const parseOption = this._getParseOption(); | ||
| this._db.prepareDefs.push({ | ||
| def: tslib_1.__assign({ type: "update" }, queryDef), | ||
| def: { | ||
| type: "update", | ||
| ...queryDef | ||
| }, | ||
| option: { | ||
@@ -715,27 +673,4 @@ columns: parseOption.columns | ||
| }); | ||
| }; | ||
| Queryable.prototype.deleteAsync = function () { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var queryDef, parseOption; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| queryDef = this.getDeleteDef(); | ||
| parseOption = this._getParseOption(); | ||
| return [4, this._db.executeDefsAsync([tslib_1.__assign({ type: "delete" }, queryDef)], [{ | ||
| columns: parseOption.columns | ||
| }])]; | ||
| case 1: return [2, (_a.sent())[0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.deletePrepare = function () { | ||
| } | ||
| async deleteAsync() { | ||
| if (!this._db) { | ||
@@ -747,6 +682,20 @@ throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| var queryDef = this.getDeleteDef(); | ||
| var parseOption = this._getParseOption(); | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| const queryDef = this.getDeleteDef(); | ||
| const parseOption = this._getParseOption(); | ||
| return (await this._db.executeDefsAsync([{ type: "delete", ...queryDef }], [{ | ||
| columns: parseOption.columns | ||
| }]))[0]; | ||
| } | ||
| deletePrepare() { | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| const queryDef = this.getDeleteDef(); | ||
| const parseOption = this._getParseOption(); | ||
| this._db.prepareDefs.push({ | ||
| def: tslib_1.__assign({ type: "delete" }, queryDef), | ||
| def: { type: "delete", ...queryDef }, | ||
| option: { | ||
@@ -757,27 +706,4 @@ columns: parseOption.columns | ||
| }); | ||
| }; | ||
| Queryable.prototype.upsertAsync = function (updateObjOrFwd, insertObj) { | ||
| return tslib_1.__awaiter(this, void 0, Promise, function () { | ||
| var queryDef, parseOption; | ||
| return tslib_1.__generator(this, function (_a) { | ||
| switch (_a.label) { | ||
| case 0: | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| queryDef = this.getUpsertDef(updateObjOrFwd, insertObj); | ||
| parseOption = this._getParseOption(); | ||
| return [4, this._db.executeDefsAsync([tslib_1.__assign({ type: "upsert" }, queryDef)], [{ | ||
| columns: parseOption.columns | ||
| }])]; | ||
| case 1: return [2, (_a.sent())[0]]; | ||
| } | ||
| }); | ||
| }); | ||
| }; | ||
| Queryable.prototype.upsertPrepare = function (updateObjOrFwd, insertObj) { | ||
| } | ||
| async upsertAsync(updateObjOrFwd, insertObj) { | ||
| if (!this._db) { | ||
@@ -789,6 +715,20 @@ throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| var queryDef = this.getUpsertDef(updateObjOrFwd, insertObj); | ||
| var parseOption = this._getParseOption(); | ||
| DbContext_1.DbContext.selectCache.clear(); | ||
| const queryDef = this.getUpsertDef(updateObjOrFwd, insertObj); | ||
| const parseOption = this._getParseOption(); | ||
| return (await this._db.executeDefsAsync([{ type: "upsert", ...queryDef }], [{ | ||
| columns: parseOption.columns | ||
| }]))[0]; | ||
| } | ||
| upsertPrepare(updateObjOrFwd, insertObj) { | ||
| if (!this._db) { | ||
| throw new Error("'DbContext'가 설정되지 않은 쿼리는 실행할 수 없습니다."); | ||
| } | ||
| if (!this._tableDef) { | ||
| throw new Error("'Wrapping'된 이후에는 편집 쿼리를 실행할 수 없습니다."); | ||
| } | ||
| const queryDef = this.getUpsertDef(updateObjOrFwd, insertObj); | ||
| const parseOption = this._getParseOption(); | ||
| this._db.prepareDefs.push({ | ||
| def: tslib_1.__assign({ type: "upsert" }, queryDef), | ||
| def: { type: "upsert", ...queryDef }, | ||
| option: { | ||
@@ -799,11 +739,10 @@ columns: parseOption.columns | ||
| }); | ||
| }; | ||
| Queryable.prototype._getParseOption = function () { | ||
| var result = { | ||
| } | ||
| _getParseOption() { | ||
| const result = { | ||
| columns: {}, | ||
| joins: {} | ||
| }; | ||
| var configuration = function (entity, parentKeys) { | ||
| for (var _i = 0, _a = Object.keys(sd_core_common_1.ObjectUtil.clearUndefined(entity)); _i < _a.length; _i++) { | ||
| var key = _a[_i]; | ||
| const configuration = (entity, parentKeys) => { | ||
| for (const key of Object.keys(sd_core_common_1.ObjectUtil.clearUndefined(entity))) { | ||
| try { | ||
@@ -823,3 +762,3 @@ if (entity[key] && QueryUtil_1.QueryUtil.canGetQueryValue(entity[key])) { | ||
| catch (err) { | ||
| err.message = err.message + ("\n==> [" + key + "]"); | ||
| err.message = err.message + `\n==> [${key}]`; | ||
| throw err; | ||
@@ -831,6 +770,5 @@ } | ||
| return result; | ||
| }; | ||
| return Queryable; | ||
| }()); | ||
| } | ||
| } | ||
| exports.Queryable = Queryable; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var QueryUtil_1 = require("../util/QueryUtil"); | ||
| var QueryBuilder = (function () { | ||
| function QueryBuilder() { | ||
| } | ||
| QueryBuilder.select = function (def) { | ||
| var q = ""; | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| const QueryUtil_1 = require("../util/QueryUtil"); | ||
| class QueryBuilder { | ||
| static select(def) { | ||
| let q = ""; | ||
| q += "SELECT"; | ||
| if (def.top) { | ||
| q += " TOP " + def.top; | ||
| q += ` TOP ${def.top}`; | ||
| } | ||
@@ -19,15 +16,14 @@ if (def.distinct) { | ||
| q += "\n"; | ||
| var selectFieldQueryStrings = []; | ||
| for (var _i = 0, _a = Object.keys(def.select); _i < _a.length; _i++) { | ||
| var selectKey = _a[_i]; | ||
| var selectValue = def.select[selectKey]; | ||
| const selectFieldQueryStrings = []; | ||
| for (const selectKey of Object.keys(def.select)) { | ||
| const selectValue = def.select[selectKey]; | ||
| if (selectValue && selectValue["from"]) { | ||
| var selectQueryDef = selectValue; | ||
| var subQuery = " (\n"; | ||
| const selectQueryDef = selectValue; | ||
| let subQuery = ` (\n`; | ||
| subQuery += " " + QueryBuilder.select(selectQueryDef).replace(/\n/g, "\n ") + "\n"; | ||
| subQuery += " ) as " + selectKey; | ||
| subQuery += ` ) as ${selectKey}`; | ||
| selectFieldQueryStrings.push(subQuery); | ||
| } | ||
| else { | ||
| selectFieldQueryStrings.push(" " + QueryBuilder.getQueryOfQueryValue(def.select[selectKey]) + " as " + selectKey); | ||
| selectFieldQueryStrings.push(` ${QueryBuilder.getQueryOfQueryValue(def.select[selectKey])} as ${selectKey}`); | ||
| } | ||
@@ -38,6 +34,5 @@ } | ||
| if (def.from instanceof Array) { | ||
| q += "FROM (\n"; | ||
| for (var _b = 0, _c = def.from; _b < _c.length; _b++) { | ||
| var from = _c[_b]; | ||
| var fromQueryDef = from; | ||
| q += `FROM (\n`; | ||
| for (const from of def.from) { | ||
| const fromQueryDef = from; | ||
| q += " " + QueryBuilder.select(fromQueryDef).replace(/\n/g, "\n "); | ||
@@ -47,18 +42,17 @@ q += "\n\n UNION ALL\n\n"; | ||
| q = q.slice(0, -14); | ||
| q += ")"; | ||
| q += `)`; | ||
| } | ||
| else if (def.from["from"]) { | ||
| var fromQueryDef = def.from; | ||
| q += "FROM (\n"; | ||
| const fromQueryDef = def.from; | ||
| q += `FROM (\n`; | ||
| q += " " + QueryBuilder.select(fromQueryDef).replace(/\n/g, "\n ") + "\n"; | ||
| q += ")"; | ||
| q += `)`; | ||
| } | ||
| else { | ||
| q += "FROM " + def.from; | ||
| q += `FROM ${def.from}`; | ||
| } | ||
| q += def.as ? " as " + def.as : ""; | ||
| q += def.as ? ` as ${def.as}` : ""; | ||
| q += "\n"; | ||
| if (def.join && def.join.length > 0) { | ||
| for (var _d = 0, _e = def.join; _d < _e.length; _d++) { | ||
| var joinDef = _e[_d]; | ||
| for (const joinDef of def.join) { | ||
| q += QueryBuilder._getQueryOfJoinDef(joinDef); | ||
@@ -69,7 +63,7 @@ q += "\n"; | ||
| if (def.where) { | ||
| q += "WHERE " + def.where.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += `WHERE ${def.where.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| q += "\n"; | ||
| } | ||
| if (def.groupBy && def.groupBy.length > 0) { | ||
| q += "GROUP BY " + def.groupBy.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(", "); | ||
| q += `GROUP BY ${def.groupBy.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join(", ")}`; | ||
| q += "\n"; | ||
@@ -81,7 +75,7 @@ } | ||
| } | ||
| q += "HAVING " + def.having.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += `HAVING ${def.having.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| q += "\n"; | ||
| } | ||
| if (def.orderBy && def.orderBy.length > 0) { | ||
| q += "ORDER BY " + def.orderBy.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item[0]) + " " + item[1]; }).join(", "); | ||
| q += `ORDER BY ${def.orderBy.map((item) => QueryBuilder.getQueryOfQueryValue(item[0]) + " " + item[1]).join(", ")}`; | ||
| q += "\n"; | ||
@@ -93,38 +87,38 @@ } | ||
| } | ||
| q += "OFFSET " + def.limit[0] + " ROWS FETCH NEXT " + def.limit[1] + " ROWS ONLY"; | ||
| q += `OFFSET ${def.limit[0]} ROWS FETCH NEXT ${def.limit[1]} ROWS ONLY`; | ||
| q += "\n"; | ||
| } | ||
| return q.trim(); | ||
| }; | ||
| QueryBuilder.insert = function (def) { | ||
| var q = ""; | ||
| q += "INSERT INTO " + def.from + " (" + Object.keys(def.record).join(", ") + ")"; | ||
| } | ||
| static insert(def) { | ||
| let q = ""; | ||
| q += `INSERT INTO ${def.from} (${Object.keys(def.record).join(", ")})`; | ||
| q += "\n"; | ||
| if (def.output) { | ||
| q += "OUTPUT " + def.output.join(", "); | ||
| q += `OUTPUT ${def.output.join(", ")}`; | ||
| q += "\n"; | ||
| } | ||
| q += "VALUES (" + Object.values(def.record).map(function (val) { return QueryBuilder.getQueryOfQueryValue(val); }).join(", ") + ")"; | ||
| q += `VALUES (${Object.values(def.record).map((val) => QueryBuilder.getQueryOfQueryValue(val)).join(", ")})`; | ||
| q += "\n"; | ||
| return q.trim(); | ||
| }; | ||
| QueryBuilder.update = function (def) { | ||
| } | ||
| static update(def) { | ||
| var _a; | ||
| var q = ""; | ||
| q += "UPDATE"; | ||
| let q = ""; | ||
| q += `UPDATE`; | ||
| if (def.top) { | ||
| q += " TOP (" + def.top + ")"; | ||
| q += ` TOP (${def.top})`; | ||
| } | ||
| q += " " + (_a = def.as, (_a !== null && _a !== void 0 ? _a : def.from)) + " SET"; | ||
| q += ` ${_a = def.as, (_a !== null && _a !== void 0 ? _a : def.from)} SET`; | ||
| q += "\n"; | ||
| q += Object.keys(def.record).map(function (key) { return " " + key + " = " + QueryBuilder.getQueryOfQueryValue(def.record[key]); }).join(",\n"); | ||
| q += Object.keys(def.record).map((key) => ` ${key} = ${QueryBuilder.getQueryOfQueryValue(def.record[key])}`).join(",\n"); | ||
| q += "\n"; | ||
| if (def.output) { | ||
| q += "OUTPUT " + def.output.join(", "); | ||
| q += `OUTPUT ${def.output.join(", ")}`; | ||
| q += "\n"; | ||
| } | ||
| if (def.as || (def.join && def.join.length > 0)) { | ||
| q += "FROM " + def.from; | ||
| q += `FROM ${def.from}`; | ||
| if (def.as) { | ||
| q += " as " + def.as; | ||
| q += ` as ${def.as}`; | ||
| } | ||
@@ -134,4 +128,3 @@ q += "\n"; | ||
| if (def.join && def.join.length > 0) { | ||
| for (var _i = 0, _b = def.join; _i < _b.length; _i++) { | ||
| var joinDef = _b[_i]; | ||
| for (const joinDef of def.join) { | ||
| q += QueryBuilder._getQueryOfJoinDef(joinDef); | ||
@@ -142,12 +135,12 @@ q += "\n"; | ||
| if (def.where) { | ||
| q += "WHERE " + def.where.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += `WHERE ${def.where.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| q += "\n"; | ||
| } | ||
| return q.trim(); | ||
| }; | ||
| QueryBuilder.upsert = function (def) { | ||
| var q = ""; | ||
| q += "MERGE " + def.from; | ||
| } | ||
| static upsert(def) { | ||
| let q = ""; | ||
| q += `MERGE ${def.from}`; | ||
| if (def.as) { | ||
| q += " as " + def.as; | ||
| q += ` as ${def.as}`; | ||
| } | ||
@@ -157,3 +150,3 @@ q += "\n"; | ||
| q += "\n"; | ||
| q += "ON " + def.where.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += `ON ${def.where.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| q += "\n"; | ||
@@ -163,32 +156,32 @@ if (def.updateRecord && Object.keys(def.updateRecord).length > 0) { | ||
| q += " UPDATE SET\n"; | ||
| q += Object.keys(def.updateRecord).map(function (key) { return " " + key + " = " + QueryBuilder.getQueryOfQueryValue(def.updateRecord[key]); }).join(",\n"); | ||
| q += Object.keys(def.updateRecord).map((key) => ` ${key} = ${QueryBuilder.getQueryOfQueryValue(def.updateRecord[key])}`).join(",\n"); | ||
| q += "\n"; | ||
| } | ||
| q += "WHEN NOT MATCHED THEN\n"; | ||
| q += " INSERT (" + Object.keys(def.insertRecord).join(", ") + ")\n"; | ||
| q += " VALUES (" + Object.values(def.insertRecord).map(function (val) { return QueryBuilder.getQueryOfQueryValue(val); }).join(", ") + ")"; | ||
| q += ` INSERT (${Object.keys(def.insertRecord).join(", ")})\n`; | ||
| q += ` VALUES (${Object.values(def.insertRecord).map((val) => QueryBuilder.getQueryOfQueryValue(val)).join(", ")})`; | ||
| q += "\n"; | ||
| if (def.output) { | ||
| q += "OUTPUT " + def.output.join(", "); | ||
| q += `OUTPUT ${def.output.join(", ")}`; | ||
| q += "\n"; | ||
| } | ||
| return q.trim() + ";"; | ||
| }; | ||
| QueryBuilder.delete = function (def) { | ||
| } | ||
| static delete(def) { | ||
| var _a; | ||
| var q = ""; | ||
| q += "DELETE"; | ||
| let q = ""; | ||
| q += `DELETE`; | ||
| if (def.top) { | ||
| q += " TOP (" + def.top + ")"; | ||
| q += ` TOP (${def.top})`; | ||
| } | ||
| q += " " + (_a = def.as, (_a !== null && _a !== void 0 ? _a : def.from)); | ||
| q += ` ${_a = def.as, (_a !== null && _a !== void 0 ? _a : def.from)}`; | ||
| q += "\n"; | ||
| if (def.output) { | ||
| q += "OUTPUT " + def.output.join(", "); | ||
| q += `OUTPUT ${def.output.join(", ")}`; | ||
| q += "\n"; | ||
| } | ||
| if (def.as || (def.join && def.join.length > 0)) { | ||
| q += "FROM " + def.from; | ||
| q += `FROM ${def.from}`; | ||
| if (def.as) { | ||
| q += " as " + def.as; | ||
| q += ` as ${def.as}`; | ||
| } | ||
@@ -198,4 +191,3 @@ q += "\n"; | ||
| if (def.join && def.join.length > 0) { | ||
| for (var _i = 0, _b = def.join; _i < _b.length; _i++) { | ||
| var joinDef = _b[_i]; | ||
| for (const joinDef of def.join) { | ||
| q += QueryBuilder._getQueryOfJoinDef(joinDef); | ||
@@ -206,94 +198,133 @@ q += "\n"; | ||
| if (def.where) { | ||
| q += "WHERE " + def.where.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += `WHERE ${def.where.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| q += "\n"; | ||
| } | ||
| return q.trim(); | ||
| }; | ||
| QueryBuilder.createDatabaseIfNotExists = function (def) { | ||
| return ("IF NOT EXISTS(select * from sys.databases WHERE name='" + def.database + "') CREATE DATABASE [" + def.database + "]").trim(); | ||
| }; | ||
| QueryBuilder.clearDatabaseIfExists = function (def) { | ||
| return ("\nIF EXISTS(select * from sys.databases WHERE name='" + def.database + "')\nBEGIN\n DECLARE @sql NVARCHAR(MAX);\n SET @sql = N'';\n \n -- \uD504\uB85D\uC2DC\uC800 \uCD08\uAE30\uD654\n SELECT @sql = @sql + 'DROP PROCEDURE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(o.name) +';' + CHAR(13) + CHAR(10)\n FROM [" + def.database + "].sys.sql_modules m\n INNER JOIN [" + def.database + "].sys.objects o ON m.object_id=o.object_id\n WHERE type_desc like '%PROCEDURE%'\n \n -- \uD568\uC218 \uCD08\uAE30\uD654\n SELECT @sql = @sql + 'DROP FUNCTION [" + def.database + "].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(o.name) + N';' + CHAR(13) + CHAR(10)\n FROM [" + def.database + "].sys.sql_modules m\n INNER JOIN [" + def.database + "].sys.objects o ON m.object_id=o.object_id\n WHERE type_desc like '%function%'\n \n -- \uBDF0 \uCD08\uAE30\uD654\n SELECT @sql = @sql + 'DROP VIEW [" + def.database + "].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(v.name) + N';' + CHAR(13) + CHAR(10)\n FROM [" + def.database + "].sys.views v\n \n -- \uD14C\uC774\uBE14 FK \uB04A\uAE30 \uCD08\uAE30\uD654\n SELECT @sql = @sql + N'ALTER TABLE [" + def.database + "].' + QUOTENAME(SCHEMA_NAME([tbl].schema_id)) + '.' + QUOTENAME([tbl].[name]) + N' DROP CONSTRAINT ' + QUOTENAME([obj].[name]) + N';' + CHAR(13) + CHAR(10)\n FROM [" + def.database + "].sys.tables [tbl]\n INNER JOIN [" + def.database + "].sys.objects AS [obj] ON [obj].[parent_object_id] = [tbl].[object_id] AND [obj].[type] = 'F'\n\n -- \uD14C\uC774\uBE14 \uC0AD\uC81C\n SELECT @sql = @sql + N'DROP TABLE [" + def.database + "].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME([tbl].[name]) + N';' + CHAR(13) + CHAR(10)\n FROM [" + def.database + "].sys.tables [tbl]\n WHERE [type]= 'U'\n\n EXEC(@sql);\nEND").trim(); | ||
| }; | ||
| QueryBuilder.createTable = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var query = ""; | ||
| query += "CREATE TABLE " + tableName + " (\n"; | ||
| query += def.columns.map(function (colDef) { return " " + QueryBuilder._getQueryOfColDef(colDef); }).join(",\n") + "\n"; | ||
| } | ||
| static createDatabaseIfNotExists(def) { | ||
| return `IF NOT EXISTS(select * from sys.databases WHERE name='${def.database}') CREATE DATABASE [${def.database}]`.trim(); | ||
| } | ||
| static clearDatabaseIfExists(def) { | ||
| return ` | ||
| IF EXISTS(select * from sys.databases WHERE name='${def.database}') | ||
| BEGIN | ||
| DECLARE @sql NVARCHAR(MAX); | ||
| SET @sql = N''; | ||
| -- 프록시저 초기화 | ||
| SELECT @sql = @sql + 'DROP PROCEDURE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(o.name) +';' + CHAR(13) + CHAR(10) | ||
| FROM [${def.database}].sys.sql_modules m | ||
| INNER JOIN [${def.database}].sys.objects o ON m.object_id=o.object_id | ||
| WHERE type_desc like '%PROCEDURE%' | ||
| -- 함수 초기화 | ||
| SELECT @sql = @sql + 'DROP FUNCTION [${def.database}].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(o.name) + N';' + CHAR(13) + CHAR(10) | ||
| FROM [${def.database}].sys.sql_modules m | ||
| INNER JOIN [${def.database}].sys.objects o ON m.object_id=o.object_id | ||
| WHERE type_desc like '%function%' | ||
| -- 뷰 초기화 | ||
| SELECT @sql = @sql + 'DROP VIEW [${def.database}].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(v.name) + N';' + CHAR(13) + CHAR(10) | ||
| FROM [${def.database}].sys.views v | ||
| -- 테이블 FK 끊기 초기화 | ||
| SELECT @sql = @sql + N'ALTER TABLE [${def.database}].' + QUOTENAME(SCHEMA_NAME([tbl].schema_id)) + '.' + QUOTENAME([tbl].[name]) + N' DROP CONSTRAINT ' + QUOTENAME([obj].[name]) + N';' + CHAR(13) + CHAR(10) | ||
| FROM [${def.database}].sys.tables [tbl] | ||
| INNER JOIN [${def.database}].sys.objects AS [obj] ON [obj].[parent_object_id] = [tbl].[object_id] AND [obj].[type] = 'F' | ||
| -- 테이블 삭제 | ||
| SELECT @sql = @sql + N'DROP TABLE [${def.database}].' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME([tbl].[name]) + N';' + CHAR(13) + CHAR(10) | ||
| FROM [${def.database}].sys.tables [tbl] | ||
| WHERE [type]= 'U' | ||
| EXEC(@sql); | ||
| END`.trim(); | ||
| } | ||
| static createTable(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| let query = ""; | ||
| query += `CREATE TABLE ${tableName} (\n`; | ||
| query += def.columns.map((colDef) => " " + QueryBuilder._getQueryOfColDef(colDef)).join(",\n") + "\n"; | ||
| query += ")"; | ||
| return query.trim(); | ||
| }; | ||
| QueryBuilder.dropTable = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return "DROP TABLE " + tableName; | ||
| }; | ||
| QueryBuilder.addColumn = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var queries = []; | ||
| } | ||
| static dropTable(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return `DROP TABLE ${tableName}`; | ||
| } | ||
| static addColumn(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| const queries = []; | ||
| if (!def.column.nullable && def.column.defaultValue) { | ||
| queries.push("ALTER TABLE " + tableName + " ADD " + QueryBuilder._getQueryOfColDef(tslib_1.__assign(tslib_1.__assign({}, def.column), { nullable: true }))); | ||
| queries.push("UPDATE " + tableName + " SET [" + def.column.name + "] = " + QueryBuilder.getQueryOfQueryValue(def.column.defaultValue)); | ||
| queries.push("ALTER TABLE " + tableName + " ALTER COLUMN " + QueryBuilder._getQueryOfColDef(def.column)); | ||
| queries.push(`ALTER TABLE ${tableName} ADD ${QueryBuilder._getQueryOfColDef({ | ||
| ...def.column, | ||
| nullable: true | ||
| })}`); | ||
| queries.push(`UPDATE ${tableName} SET [${def.column.name}] = ${QueryBuilder.getQueryOfQueryValue(def.column.defaultValue)}`); | ||
| queries.push(`ALTER TABLE ${tableName} ALTER COLUMN ${QueryBuilder._getQueryOfColDef(def.column)}`); | ||
| } | ||
| else { | ||
| queries.push("ALTER TABLE " + tableName + " ADD " + QueryBuilder._getQueryOfColDef(def.column)); | ||
| queries.push(`ALTER TABLE ${tableName} ADD ${QueryBuilder._getQueryOfColDef(def.column)}`); | ||
| } | ||
| return queries; | ||
| }; | ||
| QueryBuilder.removeColumn = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return "ALTER TABLE " + tableName + " DROP COLUMN [" + def.column + "]"; | ||
| }; | ||
| QueryBuilder.modifyColumn = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var queries = []; | ||
| } | ||
| static removeColumn(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return `ALTER TABLE ${tableName} DROP COLUMN [${def.column}]`; | ||
| } | ||
| static modifyColumn(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| const queries = []; | ||
| if (!def.column.nullable && def.column.defaultValue) { | ||
| queries.push("ALTER TABLE " + tableName + " ALTER COLUMN " + QueryBuilder._getQueryOfColDef(tslib_1.__assign(tslib_1.__assign({}, def.column), { nullable: true }))); | ||
| queries.push("UPDATE " + tableName + " SET [" + def.column.name + "] = " + QueryBuilder.getQueryOfQueryValue(def.column.defaultValue) + " WHERE [" + def.column.name + "] IS NULL"); | ||
| queries.push(`ALTER TABLE ${tableName} ALTER COLUMN ${QueryBuilder._getQueryOfColDef({ | ||
| ...def.column, | ||
| nullable: true | ||
| })}`); | ||
| queries.push(`UPDATE ${tableName} SET [${def.column.name}] = ${QueryBuilder.getQueryOfQueryValue(def.column.defaultValue)} WHERE [${def.column.name}] IS NULL`); | ||
| } | ||
| queries.push("ALTER TABLE " + tableName + " ALTER COLUMN " + QueryBuilder._getQueryOfColDef(def.column)); | ||
| queries.push(`ALTER TABLE ${tableName} ALTER COLUMN ${QueryBuilder._getQueryOfColDef(def.column)}`); | ||
| return queries; | ||
| }; | ||
| QueryBuilder.renameColumn = function (def) { | ||
| return "EXECUTE " + def.table.database + "..sp_rename N'" + def.table.schema + "." + def.table.name + ".[" + def.prevName + "]', N'" + def.nextName + "', 'COLUMN'"; | ||
| }; | ||
| QueryBuilder.addPrimaryKey = function (def) { | ||
| } | ||
| static renameColumn(def) { | ||
| return `EXECUTE ${def.table.database}..sp_rename N'${def.table.schema}.${def.table.name}.[${def.prevName}]', N'${def.nextName}', 'COLUMN'`; | ||
| } | ||
| static addPrimaryKey(def) { | ||
| if (def.primaryKeys.length <= 0) { | ||
| throw new Error("설정할 PK가 입력되지 않았습니다."); | ||
| } | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return "ALTER TABLE " + tableName + " ADD PRIMARY KEY (" + def.primaryKeys.map(function (item) { return "[" + item.column + "] " + item.orderBy; }).join(", ") + ")"; | ||
| }; | ||
| QueryBuilder.addForeignKey = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| var fkName = "[FK_" + tableNameChain.join("_") + "_" + def.foreignKey.name + "]"; | ||
| var targetTableName = QueryUtil_1.QueryUtil.getTableName(def.foreignKey.targetTable); | ||
| var query = ""; | ||
| query += "ALTER TABLE " + tableName + " ADD CONSTRAINT " + fkName + " FOREIGN KEY (" + def.foreignKey.fkColumns.map(function (columnName) { return "[" + columnName + "]"; }).join(", ") + ")\n"; | ||
| query += " REFERENCES " + targetTableName + " (" + def.foreignKey.targetPkColumns.map(function (columnName) { return "[" + columnName + "]"; }).join(", ") + ")\n"; | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${def.primaryKeys.map((item) => `[${item.column}] ${item.orderBy}`).join(", ")})`; | ||
| } | ||
| static addForeignKey(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| const tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| const fkName = `[FK_${tableNameChain.join("_")}_${def.foreignKey.name}]`; | ||
| const targetTableName = QueryUtil_1.QueryUtil.getTableName(def.foreignKey.targetTable); | ||
| let query = ""; | ||
| query += `ALTER TABLE ${tableName} ADD CONSTRAINT ${fkName} FOREIGN KEY (${def.foreignKey.fkColumns.map((columnName) => `[${columnName}]`).join(", ")})\n`; | ||
| query += ` REFERENCES ${targetTableName} (${def.foreignKey.targetPkColumns.map((columnName) => `[${columnName}]`).join(", ")})\n`; | ||
| query += " ON DELETE NO ACTION\n"; | ||
| query += " ON UPDATE NO ACTION"; | ||
| return query.trim(); | ||
| }; | ||
| QueryBuilder.removeForeignKey = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| var fkName = "[FK_" + tableNameChain.join("_") + "_" + def.foreignKey + "]"; | ||
| return "ALTER TABLE " + tableName + " DROP CONSTRAINT " + fkName; | ||
| }; | ||
| QueryBuilder.createIndex = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| var tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| var idxName = "[IDX_" + tableNameChain.join("_") + "_" + def.index.name + "]"; | ||
| return "CREATE INDEX " + idxName + " ON " + tableName + " (" + def.index.columns.map(function (item) { return "[" + item.name + "] " + item.orderBy; }).join(", ") + ")"; | ||
| }; | ||
| QueryBuilder.configIdentityInsert = function (def) { | ||
| var tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return "SET IDENTITY_INSERT " + tableName + " " + def.state.toUpperCase(); | ||
| }; | ||
| QueryBuilder.query = function (def) { | ||
| } | ||
| static removeForeignKey(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| const tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| const fkName = `[FK_${tableNameChain.join("_")}_${def.foreignKey}]`; | ||
| return `ALTER TABLE ${tableName} DROP CONSTRAINT ${fkName}`; | ||
| } | ||
| static createIndex(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| const tableNameChain = QueryUtil_1.QueryUtil.getTableNameChain(def.table); | ||
| const idxName = `[IDX_${tableNameChain.join("_")}_${def.index.name}]`; | ||
| return `CREATE INDEX ${idxName} ON ${tableName} (${def.index.columns.map((item) => `[${item.name}] ${item.orderBy}`).join(", ")})`; | ||
| } | ||
| static configIdentityInsert(def) { | ||
| const tableName = QueryUtil_1.QueryUtil.getTableName(def.table); | ||
| return `SET IDENTITY_INSERT ${tableName} ${def.state.toUpperCase()}`; | ||
| } | ||
| static query(def) { | ||
| return QueryBuilder[def.type](def); | ||
| }; | ||
| QueryBuilder.getQueryOfQueryValue = function (queryValue) { | ||
| } | ||
| static getQueryOfQueryValue(queryValue) { | ||
| var _a, _b, _c; | ||
@@ -323,25 +354,24 @@ if (queryValue === undefined) { | ||
| else if (queryValue instanceof Buffer) { | ||
| return "0x" + queryValue.toString("hex"); | ||
| return `0x${queryValue.toString("hex")}`; | ||
| } | ||
| else if (queryValue instanceof Array) { | ||
| return "(" + queryValue.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join("") + ")"; | ||
| return "(" + queryValue.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("") + ")"; | ||
| } | ||
| else if (queryValue["from"]) { | ||
| var subQuery = "(\n"; | ||
| let subQuery = `(\n`; | ||
| subQuery += " " + QueryBuilder.select(queryValue).replace(/\n/g, "\n ") + "\n"; | ||
| subQuery += ")"; | ||
| subQuery += `)`; | ||
| return subQuery; | ||
| } | ||
| else { | ||
| throw new TypeError((_c = (_b = (_a = queryValue) === null || _a === void 0 ? void 0 : _a["constructor"]) === null || _b === void 0 ? void 0 : _b["name"], (_c !== null && _c !== void 0 ? _c : typeof queryValue)) + ": " + queryValue + ": " + sd_core_common_1.JsonConvert.stringify(queryValue)); | ||
| throw new TypeError(`${_c = (_b = (_a = queryValue) === null || _a === void 0 ? void 0 : _a["constructor"]) === null || _b === void 0 ? void 0 : _b["name"], (_c !== null && _c !== void 0 ? _c : typeof queryValue)}: ${queryValue}: ${sd_core_common_1.JsonConvert.stringify(queryValue)}`); | ||
| } | ||
| }; | ||
| QueryBuilder._getQueryOfJoinDef = function (def) { | ||
| var q = ""; | ||
| if (Object.keys(def).every(function (key) { return !def[key] || ["where", "from", "as"].includes(key); })) { | ||
| } | ||
| static _getQueryOfJoinDef(def) { | ||
| let q = ""; | ||
| if (Object.keys(def).every((key) => !def[key] || ["where", "from", "as"].includes(key))) { | ||
| if (def.from instanceof Array) { | ||
| q += "LEFT OUTER JOIN (\n"; | ||
| for (var _i = 0, _a = def.from; _i < _a.length; _i++) { | ||
| var from = _a[_i]; | ||
| var fromQueryDef = from; | ||
| q += `LEFT OUTER JOIN (\n`; | ||
| for (const from of def.from) { | ||
| const fromQueryDef = from; | ||
| q += " " + QueryBuilder.select(fromQueryDef).replace(/\n/g, "\n "); | ||
@@ -351,15 +381,15 @@ q += "\n\n UNION ALL\n\n"; | ||
| q = q.slice(0, -14); | ||
| q += ") as " + def.as; | ||
| q += `) as ${def.as}`; | ||
| } | ||
| else if (def.from["from"]) { | ||
| var joinFromQueryDef = def.from; | ||
| q += "LEFT OUTER JOIN (\n"; | ||
| const joinFromQueryDef = def.from; | ||
| q += `LEFT OUTER JOIN (\n`; | ||
| q += " " + QueryBuilder.select(joinFromQueryDef).replace(/\n/g, "\n ") + "\n"; | ||
| q += ") as " + def.as; | ||
| q += `) as ${def.as}`; | ||
| } | ||
| else { | ||
| q += "LEFT OUTER JOIN " + def.from + " as " + def.as; | ||
| q += `LEFT OUTER JOIN ${def.from} as ${def.as}`; | ||
| } | ||
| if (def.where) { | ||
| q += " ON " + def.where.map(function (item) { return QueryBuilder.getQueryOfQueryValue(item); }).join(""); | ||
| q += ` ON ${def.where.map((item) => QueryBuilder.getQueryOfQueryValue(item)).join("")}`; | ||
| } | ||
@@ -371,3 +401,3 @@ } | ||
| } | ||
| var joinFullDef = def; | ||
| const joinFullDef = def; | ||
| q += "OUTER APPLY (\n"; | ||
@@ -378,5 +408,5 @@ q += " " + QueryBuilder.select(joinFullDef).replace(/\n/g, "\n ") + "\n"; | ||
| return q.trim(); | ||
| }; | ||
| QueryBuilder._getQueryOfColDef = function (colDef) { | ||
| var q = ""; | ||
| } | ||
| static _getQueryOfColDef(colDef) { | ||
| let q = ""; | ||
| q += "[" + colDef.name + "] "; | ||
@@ -387,6 +417,5 @@ q += colDef.dataType + " "; | ||
| return q; | ||
| }; | ||
| return QueryBuilder; | ||
| }()); | ||
| } | ||
| } | ||
| exports.QueryBuilder = QueryBuilder; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var QueryUnit = (function () { | ||
| function QueryUnit(type, _query) { | ||
| class QueryUnit { | ||
| constructor(type, _query) { | ||
| this.type = type; | ||
| this._query = _query; | ||
| } | ||
| Object.defineProperty(QueryUnit.prototype, "query", { | ||
| get: function () { | ||
| return this._query; | ||
| }, | ||
| enumerable: true, | ||
| configurable: true | ||
| }); | ||
| return QueryUnit; | ||
| }()); | ||
| get query() { | ||
| return this._query; | ||
| } | ||
| } | ||
| exports.QueryUnit = QueryUnit; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var QueryUtil_1 = require("../util/QueryUtil"); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var QueryUnit_1 = require("./QueryUnit"); | ||
| const QueryUtil_1 = require("../util/QueryUtil"); | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| const QueryUnit_1 = require("./QueryUnit"); | ||
| exports.sorm = { | ||
| equal: function (source, target) { | ||
| equal(source, target) { | ||
| if (target === undefined) { | ||
@@ -16,3 +15,3 @@ return exports.sorm.null(source); | ||
| }, | ||
| notEqual: function (source, target) { | ||
| notEqual(source, target) { | ||
| if (target === undefined) { | ||
@@ -25,21 +24,21 @@ return exports.sorm.notNull(source); | ||
| }, | ||
| null: function (source) { | ||
| null(source) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " IS ", "NULL"]; | ||
| }, | ||
| notNull: function (source) { | ||
| notNull(source) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " IS NOT ", "NULL"]; | ||
| }, | ||
| lessThen: function (source, target) { | ||
| lessThen(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " < ", QueryUtil_1.QueryUtil.getQueryValue(target)]; | ||
| }, | ||
| lessThenOrEqual: function (source, target) { | ||
| lessThenOrEqual(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " <= ", QueryUtil_1.QueryUtil.getQueryValue(target)]; | ||
| }, | ||
| greaterThen: function (source, target) { | ||
| greaterThen(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " > ", QueryUtil_1.QueryUtil.getQueryValue(target)]; | ||
| }, | ||
| greaterThenOrEqual: function (source, target) { | ||
| greaterThenOrEqual(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " >= ", QueryUtil_1.QueryUtil.getQueryValue(target)]; | ||
| }, | ||
| between: function (source, from, to) { | ||
| between(source, from, to) { | ||
| return exports.sorm.and([ | ||
@@ -50,12 +49,12 @@ exports.sorm.greaterThenOrEqual(source, from), | ||
| }, | ||
| includes: function (source, target) { | ||
| includes(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " LIKE ", "'%'", " + ", QueryUtil_1.QueryUtil.getQueryValue(target), " + ", "'%'"]; | ||
| }, | ||
| startsWith: function (source, target) { | ||
| startsWith(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " LIKE ", QueryUtil_1.QueryUtil.getQueryValue(target), " + ", "'%'"]; | ||
| }, | ||
| endsWith: function (source, target) { | ||
| endsWith(source, target) { | ||
| return [QueryUtil_1.QueryUtil.getQueryValue(source), " LIKE ", "'%'", " + ", QueryUtil_1.QueryUtil.getQueryValue(target)]; | ||
| }, | ||
| in: function (src, target) { | ||
| in(src, target) { | ||
| if (target.length < 1) { | ||
@@ -65,6 +64,6 @@ return [1, " = ", 0]; | ||
| else { | ||
| if (target.every(function (item) { return item === undefined; })) { | ||
| if (target.every((item) => item === undefined)) { | ||
| return exports.sorm.null(src); | ||
| } | ||
| var result = [QueryUtil_1.QueryUtil.getQueryValue(src), " IN ", target.filterExists().mapMany(function (item) { return [QueryUtil_1.QueryUtil.getQueryValue(item), ", "]; }).slice(0, -1)]; | ||
| const result = [QueryUtil_1.QueryUtil.getQueryValue(src), " IN ", target.filterExists().mapMany((item) => [QueryUtil_1.QueryUtil.getQueryValue(item), ", "]).slice(0, -1)]; | ||
| if (target.includes(undefined)) { | ||
@@ -79,3 +78,3 @@ return exports.sorm.or([ | ||
| }, | ||
| notIn: function (src, target) { | ||
| notIn(src, target) { | ||
| if (target.length < 1) { | ||
@@ -85,6 +84,6 @@ return [1, " = ", 1]; | ||
| else { | ||
| if (target.every(function (item) { return item === undefined; })) { | ||
| if (target.every((item) => item === undefined)) { | ||
| return exports.sorm.null(src); | ||
| } | ||
| var result = [QueryUtil_1.QueryUtil.getQueryValue(src), " NOT IN ", target.filterExists().mapMany(function (item) { return [QueryUtil_1.QueryUtil.getQueryValue(item), ", "]; }).slice(0, -1)]; | ||
| const result = [QueryUtil_1.QueryUtil.getQueryValue(src), " NOT IN ", target.filterExists().mapMany((item) => [QueryUtil_1.QueryUtil.getQueryValue(item), ", "]).slice(0, -1)]; | ||
| if (target.includes(undefined)) { | ||
@@ -99,9 +98,8 @@ return exports.sorm.and([ | ||
| }, | ||
| and: function (args) { | ||
| var result = []; | ||
| for (var _i = 0, args_1 = args; _i < args_1.length; _i++) { | ||
| var arg = args_1[_i]; | ||
| var queryValue = QueryUtil_1.QueryUtil.getQueryValue(arg); | ||
| and(args) { | ||
| const result = []; | ||
| for (const arg of args) { | ||
| const queryValue = QueryUtil_1.QueryUtil.getQueryValue(arg); | ||
| if (queryValue) { | ||
| result.push.apply(result, [queryValue, " AND "]); | ||
| result.push(...[queryValue, " AND "]); | ||
| } | ||
@@ -111,29 +109,23 @@ } | ||
| }, | ||
| or: function (args) { | ||
| var result = []; | ||
| for (var _i = 0, args_2 = args; _i < args_2.length; _i++) { | ||
| var arg = args_2[_i]; | ||
| var queryValue = QueryUtil_1.QueryUtil.getQueryValue(arg); | ||
| result.push.apply(result, [queryValue, " OR "]); | ||
| or(args) { | ||
| const result = []; | ||
| for (const arg of args) { | ||
| const queryValue = QueryUtil_1.QueryUtil.getQueryValue(arg); | ||
| result.push(...[queryValue, " OR "]); | ||
| } | ||
| return result.slice(0, -1); | ||
| }, | ||
| is: function (where) { | ||
| is(where) { | ||
| return exports.sorm.case(where, true).else(false); | ||
| }, | ||
| dateDiff: function (separator, from, to) { | ||
| dateDiff(separator, from, to) { | ||
| return new QueryUnit_1.QueryUnit(Number, ["DATEDIFF(", separator, ", ", QueryUtil_1.QueryUtil.getQueryValue(from), ", ", QueryUtil_1.QueryUtil.getQueryValue(to), ")"]); | ||
| }, | ||
| dateAdd: function (separator, from, value) { | ||
| dateAdd(separator, from, value) { | ||
| return new QueryUnit_1.QueryUnit(sd_core_common_1.DateOnly, ["DATEADD(", separator, ", ", QueryUtil_1.QueryUtil.getQueryValue(value), ", ", QueryUtil_1.QueryUtil.getQueryValue(from), ")"]); | ||
| }, | ||
| ifNull: function (source) { | ||
| var targets = []; | ||
| for (var _i = 1; _i < arguments.length; _i++) { | ||
| targets[_i - 1] = arguments[_i]; | ||
| } | ||
| var cursorQuery = QueryUtil_1.QueryUtil.getQueryValue(source); | ||
| var type = QueryUtil_1.QueryUtil.getQueryValueType(source); | ||
| for (var _a = 0, targets_1 = targets; _a < targets_1.length; _a++) { | ||
| var target = targets_1[_a]; | ||
| ifNull(source, ...targets) { | ||
| let cursorQuery = QueryUtil_1.QueryUtil.getQueryValue(source); | ||
| let type = QueryUtil_1.QueryUtil.getQueryValueType(source); | ||
| for (const target of targets) { | ||
| cursorQuery = ["ISNULL(", cursorQuery, ", ", QueryUtil_1.QueryUtil.getQueryValue(target), ")"]; | ||
@@ -144,23 +136,23 @@ type = (type !== null && type !== void 0 ? type : QueryUtil_1.QueryUtil.getQueryValueType(target)); | ||
| }, | ||
| case: function (predicate, then) { | ||
| var type = QueryUtil_1.QueryUtil.getQueryValueType(then); | ||
| var caseQueryable = new CaseQueryable(type); | ||
| case(predicate, then) { | ||
| const type = QueryUtil_1.QueryUtil.getQueryValueType(then); | ||
| const caseQueryable = new CaseQueryable(type); | ||
| return caseQueryable.case(predicate, then); | ||
| }, | ||
| dataLength: function (arg) { | ||
| dataLength(arg) { | ||
| return new QueryUnit_1.QueryUnit(Number, ["DATALENGTH(", QueryUtil_1.QueryUtil.getQueryValue(arg), ")"]); | ||
| }, | ||
| stringLength: function (arg) { | ||
| stringLength(arg) { | ||
| return new QueryUnit_1.QueryUnit(Number, ["LEN(", QueryUtil_1.QueryUtil.getQueryValue(arg), ")"]); | ||
| }, | ||
| cast: function (src, targetType) { | ||
| cast(src, targetType) { | ||
| return new QueryUnit_1.QueryUnit(targetType, ["CONVERT(", QueryUtil_1.QueryUtil.getDataType(targetType), ", ", QueryUtil_1.QueryUtil.getQueryValue(src), ")"]); | ||
| }, | ||
| left: function (src, num) { | ||
| left(src, num) { | ||
| return new QueryUnit_1.QueryUnit(String, ["LEFT(", QueryUtil_1.QueryUtil.getQueryValue(src), ", ", QueryUtil_1.QueryUtil.getQueryValue(num), ")"]); | ||
| }, | ||
| right: function (src, num) { | ||
| right(src, num) { | ||
| return new QueryUnit_1.QueryUnit(String, ["RIGHT(", QueryUtil_1.QueryUtil.getQueryValue(src), ", ", QueryUtil_1.QueryUtil.getQueryValue(num), ")"]); | ||
| }, | ||
| replace: function (src, from, to) { | ||
| replace(src, from, to) { | ||
| return new QueryUnit_1.QueryUnit(String, [ | ||
@@ -174,3 +166,3 @@ "REPLACE(", | ||
| }, | ||
| count: function (arg) { | ||
| count(arg) { | ||
| if (arg) { | ||
@@ -183,7 +175,7 @@ return new QueryUnit_1.QueryUnit(Number, ["COUNT(DISTINCT(", QueryUtil_1.QueryUtil.getQueryValue(arg), "))"]); | ||
| }, | ||
| sum: function (arg) { | ||
| sum(arg) { | ||
| return new QueryUnit_1.QueryUnit(Number, ["SUM(", QueryUtil_1.QueryUtil.getQueryValue(arg), ")"]); | ||
| }, | ||
| max: function (unit) { | ||
| var type = QueryUtil_1.QueryUtil.getQueryValueType(unit); | ||
| max(unit) { | ||
| const type = QueryUtil_1.QueryUtil.getQueryValueType(unit); | ||
| if (!type) { | ||
@@ -194,4 +186,4 @@ throw new TypeError(); | ||
| }, | ||
| min: function (unit) { | ||
| var type = QueryUtil_1.QueryUtil.getQueryValueType(unit); | ||
| min(unit) { | ||
| const type = QueryUtil_1.QueryUtil.getQueryValueType(unit); | ||
| if (!type) { | ||
@@ -202,27 +194,25 @@ throw new TypeError(); | ||
| }, | ||
| exists: function (arg) { | ||
| exists(arg) { | ||
| return exports.sorm.case(exports.sorm.greaterThen(exports.sorm.ifNull(exports.sorm.count(arg), 0), 0), true).else(false); | ||
| }, | ||
| notExists: function (arg) { | ||
| notExists(arg) { | ||
| return exports.sorm.case(exports.sorm.lessThenOrEqual(exports.sorm.ifNull(exports.sorm.count(arg), 0), 0), true).else(false); | ||
| } | ||
| }; | ||
| var CaseQueryable = (function () { | ||
| function CaseQueryable(_type) { | ||
| class CaseQueryable { | ||
| constructor(_type) { | ||
| this._type = _type; | ||
| this._cases = []; | ||
| } | ||
| CaseQueryable.prototype.case = function (predicate, then) { | ||
| var _a; | ||
| case(predicate, then) { | ||
| this._type = QueryUtil_1.QueryUtil.getQueryValueType(then); | ||
| (_a = this._cases).push.apply(_a, [" WHEN ", QueryUtil_1.QueryUtil.getQueryValue(predicate), " THEN ", QueryUtil_1.QueryUtil.getQueryValue(then)]); | ||
| this._cases.push(...[" WHEN ", QueryUtil_1.QueryUtil.getQueryValue(predicate), " THEN ", QueryUtil_1.QueryUtil.getQueryValue(then)]); | ||
| return this; | ||
| }; | ||
| CaseQueryable.prototype.else = function (then) { | ||
| } | ||
| else(then) { | ||
| this._type = QueryUtil_1.QueryUtil.getQueryValueType(then); | ||
| return new QueryUnit_1.QueryUnit(this._type, tslib_1.__spreadArrays(["CASE "], this._cases, [" ELSE ", QueryUtil_1.QueryUtil.getQueryValue(then), " END"])); | ||
| }; | ||
| return CaseQueryable; | ||
| }()); | ||
| return new QueryUnit_1.QueryUnit(this._type, ["CASE ", ...this._cases, " ELSE ", QueryUtil_1.QueryUtil.getQueryValue(then), " END"]); | ||
| } | ||
| } | ||
| exports.CaseQueryable = CaseQueryable; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var DbDefinitionUtil = (function () { | ||
| function DbDefinitionUtil() { | ||
| } | ||
| DbDefinitionUtil.getTableDef = function (tableType, throws) { | ||
| if (throws === void 0) { throws = true; } | ||
| var tableDef = Reflect.getMetadata(DbDefinitionUtil._tableDefMetadataKey, tableType); | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| class DbDefinitionUtil { | ||
| static getTableDef(tableType, throws = true) { | ||
| const tableDef = Reflect.getMetadata(DbDefinitionUtil._tableDefMetadataKey, tableType); | ||
| if (throws && !tableDef) { | ||
| throw new Error("'" + tableType.name + "'\uC5D0 '@Table()'\uC774 \uC9C0\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."); | ||
| throw new Error(`'${tableType.name}'에 '@Table()'이 지정되지 않았습니다.`); | ||
| } | ||
@@ -21,29 +18,29 @@ return (tableDef !== null && tableDef !== void 0 ? tableDef : { | ||
| }); | ||
| }; | ||
| DbDefinitionUtil.setTableDef = function (tableType, tableDef) { | ||
| } | ||
| static setTableDef(tableType, tableDef) { | ||
| Reflect.defineMetadata(DbDefinitionUtil._tableDefMetadataKey, tableDef, tableType); | ||
| }; | ||
| DbDefinitionUtil.mergeTableDef = function (tableType, target) { | ||
| var tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| } | ||
| static mergeTableDef(tableType, target) { | ||
| let tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| tableDef = sd_core_common_1.ObjectUtil.merge(tableDef, target); | ||
| DbDefinitionUtil.setTableDef(tableType, tableDef); | ||
| }; | ||
| DbDefinitionUtil.addColumnDef = function (tableType, def) { | ||
| var tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| } | ||
| static addColumnDef(tableType, def) { | ||
| const tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| tableDef.columns = tableDef.columns.merge([def], { keys: ["propertyKey"] }); | ||
| DbDefinitionUtil.setTableDef(tableType, tableDef); | ||
| }; | ||
| DbDefinitionUtil.addForeignKeyDef = function (tableType, def) { | ||
| var tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| } | ||
| static addForeignKeyDef(tableType, def) { | ||
| const tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| tableDef.foreignKeys = tableDef.foreignKeys.merge([def], { keys: ["propertyKey"] }); | ||
| DbDefinitionUtil.setTableDef(tableType, tableDef); | ||
| }; | ||
| DbDefinitionUtil.addForeignKeyTargetDef = function (tableType, def) { | ||
| var tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| } | ||
| static addForeignKeyTargetDef(tableType, def) { | ||
| const tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| tableDef.foreignKeyTargets = tableDef.foreignKeyTargets.merge([def], { keys: ["propertyKey"] }); | ||
| DbDefinitionUtil.setTableDef(tableType, tableDef); | ||
| }; | ||
| DbDefinitionUtil.addIndexDef = function (tableType, def) { | ||
| var tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| var prevIndexDef = tableDef.indexes.single(function (item) { return item.name === def.name; }); | ||
| } | ||
| static addIndexDef(tableType, def) { | ||
| const tableDef = DbDefinitionUtil.getTableDef(tableType, false); | ||
| const prevIndexDef = tableDef.indexes.single((item) => item.name === def.name); | ||
| if (!prevIndexDef) { | ||
@@ -57,7 +54,6 @@ tableDef.indexes.push(def); | ||
| DbDefinitionUtil.setTableDef(tableType, tableDef); | ||
| }; | ||
| DbDefinitionUtil._tableDefMetadataKey = "sd-orm-table-def"; | ||
| return DbDefinitionUtil; | ||
| }()); | ||
| } | ||
| } | ||
| exports.DbDefinitionUtil = DbDefinitionUtil; | ||
| DbDefinitionUtil._tableDefMetadataKey = "sd-orm-table-def"; | ||
| //# sourceMappingURL=module.js.map |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| var tslib_1 = require("tslib"); | ||
| var QueryUnit_1 = require("../query/QueryUnit"); | ||
| var sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| var Queryable_1 = require("../query/Queryable"); | ||
| var QueryUtil = (function () { | ||
| function QueryUtil() { | ||
| } | ||
| QueryUtil.getTableNameChain = function (def) { | ||
| const QueryUnit_1 = require("../query/QueryUnit"); | ||
| const sd_core_common_1 = require("@simplysm/sd-core-common"); | ||
| const Queryable_1 = require("../query/Queryable"); | ||
| class QueryUtil { | ||
| static getTableNameChain(def) { | ||
| var _a; | ||
@@ -21,7 +18,7 @@ if (def.database) { | ||
| } | ||
| }; | ||
| QueryUtil.getTableName = function (def) { | ||
| return QueryUtil.getTableNameChain(def).map(function (item) { return "[" + item + "]"; }).join("."); | ||
| }; | ||
| QueryUtil.getQueryValue = function (value) { | ||
| } | ||
| static getTableName(def) { | ||
| return QueryUtil.getTableNameChain(def).map((item) => `[${item}]`).join("."); | ||
| } | ||
| static getQueryValue(value) { | ||
| if (value instanceof QueryUnit_1.QueryUnit) { | ||
@@ -42,6 +39,6 @@ if (value.query instanceof Array) { | ||
| else if (typeof value === "string") { | ||
| return "N'" + value + "'"; | ||
| return `N'${value}'`; | ||
| } | ||
| else if (value instanceof Queryable_1.Queryable) { | ||
| var selectDef = value.getSelectDef(); | ||
| const selectDef = value.getSelectDef(); | ||
| if (selectDef.top !== 1) { | ||
@@ -58,5 +55,5 @@ throw new Error("하나의 필드를 추출하기 위한 내부쿼리에서는 반드시 TOP 1 이 지정 되야 합니다."); | ||
| } | ||
| }; | ||
| QueryUtil.getQueryValueArray = function (arr) { | ||
| return arr.map(function (item) { | ||
| } | ||
| static getQueryValueArray(arr) { | ||
| return arr.map((item) => { | ||
| if (item instanceof Array) { | ||
@@ -75,4 +72,4 @@ return QueryUtil.getQueryValueArray(item); | ||
| }); | ||
| }; | ||
| QueryUtil.canGetQueryValue = function (value) { | ||
| } | ||
| static canGetQueryValue(value) { | ||
| return ["undefined", "boolean", "number", "string"].includes(typeof value) || | ||
@@ -88,4 +85,4 @@ value instanceof QueryUnit_1.QueryUnit || | ||
| value instanceof Buffer; | ||
| }; | ||
| QueryUtil.getQueryValueType = function (value) { | ||
| } | ||
| static getQueryValueType(value) { | ||
| if (value instanceof QueryUnit_1.QueryUnit) { | ||
@@ -121,4 +118,4 @@ return value.type; | ||
| } | ||
| }; | ||
| QueryUtil.getDataType = function (type) { | ||
| } | ||
| static getDataType(type) { | ||
| switch (type) { | ||
@@ -144,10 +141,9 @@ case String: | ||
| } | ||
| }; | ||
| QueryUtil.parseQueryResult = function (orgResults, option) { | ||
| } | ||
| static parseQueryResult(orgResults, option) { | ||
| var _a; | ||
| var result = orgResults.map(function (item) { | ||
| let result = orgResults.map((item) => { | ||
| var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q; | ||
| var obj = {}; | ||
| for (var _i = 0, _r = Object.keys(item); _i < _r.length; _i++) { | ||
| var key = _r[_i]; | ||
| const obj = {}; | ||
| for (const key of Object.keys(item)) { | ||
| if (item[key] == undefined) { | ||
@@ -177,16 +173,14 @@ } | ||
| if (((_a = option) === null || _a === void 0 ? void 0 : _a.joins) && Object.keys(option.joins).length > 0) { | ||
| var joinKeys = Object.keys(option.joins).orderByDesc(function (key) { return key.length; }); | ||
| var _loop_1 = function (joinKey) { | ||
| var grouped = []; | ||
| var _loop_2 = function (item) { | ||
| var keyObjKeys = Object.keys(item).filter(function (key) { return !key.startsWith(joinKey + "."); }); | ||
| var keyObj = {}; | ||
| for (var _i = 0, keyObjKeys_1 = keyObjKeys; _i < keyObjKeys_1.length; _i++) { | ||
| var keyObjKey = keyObjKeys_1[_i]; | ||
| const joinKeys = Object.keys(option.joins).orderByDesc((key) => key.length); | ||
| for (const joinKey of joinKeys) { | ||
| const grouped = []; | ||
| for (const item of result) { | ||
| const keyObjKeys = Object.keys(item).filter((key) => !key.startsWith(joinKey + ".")); | ||
| const keyObj = {}; | ||
| for (const keyObjKey of keyObjKeys) { | ||
| keyObj[keyObjKey] = item[keyObjKey]; | ||
| } | ||
| var valueObjKeys = Object.keys(item).filter(function (key) { return key.startsWith(joinKey + "."); }); | ||
| var valueObj = {}; | ||
| for (var _a = 0, valueObjKeys_1 = valueObjKeys; _a < valueObjKeys_1.length; _a++) { | ||
| var valueObjKey = valueObjKeys_1[_a]; | ||
| const valueObjKeys = Object.keys(item).filter((key) => key.startsWith(joinKey + ".")); | ||
| const valueObj = {}; | ||
| for (const valueObjKey of valueObjKeys) { | ||
| valueObj[valueObjKey.slice(joinKey.length + 1)] = item[valueObjKey]; | ||
@@ -198,3 +192,3 @@ } | ||
| else { | ||
| var existsRecord = grouped.single(function (item1) { return sd_core_common_1.ObjectUtil.equal(item1.key, keyObj); }); | ||
| const existsRecord = grouped.single((item1) => sd_core_common_1.ObjectUtil.equal(item1.key, keyObj)); | ||
| if (existsRecord) { | ||
@@ -207,34 +201,28 @@ existsRecord.values.push(valueObj); | ||
| } | ||
| }; | ||
| for (var _i = 0, result_1 = result; _i < result_1.length; _i++) { | ||
| var item = result_1[_i]; | ||
| _loop_2(item); | ||
| } | ||
| result = grouped.map(function (item) { | ||
| var _a, _b; | ||
| result = grouped.map((item) => { | ||
| if (item.values instanceof Array) { | ||
| return tslib_1.__assign(tslib_1.__assign({}, item.key), (_a = {}, _a[joinKey] = item.values | ||
| .filter(function (item1) { | ||
| return Object.keys(item1) | ||
| .filter(function (key) { return !(item1[key] instanceof Array) || item1[key].length > 0; }) | ||
| .length > 0; | ||
| }), _a)); | ||
| return { | ||
| ...item.key, | ||
| [joinKey]: item.values | ||
| .filter((item1) => Object.keys(item1) | ||
| .filter((key) => !(item1[key] instanceof Array) || item1[key].length > 0) | ||
| .length > 0) | ||
| }; | ||
| } | ||
| else { | ||
| return tslib_1.__assign(tslib_1.__assign({}, item.key), Object.keys(item.values).length > 0 ? (_b = {}, | ||
| _b[joinKey] = item.values, | ||
| _b) : {}); | ||
| return { | ||
| ...item.key, | ||
| ...Object.keys(item.values).length > 0 ? { | ||
| [joinKey]: item.values | ||
| } : {} | ||
| }; | ||
| } | ||
| }); | ||
| }; | ||
| for (var _i = 0, joinKeys_1 = joinKeys; _i < joinKeys_1.length; _i++) { | ||
| var joinKey = joinKeys_1[_i]; | ||
| _loop_1(joinKey); | ||
| } | ||
| } | ||
| return result; | ||
| }; | ||
| return QueryUtil; | ||
| }()); | ||
| } | ||
| } | ||
| exports.QueryUtil = QueryUtil; | ||
| //# sourceMappingURL=module.js.map |
| { | ||
| "name": "@simplysm/sd-orm-common", | ||
| "version": "3.1.136", | ||
| "version": "3.1.137", | ||
| "description": "심플리즘 패키지 - ORM 모듈 (browser/node)", | ||
@@ -13,3 +13,3 @@ "author": "김석래", | ||
| "dependencies": { | ||
| "@simplysm/sd-core-common": "3.1.136" | ||
| "@simplysm/sd-core-common": "3.1.137" | ||
| }, | ||
@@ -16,0 +16,0 @@ "devDependencies": { |
@@ -10,3 +10,6 @@ { | ||
| }, | ||
| "files": [ | ||
| "src/index.ts" | ||
| ], | ||
| "compileOnSave": false | ||
| } |
@@ -9,3 +9,6 @@ { | ||
| "declaration": false | ||
| } | ||
| }, | ||
| "files": [ | ||
| "src/index.ts" | ||
| ] | ||
| } |
@@ -17,3 +17,6 @@ { | ||
| }, | ||
| "files": [ | ||
| "src/index.ts" | ||
| ], | ||
| "compileOnSave": false | ||
| } |
@@ -16,3 +16,6 @@ { | ||
| } | ||
| } | ||
| }, | ||
| "files": [ | ||
| "src/index.ts" | ||
| ] | ||
| } |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Uses eval
Supply chain riskPackage uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by117.42%
712553
- Lines of code
- increased by68.65%
9350
Worsened metrics
- Number of medium supply chain risk alerts
- increased byInfinity%
1
Dependency changes
+ Added@simplysm/sd-core-common@3.1.137(transitive)
- Removed@simplysm/sd-core-common@3.1.136(transitive)