remult 0.14.6 → 0.14.7

package/src/data-providers/sql-database.js

@@ -1,173 +1,283 @@
-import { CompoundIdField } from "../column";
-import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
-import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
-import { Sort } from '../sort';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDatabase = void 0;
+var tslib_1 = require("tslib");
+var column_1 = require("../column");
+var filter_consumer_bridge_to_sql_request_1 = require("../filter/filter-consumer-bridge-to-sql-request");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var sort_1 = require("../sort");
 // @dynamic
-export class SqlDatabase {
-    constructor(sql) {
+var SqlDatabase = /** @class */ (function () {
+    function SqlDatabase(sql) {
         this.sql = sql;
         this.createdEntities = [];
     }
-    createCommand() {
+    SqlDatabase.prototype.createCommand = function () {
         return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
-    }
-    async execute(sql) {
-        return await this.createCommand().execute(sql);
-    }
-    getEntityDataProvider(entity) {
-        return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
-            if (this.createdEntities.indexOf(dbName.entityName) < 0) {
-                this.createdEntities.push(dbName.entityName);
-                await this.sql.entityIsUsedForTheFirstTime(entity);
-            }
-        }, this.sql);
-    }
-    transaction(action) {
-        return this.sql.transaction(async (x) => {
-            let completed = false;
-            try {
-                await action(new SqlDatabase({
-                    createCommand: () => {
-                        let c = x.createCommand();
-                        return {
-                            addParameterAndReturnSqlToken: x => c.addParameterAndReturnSqlToken(x),
-                            execute: async (sql) => {
-                                if (completed)
-                                    throw "can't run a command after the transaction was completed";
-                                return c.execute(sql);
-                            }
-                        };
-                    },
-                    getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
-                    entityIsUsedForTheFirstTime: y => x.entityIsUsedForTheFirstTime(y),
-                    transaction: z => x.transaction(z),
-                }));
-            }
-            finally {
-                completed = true;
-            }
+    };
+    SqlDatabase.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createCommand().execute(sql)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
         });
-    }
-    static customFilter(build) {
-        return {
-            [customDatabaseFilterToken]: {
+    };
+    SqlDatabase.prototype.getEntityDataProvider = function (entity) {
+        var _this = this;
+        return new ActualSQLServerDataProvider(entity, this, function (dbName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.createdEntities.indexOf(dbName.entityName) < 0)) return [3 /*break*/, 2];
+                        this.createdEntities.push(dbName.entityName);
+                        return [4 /*yield*/, this.sql.entityIsUsedForTheFirstTime(entity)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); }, this.sql);
+    };
+    SqlDatabase.prototype.transaction = function (action) {
+        var _this = this;
+        return this.sql.transaction(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var completed;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        completed = false;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        return [4 /*yield*/, action(new SqlDatabase({
+                                createCommand: function () {
+                                    var c = x.createCommand();
+                                    return {
+                                        addParameterAndReturnSqlToken: function (x) { return c.addParameterAndReturnSqlToken(x); },
+                                        execute: function (sql) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            return tslib_1.__generator(this, function (_a) {
+                                                if (completed)
+                                                    throw "can't run a command after the transaction was completed";
+                                                return [2 /*return*/, c.execute(sql)];
+                                            });
+                                        }); }
+                                    };
+                                },
+                                getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
+                                entityIsUsedForTheFirstTime: function (y) { return x.entityIsUsedForTheFirstTime(y); },
+                                transaction: function (z) { return x.transaction(z); },
+                            }))];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        completed = true;
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    SqlDatabase.customFilter = function (build) {
+        var _a;
+        return _a = {},
+            _a[filter_interfaces_1.customDatabaseFilterToken] = {
                 buildSql: build
-            }
-        };
-    }
-}
-SqlDatabase.LogToConsole = false;
-SqlDatabase.durationThreshold = 0;
-class LogSQLCommand {
-    constructor(origin, allQueries) {
+            },
+            _a;
+    };
+    SqlDatabase.LogToConsole = false;
+    SqlDatabase.durationThreshold = 0;
+    return SqlDatabase;
+}());
+exports.SqlDatabase = SqlDatabase;
+var LogSQLCommand = /** @class */ (function () {
+    function LogSQLCommand(origin, allQueries) {
         this.origin = origin;
         this.allQueries = allQueries;
         this.args = {};
     }
-    addParameterAndReturnSqlToken(val) {
-        let r = this.origin.addParameterAndReturnSqlToken(val);
+    LogSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+        var r = this.origin.addParameterAndReturnSqlToken(val);
         this.args[r] = val;
         return r;
-    }
-    async execute(sql) {
-        try {
-            let start = new Date();
-            let r = await this.origin.execute(sql);
-            if (this.allQueries) {
-                var d = new Date().valueOf() - start.valueOf();
-                if (d > SqlDatabase.durationThreshold) {
-                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+    };
+    LogSQLCommand.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var start, r, d, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        start = new Date();
+                        return [4 /*yield*/, this.origin.execute(sql)];
+                    case 1:
+                        r = _a.sent();
+                        if (this.allQueries) {
+                            d = new Date().valueOf() - start.valueOf();
+                            if (d > SqlDatabase.durationThreshold) {
+                                console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+                            }
+                        }
+                        return [2 /*return*/, r];
+                    case 2:
+                        err_1 = _a.sent();
+                        console.error({ error: err_1, query: sql, arguments: this.args });
+                        throw err_1;
+                    case 3: return [2 /*return*/];
                 }
-            }
-            return r;
-        }
-        catch (err) {
-            console.error({ error: err, query: sql, arguments: this.args });
-            throw err;
-        }
-    }
-}
-class ActualSQLServerDataProvider {
-    constructor(entity, sql, iAmUsed, strategy) {
+            });
+        });
+    };
+    return LogSQLCommand;
+}());
+var ActualSQLServerDataProvider = /** @class */ (function () {
+    function ActualSQLServerDataProvider(entity, sql, iAmUsed, strategy) {
         this.entity = entity;
         this.sql = sql;
         this.iAmUsed = iAmUsed;
         this.strategy = strategy;
     }
-    async init() {
-        let dbNameProvider = await getDbNameProvider(this.entity);
-        await this.iAmUsed(dbNameProvider);
-        return dbNameProvider;
-    }
-    async count(where) {
-        let e = await this.init();
-        let select = 'select count(*) count from ' + e.entityName;
-        let r = this.sql.createCommand();
-        if (where) {
-            let wc = new FilterConsumerBridgeToSqlRequest(r, e);
-            where.__applyToConsumer(wc);
-            select += await wc.resolveWhere();
-        }
-        return r.execute(select).then(r => {
-            return +r.rows[0].count;
+    ActualSQLServerDataProvider.prototype.init = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var dbNameProvider;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(this.entity)];
+                    case 1:
+                        dbNameProvider = _a.sent();
+                        return [4 /*yield*/, this.iAmUsed(dbNameProvider)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, dbNameProvider];
+                }
+            });
         });
