@spinajs/orm-mssql 2.0.179 → 2.0.181

package/lib/cjs/types.d.ts

@@ -1,18 +1,18 @@
-export interface ITableColumnInfo {
-    TABLE_CATALOG: string;
-    TABLE_SCHEMA: string;
-    TABLE_NAME: string;
-    COLUMN_NAME: string;
-    ORDINAL_POSITION: number;
-    COLUMN_DEFAULT: any | null;
-    IS_NULLABLE: boolean;
-    DATA_TYPE: string;
-    CHARACTER_MAXIMUM_LENGTH: number;
-}
-export interface IIndexInfo {
-    TABLE_SCHEMA: string;
-    TABLE_NAME: string;
-    COLUMN_NAME: string;
-    CONSTRAINT_TYPE: string;
-}
+export interface ITableColumnInfo {
+    TABLE_CATALOG: string;
+    TABLE_SCHEMA: string;
+    TABLE_NAME: string;
+    COLUMN_NAME: string;
+    ORDINAL_POSITION: number;
+    COLUMN_DEFAULT: any | null;
+    IS_NULLABLE: boolean;
+    DATA_TYPE: string;
+    CHARACTER_MAXIMUM_LENGTH: number;
+}
+export interface IIndexInfo {
+    TABLE_SCHEMA: string;
+    TABLE_NAME: string;
+    COLUMN_NAME: string;
+    CONSTRAINT_TYPE: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/lib/cjs/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/lib/mjs/compilers.d.ts

@@ -1,50 +1,50 @@
-import { IContainer } from '@spinajs/di';
-import { TableExistsCompiler, TableExistsQueryBuilder, ICompilerOutput, ColumnQueryBuilder, TableAliasCompiler, IQueryBuilder, InsertQueryBuilder } from '@spinajs/orm';
-import { SqlColumnQueryCompiler, SqlDeleteQueryCompiler, SqlInsertQueryCompiler, SqlLimitQueryCompiler, SqlOrderByQueryCompiler, SqlTableQueryCompiler, SqlOnDuplicateQueryCompiler } from '@spinajs/orm-sql';
-export declare class MsSqlOnDuplicateQueryCompiler extends SqlOnDuplicateQueryCompiler {
-    compile(): {
-        bindings: any[];
-        expression: string;
-    };
-}
-export declare class MsSqlInsertQueryCompiler extends SqlInsertQueryCompiler {
-    protected isDuplicate: boolean;
-    constructor(container: IContainer, builder: InsertQueryBuilder);
-    compile(): {
-        bindings: any[];
-        expression: string;
-    };
-    protected into(): string;
-}
-export declare class MsSqlTableExistsCompiler implements TableExistsCompiler {
-    protected builder: TableExistsQueryBuilder;
-    constructor(builder: TableExistsQueryBuilder);
-    compile(): ICompilerOutput;
-}
-export declare class MsSqlLimitCompiler extends SqlLimitQueryCompiler {
-    compile(): ICompilerOutput;
-}
-export declare class MsSqlOrderByCompiler extends SqlOrderByQueryCompiler {
-    compile(): ICompilerOutput;
-}
-export declare class MsSqlTableQueryCompiler extends SqlTableQueryCompiler {
-    compile(): ICompilerOutput[];
-    protected _columns(): string;
-    protected _foreignKeys(): string;
-    protected _table(): string;
-}
-export declare class MsSqlColumnQueryCompiler extends SqlColumnQueryCompiler {
-    protected builder: ColumnQueryBuilder;
-    constructor(builder: ColumnQueryBuilder);
-}
-export declare class MsSqlDeleteQueryCompiler extends SqlDeleteQueryCompiler {
-    compile(): {
-        bindings: any[];
-        expression: string;
-    };
-    protected from(): string;
-}
-export declare class MsSqlTableAliasCompiler implements TableAliasCompiler {
-    compile(builder: IQueryBuilder, tbl?: string): string;
-}
+import { IContainer } from '@spinajs/di';
+import { TableExistsCompiler, TableExistsQueryBuilder, ICompilerOutput, ColumnQueryBuilder, TableAliasCompiler, IQueryBuilder, InsertQueryBuilder } from '@spinajs/orm';
+import { SqlColumnQueryCompiler, SqlDeleteQueryCompiler, SqlInsertQueryCompiler, SqlLimitQueryCompiler, SqlOrderByQueryCompiler, SqlTableQueryCompiler, SqlOnDuplicateQueryCompiler } from '@spinajs/orm-sql';
+export declare class MsSqlOnDuplicateQueryCompiler extends SqlOnDuplicateQueryCompiler {
+    compile(): {
+        bindings: any[];
+        expression: string;
+    };
+}
+export declare class MsSqlInsertQueryCompiler extends SqlInsertQueryCompiler {
+    protected isDuplicate: boolean;
+    constructor(container: IContainer, builder: InsertQueryBuilder);
+    compile(): {
+        bindings: any[];
+        expression: string;
+    };
+    protected into(): string;
+}
+export declare class MsSqlTableExistsCompiler implements TableExistsCompiler {
+    protected builder: TableExistsQueryBuilder;
+    constructor(builder: TableExistsQueryBuilder);
+    compile(): ICompilerOutput;
+}
+export declare class MsSqlLimitCompiler extends SqlLimitQueryCompiler {
+    compile(): ICompilerOutput;
+}
+export declare class MsSqlOrderByCompiler extends SqlOrderByQueryCompiler {
+    compile(): ICompilerOutput;
+}
+export declare class MsSqlTableQueryCompiler extends SqlTableQueryCompiler {
+    compile(): ICompilerOutput[];
+    protected _columns(): string;
+    protected _foreignKeys(): string;
+    protected _table(): string;
+}
+export declare class MsSqlColumnQueryCompiler extends SqlColumnQueryCompiler {
+    protected builder: ColumnQueryBuilder;
+    constructor(builder: ColumnQueryBuilder);
+}
+export declare class MsSqlDeleteQueryCompiler extends SqlDeleteQueryCompiler {
+    compile(): {
+        bindings: any[];
+        expression: string;
+    };
+    protected from(): string;
+}
+export declare class MsSqlTableAliasCompiler implements TableAliasCompiler {
+    compile(builder: IQueryBuilder, tbl?: string): string;
+}
 //# sourceMappingURL=compilers.d.ts.map

package/lib/mjs/compilers.js

@@ -1,254 +1,254 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { Configuration } from '@spinajs/configuration';
-import { Inject, NewInstance } from '@spinajs/di';
-import { TableExistsQueryBuilder, ColumnQueryCompiler, ForeignKeyQueryCompiler, ColumnQueryBuilder, TableAliasCompiler, extractModelDescriptor, InsertQueryBuilder, OrmException } from '@spinajs/orm';
-import { SqlColumnQueryCompiler, SqlDeleteQueryCompiler, SqlInsertQueryCompiler, SqlLimitQueryCompiler, SqlOrderByQueryCompiler, SqlTableQueryCompiler, SqlOnDuplicateQueryCompiler } from '@spinajs/orm-sql';
-import _ from 'lodash';
-let MsSqlOnDuplicateQueryCompiler = class MsSqlOnDuplicateQueryCompiler extends SqlOnDuplicateQueryCompiler {
-    compile() {
-        const table = this._builder.getParent().Container.resolve(TableAliasCompiler).compile(this._builder.getParent());
-        const descriptor = extractModelDescriptor(this._builder.getParent().Model);
-        if (this._builder.getColumn().length === 0) {
-            throw new OrmException(`no unique columns defined in table ${this._builder.getParent().Table}`);
-        }
-        const columns = this._builder
-            .getColumnsToUpdate()
-            .map((c) => {
-            if (_.isString(c)) {
-                return `\`${c}\` = ?`;
-            }
-            else {
-                return c.Query;
-            }
-        })
-            .join(',');
-        const parent = this._builder.getParent();
-        const valueMap = parent.getColumns()
-            .map((c) => c.Column);
-        const bindings = this._builder.getColumnsToUpdate().map((c) => {
-            if (_.isString(c)) {
-                return parent.Values[0][valueMap.indexOf(c)];
-            }
-            else {
-                return c.Bindings;
-            }
-        });
-        const wBindings = this._builder.getColumn().map((c) => {
-            return parent.Values[0][valueMap.indexOf(c)];
-        });
-        return {
-            bindings: wBindings.concat(bindings),
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Configuration } from '@spinajs/configuration';
+import { Inject, NewInstance } from '@spinajs/di';
+import { TableExistsQueryBuilder, ColumnQueryCompiler, ForeignKeyQueryCompiler, ColumnQueryBuilder, TableAliasCompiler, extractModelDescriptor, InsertQueryBuilder, OrmException } from '@spinajs/orm';
+import { SqlColumnQueryCompiler, SqlDeleteQueryCompiler, SqlInsertQueryCompiler, SqlLimitQueryCompiler, SqlOrderByQueryCompiler, SqlTableQueryCompiler, SqlOnDuplicateQueryCompiler } from '@spinajs/orm-sql';
+import _ from 'lodash';
+let MsSqlOnDuplicateQueryCompiler = class MsSqlOnDuplicateQueryCompiler extends SqlOnDuplicateQueryCompiler {
+    compile() {
+        const table = this._builder.getParent().Container.resolve(TableAliasCompiler).compile(this._builder.getParent());
+        const descriptor = extractModelDescriptor(this._builder.getParent().Model);
+        if (this._builder.getColumn().length === 0) {
+            throw new OrmException(`no unique columns defined in table ${this._builder.getParent().Table}`);
+        }
+        const columns = this._builder
+            .getColumnsToUpdate()
+            .map((c) => {
+            if (_.isString(c)) {
+                return `\`${c}\` = ?`;
+            }
+            else {
+                return c.Query;
+            }
+        })
+            .join(',');
+        const parent = this._builder.getParent();
+        const valueMap = parent.getColumns()
+            .map((c) => c.Column);
+        const bindings = this._builder.getColumnsToUpdate().map((c) => {
+            if (_.isString(c)) {
+                return parent.Values[0][valueMap.indexOf(c)];
+            }
+            else {
+                return c.Bindings;
+            }
+        });
+        const wBindings = this._builder.getColumn().map((c) => {
+            return parent.Values[0][valueMap.indexOf(c)];
+        });
+        return {
+            bindings: wBindings.concat(bindings),
             expression: `MERGE INTO ${table} WITH (HOLDLOCK) AS target
-      USING (SELECT * FROM ${table} WHERE ${this._builder.getColumn().map((c) => {
-                return `${c} = ?`;
+      USING (SELECT * FROM ${table} WHERE ${this._builder.getColumn().map((c) => {
+                return `${c} = ?`;
             })}) as source
       ON (target.${descriptor.PrimaryKey} = source.${descriptor.PrimaryKey})
       WHEN MATCHED
         THEN UPDATE
             SET ${columns}
       WHEN NOT MATCHED
-        THEN `.replace(/(\r\n|\n|\r)/gm, ''),
-        };
-    }
-};
-MsSqlOnDuplicateQueryCompiler = __decorate([
-    NewInstance()
-], MsSqlOnDuplicateQueryCompiler);
-export { MsSqlOnDuplicateQueryCompiler };
-let MsSqlInsertQueryCompiler = class MsSqlInsertQueryCompiler extends SqlInsertQueryCompiler {
-    constructor(container, builder) {
-        super(container, builder);
-        this.isDuplicate = false;
-        this.isDuplicate = this._builder.DuplicateQueryBuilder !== null && this._builder.DuplicateQueryBuilder !== undefined;
-    }
-    compile() {
-        if (this._builder.Ignore) {
-            throw new OrmException(`mssql insert or ignore is not supported`);
-        }
-        const into = this.into();
-        const columns = this.columns();
-        const values = this.values();
-        const iBindings = values.bindings;
-        const iExpression = `${into} ${columns} ${values.data}`;
-        const dResult = super.upsort();
-        return {
-            bindings: dResult.bindings.concat(iBindings),
-            expression: dResult.expression + iExpression + '; SELECT SCOPE_IDENTITY() as ID;',
-        };
-    }
-    into() {
-        return `INSERT ${this.isDuplicate ? '' : `INTO ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`} `;
-    }
-};
-MsSqlInsertQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [Object, InsertQueryBuilder])
-], MsSqlInsertQueryCompiler);
-export { MsSqlInsertQueryCompiler };
-let MsSqlTableExistsCompiler = class MsSqlTableExistsCompiler {
-    constructor(builder) {
-        this.builder = builder;
-        if (builder === null) {
-            throw new Error('table exists query builder cannot be null');
-        }
-    }
-    compile() {
-        const bindings = [this.builder.Table];
-        let expression = '';
-        if (this.builder.Database) {
-            bindings.push(this.builder.Database);
-            expression = `SELECT TOP(1) * FROM INFORMATION_SCHEMA.COLUMNS where TABLE_NAME=? AND TABLE_CATALOG=? ORDER BY TABLE_NAME`;
-        }
-        else {
-            expression = `SELECT TOP(1) * FROM INFORMATION_SCHEMA.COLUMNS where TABLE_NAME=? ORDER BY TABLE_NAME`;
-        }
-        return {
-            bindings,
-            expression,
-        };
-    }
-};
-MsSqlTableExistsCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [TableExistsQueryBuilder])
-], MsSqlTableExistsCompiler);
-export { MsSqlTableExistsCompiler };
-let MsSqlLimitCompiler = class MsSqlLimitCompiler extends SqlLimitQueryCompiler {
-    compile() {
-        const limits = this._builder.getLimits();
-        const bindings = [];
-        let stmt = '';
-        if (limits.limit > 0) {
-            stmt += ` OFFSET ? ROWS`;
-            bindings.push(Math.max(limits.offset, 0));
-            stmt += ` FETCH NEXT ? ROWS ONLY`;
-            bindings.push(limits.limit);
-        }
-        return {
-            bindings,
-            expression: stmt,
-        };
-    }
-};
-MsSqlLimitCompiler = __decorate([
-    NewInstance()
-], MsSqlLimitCompiler);
-export { MsSqlLimitCompiler };
-let MsSqlOrderByCompiler = class MsSqlOrderByCompiler extends SqlOrderByQueryCompiler {
-    compile() {
-        const sort = this._builder.getSort();
-        let stmt = '';
-        const bindings = [];
-        if (sort) {
-            stmt = ` ORDER BY \`${sort.column}\` ${sort.order.toLowerCase() === 'asc' ? 'ASC' : 'DESC'}`;
-        }
-        return {
-            bindings,
-            expression: stmt,
-        };
-    }
-};
-MsSqlOrderByCompiler = __decorate([
-    NewInstance()
-], MsSqlOrderByCompiler);
-export { MsSqlOrderByCompiler };
-let MsSqlTableQueryCompiler = class MsSqlTableQueryCompiler extends SqlTableQueryCompiler {
-    compile() {
-        const _table = this._table();
-        const _columns = this._columns();
-        const _keys = [this._foreignKeys()];
-        const _unique = this.builder.Columns.filter((c) => c.Unique).map((c) => c.Name);
-        return [
-            {
-                bindings: [],
-                expression: `${_table} (${_columns} ${_unique.length !== 0 ? `, UNIQUE(${_unique.join(',')}) ` : ''} ${_keys ? ',' + _keys.filter((k) => k && k !== '').join(',') : ''})`,
-            },
-        ];
-    }
-    _columns() {
-        return this.builder.Columns.map((c) => {
-            const expr = this.container.resolve(ColumnQueryCompiler, [c]).compile().expression;
-            if (c.PrimaryKey) {
-                return expr + ' PRIMARY KEY';
-            }
-            return expr;
-        }).join(',');
-    }
-    _foreignKeys() {
-        return this.builder.ForeignKeys.map((f) => {
-            return this.container.resolve(ForeignKeyQueryCompiler, [f]).compile().expression;
-        }).join(',');
-    }
-    _table() {
-        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
-    }
-};
-MsSqlTableQueryCompiler = __decorate([
-    NewInstance()
-], MsSqlTableQueryCompiler);
-export { MsSqlTableQueryCompiler };
-let MsSqlColumnQueryCompiler = class MsSqlColumnQueryCompiler extends SqlColumnQueryCompiler {
-    constructor(builder) {
-        super(builder);
-        this.builder = builder;
-        // MSSQL usess this expression for AUTO_INCREMENT
-        this._statementsMappings.autoincrement = () => `IDENTITY(1,1)`;
-    }
-};
-MsSqlColumnQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [ColumnQueryBuilder])
-], MsSqlColumnQueryCompiler);
-export { MsSqlColumnQueryCompiler };
-let MsSqlDeleteQueryCompiler = class MsSqlDeleteQueryCompiler extends SqlDeleteQueryCompiler {
-    compile() {
-        const _bindings = [];
-        const _from = this.from();
-        const _where = this.where(this._builder);
-        const _expression = _from + (_where.expression ? ` WHERE ${_where.expression}` : '');
-        _bindings.push(..._where.bindings);
-        return {
-            bindings: _bindings,
-            expression: _expression.trim(),
-        };
-    }
-    from() {
-        const lBuilder = this._builder;
-        const limits = lBuilder.getLimits();
-        return `DELETE ${limits.limit > 0 ? `TOP ${limits.limit} ` : ''}FROM ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
-    }
-};
-MsSqlDeleteQueryCompiler = __decorate([
-    NewInstance()
-], MsSqlDeleteQueryCompiler);
-export { MsSqlDeleteQueryCompiler };
-let MsSqlTableAliasCompiler = class MsSqlTableAliasCompiler {
-    compile(builder, tbl) {
-        let table = '';
-        if (builder.Database) {
-            table += `\`${builder.Database}\`.`;
-        }
-        if (builder.Driver.Options.Options?.Schema) {
-            table += `\`${builder.Driver.Options.Options?.Schema}\`.`;
-        }
-        table += `\`${tbl ? tbl : builder.Table}\``;
-        if (builder.TableAlias) {
-            table += ` as \`${builder.TableAlias}\``;
-        }
-        return table;
-    }
-};
-MsSqlTableAliasCompiler = __decorate([
-    Inject(Configuration),
-    NewInstance()
-], MsSqlTableAliasCompiler);
-export { MsSqlTableAliasCompiler };
+        THEN `.replace(/(\r\n|\n|\r)/gm, ''),
+        };
+    }
+};
+MsSqlOnDuplicateQueryCompiler = __decorate([
+    NewInstance()
+], MsSqlOnDuplicateQueryCompiler);
+export { MsSqlOnDuplicateQueryCompiler };
+let MsSqlInsertQueryCompiler = class MsSqlInsertQueryCompiler extends SqlInsertQueryCompiler {
+    constructor(container, builder) {
+        super(container, builder);
+        this.isDuplicate = false;
+        this.isDuplicate = this._builder.DuplicateQueryBuilder !== null && this._builder.DuplicateQueryBuilder !== undefined;
+    }
+    compile() {
+        if (this._builder.Ignore) {
+            throw new OrmException(`mssql insert or ignore is not supported`);
+        }
+        const into = this.into();
+        const columns = this.columns();
+        const values = this.values();
+        const iBindings = values.bindings;
+        const iExpression = `${into} ${columns} ${values.data}`;
+        const dResult = super.upsort();
+        return {
+            bindings: dResult.bindings.concat(iBindings),
+            expression: dResult.expression + iExpression + '; SELECT SCOPE_IDENTITY() as ID;',
+        };
+    }
+    into() {
+        return `INSERT ${this.isDuplicate ? '' : `INTO ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`} `;
+    }
+};
+MsSqlInsertQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [Object, InsertQueryBuilder])
+], MsSqlInsertQueryCompiler);
+export { MsSqlInsertQueryCompiler };
+let MsSqlTableExistsCompiler = class MsSqlTableExistsCompiler {
+    constructor(builder) {
+        this.builder = builder;
+        if (builder === null) {
+            throw new Error('table exists query builder cannot be null');
+        }
+    }
+    compile() {
+        const bindings = [this.builder.Table];
+        let expression = '';
+        if (this.builder.Database) {
+            bindings.push(this.builder.Database);
+            expression = `SELECT TOP(1) * FROM INFORMATION_SCHEMA.COLUMNS where TABLE_NAME=? AND TABLE_CATALOG=? ORDER BY TABLE_NAME`;
+        }
+        else {
+            expression = `SELECT TOP(1) * FROM INFORMATION_SCHEMA.COLUMNS where TABLE_NAME=? ORDER BY TABLE_NAME`;
+        }
+        return {
+            bindings,
+            expression,
+        };
+    }
+};
+MsSqlTableExistsCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [TableExistsQueryBuilder])
+], MsSqlTableExistsCompiler);
+export { MsSqlTableExistsCompiler };
+let MsSqlLimitCompiler = class MsSqlLimitCompiler extends SqlLimitQueryCompiler {
+    compile() {
+        const limits = this._builder.getLimits();
+        const bindings = [];
+        let stmt = '';
+        if (limits.limit > 0) {
+            stmt += ` OFFSET ? ROWS`;
+            bindings.push(Math.max(limits.offset, 0));
+            stmt += ` FETCH NEXT ? ROWS ONLY`;
+            bindings.push(limits.limit);
+        }
+        return {
+            bindings,
+            expression: stmt,
+        };
+    }
+};
+MsSqlLimitCompiler = __decorate([
+    NewInstance()
+], MsSqlLimitCompiler);
+export { MsSqlLimitCompiler };
+let MsSqlOrderByCompiler = class MsSqlOrderByCompiler extends SqlOrderByQueryCompiler {
+    compile() {
+        const sort = this._builder.getSort();
+        let stmt = '';
+        const bindings = [];
+        if (sort) {
+            stmt = ` ORDER BY \`${sort.column}\` ${sort.order.toLowerCase() === 'asc' ? 'ASC' : 'DESC'}`;
+        }
+        return {
+            bindings,
+            expression: stmt,
+        };
+    }
+};
+MsSqlOrderByCompiler = __decorate([
+    NewInstance()
+], MsSqlOrderByCompiler);
+export { MsSqlOrderByCompiler };
+let MsSqlTableQueryCompiler = class MsSqlTableQueryCompiler extends SqlTableQueryCompiler {
+    compile() {
+        const _table = this._table();
+        const _columns = this._columns();
+        const _keys = [this._foreignKeys()];
+        const _unique = this.builder.Columns.filter((c) => c.Unique).map((c) => c.Name);
+        return [
+            {
+                bindings: [],
+                expression: `${_table} (${_columns} ${_unique.length !== 0 ? `, UNIQUE(${_unique.join(',')}) ` : ''} ${_keys ? ',' + _keys.filter((k) => k && k !== '').join(',') : ''})`,
+            },
+        ];
+    }
+    _columns() {
+        return this.builder.Columns.map((c) => {
+            const expr = this.container.resolve(ColumnQueryCompiler, [c]).compile().expression;
+            if (c.PrimaryKey) {
+                return expr + ' PRIMARY KEY';
+            }
+            return expr;
+        }).join(',');
+    }
+    _foreignKeys() {
+        return this.builder.ForeignKeys.map((f) => {
+            return this.container.resolve(ForeignKeyQueryCompiler, [f]).compile().expression;
+        }).join(',');
+    }
+    _table() {
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+MsSqlTableQueryCompiler = __decorate([
+    NewInstance()
+], MsSqlTableQueryCompiler);
+export { MsSqlTableQueryCompiler };
+let MsSqlColumnQueryCompiler = class MsSqlColumnQueryCompiler extends SqlColumnQueryCompiler {
+    constructor(builder) {
+        super(builder);
+        this.builder = builder;
+        // MSSQL usess this expression for AUTO_INCREMENT
+        this._statementsMappings.autoincrement = () => `IDENTITY(1,1)`;
+    }
+};
+MsSqlColumnQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [ColumnQueryBuilder])
+], MsSqlColumnQueryCompiler);
+export { MsSqlColumnQueryCompiler };
+let MsSqlDeleteQueryCompiler = class MsSqlDeleteQueryCompiler extends SqlDeleteQueryCompiler {
+    compile() {
+        const _bindings = [];
+        const _from = this.from();
+        const _where = this.where(this._builder);
+        const _expression = _from + (_where.expression ? ` WHERE ${_where.expression}` : '');
+        _bindings.push(..._where.bindings);
+        return {
+            bindings: _bindings,
+            expression: _expression.trim(),
+        };
+    }
+    from() {
+        const lBuilder = this._builder;
+        const limits = lBuilder.getLimits();
+        return `DELETE ${limits.limit > 0 ? `TOP ${limits.limit} ` : ''}FROM ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
+    }
+};
+MsSqlDeleteQueryCompiler = __decorate([
+    NewInstance()
+], MsSqlDeleteQueryCompiler);
+export { MsSqlDeleteQueryCompiler };
+let MsSqlTableAliasCompiler = class MsSqlTableAliasCompiler {
+    compile(builder, tbl) {
+        let table = '';
+        if (builder.Database) {
+            table += `\`${builder.Database}\`.`;
+        }
+        if (builder.Driver.Options.Options?.Schema) {
+            table += `\`${builder.Driver.Options.Options?.Schema}\`.`;
+        }
+        table += `\`${tbl ? tbl : builder.Table}\``;
+        if (builder.TableAlias) {
+            table += ` as \`${builder.TableAlias}\``;
+        }
+        return table;
+    }
+};
+MsSqlTableAliasCompiler = __decorate([
+    Inject(Configuration),
+    NewInstance()
+], MsSqlTableAliasCompiler);
+export { MsSqlTableAliasCompiler };
 //# sourceMappingURL=compilers.js.map