-    }
-    async find(options) {
-        let e = await this.init();
-        let { colKeys, select } = this.buildSelect(e);
-        select = 'select ' + select;
-        select += '\n from ' + e.entityName;
-        let r = this.sql.createCommand();
-        if (options) {
-            if (options.where) {
-                let where = new FilterConsumerBridgeToSqlRequest(r, e);
-                options.where.__applyToConsumer(where);
-                select += await where.resolveWhere();
-            }
-            if (options.limit) {
-                options.orderBy = Sort.createUniqueSort(this.entity, options.orderBy);
-            }
-            if (options.orderBy) {
-                let first = true;
-                let segs = [];
-                for (const s of options.orderBy.Segments) {
-                    if (s.field instanceof CompoundIdField) {
-                        segs.push(...s.field.fields.map(c => ({ field: c, isDescending: s.isDescending })));
-                    }
-                    else
-                        segs.push(s);
+    };
+    ActualSQLServerDataProvider.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, select, r, wc, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.init()];
+                    case 1:
+                        e = _b.sent();
+                        select = 'select count(*) count from ' + e.entityName;
+                        r = this.sql.createCommand();
+                        if (!where) return [3 /*break*/, 3];
+                        wc = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
+                        where.__applyToConsumer(wc);
+                        _a = select;
+                        return [4 /*yield*/, wc.resolveWhere()];
+                    case 2:
+                        select = _a + _b.sent();
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, r.execute(select).then(function (r) {
+                            return +r.rows[0].count;
+                        })];
                 }
-                for (const c of segs) {
-                    if (first) {
-                        select += ' Order By ';
-                        first = false;
-                    }
-                    else
-                        select += ', ';
-                    select += e.nameOf(c.field);
-                    if (c.isDescending)
-                        select += ' desc';
+            });
+        });
+    };
+    ActualSQLServerDataProvider.prototype.find = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, _a, colKeys, select, r, where, _b, first, segs, _loop_1, _c, _d, s, segs_1, segs_1_1, c, page;
+            var e_1, _e, e_2, _f;
+            var _this = this;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0: return [4 /*yield*/, this.init()];
+                    case 1:
+                        e = _g.sent();
+                        _a = this.buildSelect(e), colKeys = _a.colKeys, select = _a.select;
+                        select = 'select ' + select;
+                        select += '\n from ' + e.entityName;
+                        r = this.sql.createCommand();
+                        if (!options) return [3 /*break*/, 4];
+                        if (!options.where) return [3 /*break*/, 3];
+                        where = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
+                        options.where.__applyToConsumer(where);
+                        _b = select;
+                        return [4 /*yield*/, where.resolveWhere()];
+                    case 2:
+                        select = _b + _g.sent();
+                        _g.label = 3;
+                    case 3:
+                        if (options.limit) {
+                            options.orderBy = sort_1.Sort.createUniqueSort(this.entity, options.orderBy);
+                        }
+                        if (options.orderBy) {
+                            first = true;
+                            segs = [];
+                            _loop_1 = function (s) {
+                                if (s.field instanceof column_1.CompoundIdField) {
+                                    segs.push.apply(segs, tslib_1.__spread(s.field.fields.map(function (c) { return ({ field: c, isDescending: s.isDescending }); })));
+                                }
+                                else
+                                    segs.push(s);
+                            };
+                            try {
+                                for (_c = tslib_1.__values(options.orderBy.Segments), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                    s = _d.value;
+                                    _loop_1(s);
+                                }
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                            }
+                            try {
+                                for (segs_1 = tslib_1.__values(segs), segs_1_1 = segs_1.next(); !segs_1_1.done; segs_1_1 = segs_1.next()) {
+                                    c = segs_1_1.value;
+                                    if (first) {
+                                        select += ' Order By ';
+                                        first = false;
+                                    }
+                                    else
+                                        select += ', ';
+                                    select += e.nameOf(c.field);
+                                    if (c.isDescending)
+                                        select += ' desc';
+                                }
+                            }
+                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                            finally {
+                                try {
+                                    if (segs_1_1 && !segs_1_1.done && (_f = segs_1.return)) _f.call(segs_1);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                            }
+                        }
+                        if (options.limit) {
+                            page = 1;
+                            if (options.page)
+                                page = options.page;
+                            if (page < 1)
+                                page = 1;
+                            select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
+                        }
+                        _g.label = 4;
+                    case 4: return [2 /*return*/, r.execute(select).then(function (r) {
+                            return r.rows.map(function (y) {
+                                return _this.buildResultRow(colKeys, y, r);
+                            });
+                        })];
                 }
-            }
-            if (options.limit) {
-                let page = 1;
-                if (options.page)
-                    page = options.page;
-                if (page < 1)
-                    page = 1;
-                select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
-            }
-        }
-        return r.execute(select).then(r => {
-            return r.rows.map(y => {
-                return this.buildResultRow(colKeys, y, r);
             });
         });
-    }
-    buildResultRow(colKeys, y, r) {
-        let result = {};
-        for (let index = 0; index < colKeys.length; index++) {
-            const col = colKeys[index];
+    };
+    ActualSQLServerDataProvider.prototype.buildResultRow = function (colKeys, y, r) {
+        var result = {};
+        for (var index = 0; index < colKeys.length; index++) {
+            var col = colKeys[index];
             try {
                 result[col.key] = col.valueConverter.fromDb(y[r.getColumnKeyInResultForIndexInSelect(index)]);
             }
@@ -176,86 +286,156 @@ class ActualSQLServerDataProvider {
             }
         }
         return result;
-    }
-    buildSelect(e) {
-        let select = '';
-        let colKeys = [];
-        for (const x of this.entity.fields) {
-            if (x.isServerExpression) {
-            }
-            else {
-                if (colKeys.length > 0)
-                    select += ', ';
-                select += e.nameOf(x);
-                colKeys.push(x);
+    };
+    ActualSQLServerDataProvider.prototype.buildSelect = function (e) {
+        var e_3, _a;
+        var select = '';
+        var colKeys = [];
+        try {
+            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var x = _c.value;
+                if (x.isServerExpression) {
+                }
+                else {
+                    if (colKeys.length > 0)
+                        select += ', ';
+                    select += e.nameOf(x);
+                    colKeys.push(x);
+                }
             }
         }
-        return { colKeys, select };
-    }
-    async update(id, data) {
-        let e = await this.init();
-        let r = this.sql.createCommand();
-        let f = new FilterConsumerBridgeToSqlRequest(r, e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'update ' + e.entityName + ' set ';
-        let added = false;
-        for (const x of this.entity.fields) {
-            if (x instanceof CompoundIdField) {
-            }
-            if (e.isDbReadonly(x)) { }
-            else if (data[x.key] !== undefined) {
-                let v = x.valueConverter.toDb(data[x.key]);
-                if (v !== undefined) {
-                    if (!added)
-                        added = true;
-                    else
-                        statement += ', ';
-                    statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
-                }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_3) throw e_3.error; }
         }
-        statement += await f.resolveWhere();
-        let { colKeys, select } = this.buildSelect(e);
-        statement += ' returning ' + select;
-        return r.execute(statement).then(sqlResult => {
-            return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
+        return { colKeys: colKeys, select: select };
+    };
+    ActualSQLServerDataProvider.prototype.update = function (id, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, r, f, statement, added, _a, _b, x, v, _c, _d, colKeys, select;
+            var e_4, _e;
+            var _this = this;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.init()];
+                    case 1:
+                        e = _f.sent();
+                        r = this.sql.createCommand();
+                        f = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
+                        filter_interfaces_1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+                        statement = 'update ' + e.entityName + ' set ';
+                        added = false;
+                        try {
+                            for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                x = _b.value;
+                                if (x instanceof column_1.CompoundIdField) {
+                                }
+                                if (e.isDbReadonly(x)) { }
+                                else if (data[x.key] !== undefined) {
+                                    v = x.valueConverter.toDb(data[x.key]);
+                                    if (v !== undefined) {
+                                        if (!added)
+                                            added = true;
+                                        else
+                                            statement += ', ';
+                                        statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        _c = statement;
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 2:
+                        statement = _c + _f.sent();
+                        _d = this.buildSelect(e), colKeys = _d.colKeys, select = _d.select;
+                        statement += ' returning ' + select;
+                        return [2 /*return*/, r.execute(statement).then(function (sqlResult) {
+                                return _this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
+                            })];
+                }
+            });
         });
-    }
-    async delete(id) {
-        let e = await this.init();
-        let r = this.sql.createCommand();
-        let f = new FilterConsumerBridgeToSqlRequest(r, e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let statement = 'delete from ' + e.entityName;
-        statement += await f.resolveWhere();
-        return r.execute(statement).then(() => { });
-    }
-    async insert(data) {
-        let e = await this.init();
-        let r = this.sql.createCommand();
-        let cols = '';
-        let vals = '';
-        let added = false;
-        for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
-            else {
-                let v = x.valueConverter.toDb(data[x.key]);
-                if (v != undefined) {
-                    if (!added)
-                        added = true;
-                    else {
-                        cols += ', ';
-                        vals += ', ';
-                    }
-                    cols += e.nameOf(x);
-                    vals += r.addParameterAndReturnSqlToken(v);
+    };
+    ActualSQLServerDataProvider.prototype.delete = function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, r, f, statement, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.init()];
+                    case 1:
+                        e = _b.sent();
+                        r = this.sql.createCommand();
+                        f = new filter_consumer_bridge_to_sql_request_1.FilterConsumerBridgeToSqlRequest(r, e);
+                        filter_interfaces_1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+                        statement = 'delete from ' + e.entityName;
+                        _a = statement;
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 2:
+                        statement = _a + _b.sent();
+                        return [2 /*return*/, r.execute(statement).then(function () { })];
                 }
-            }
-        }
-        let statement = `insert into ${e.entityName} (${cols}) values (${vals})`;
-        let { colKeys, select } = this.buildSelect(e);
-        statement += ' returning ' + select;
-        return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));
-    }
-}
-ActualSQLServerDataProvider.LogToConsole = false;
+            });
+        });
+    };
+    ActualSQLServerDataProvider.prototype.insert = function (data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, r, cols, vals, added, _a, _b, x, v, statement, _c, colKeys, select;
+            var e_5, _d;
+            var _this = this;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.init()];
+                    case 1:
+                        e = _e.sent();
+                        r = this.sql.createCommand();
+                        cols = '';
+                        vals = '';
+                        added = false;
+                        try {
+                            for (_a = tslib_1.__values(this.entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                x = _b.value;
+                                if (e.isDbReadonly(x)) { }
+                                else {
+                                    v = x.valueConverter.toDb(data[x.key]);
+                                    if (v != undefined) {
+                                        if (!added)
+                                            added = true;
+                                        else {
+                                            cols += ', ';
+                                            vals += ', ';
+                                        }
+                                        cols += e.nameOf(x);
+                                        vals += r.addParameterAndReturnSqlToken(v);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                        statement = "insert into " + e.entityName + " (" + cols + ") values (" + vals + ")";
+                        _c = this.buildSelect(e), colKeys = _c.colKeys, select = _c.select;
+                        statement += ' returning ' + select;
+                        return [4 /*yield*/, r.execute(statement).then(function (sql) { return _this.buildResultRow(colKeys, sql.rows[0], sql); })];
+                    case 2: return [2 /*return*/, _e.sent()];
+                }
+            });
+        });
+    };
+    ActualSQLServerDataProvider.LogToConsole = false;
+    return ActualSQLServerDataProvider;
+}());