@spinajs/orm-sql 2.0.180 → 2.0.181

package/lib/mjs/compilers.js

@@ -1,1027 +1,1027 @@
-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);
-};
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-/* eslint-disable prettier/prettier */
-import { InvalidOperation, InvalidArgument } from '@spinajs/exceptions';
-import { LimitBuilder, DropTableQueryBuilder, AlterColumnQueryBuilder, TableCloneQueryCompiler, OnDuplicateQueryBuilder, DeleteQueryBuilder, LimitQueryCompiler, InsertQueryBuilder, OrderByBuilder, SelectQueryBuilder, UpdateQueryBuilder, SelectQueryCompiler, TableQueryCompiler, TableQueryBuilder, ColumnQueryBuilder, ColumnQueryCompiler, RawQuery, OrderByQueryCompiler, OnDuplicateQueryCompiler, IndexQueryCompiler, IndexQueryBuilder, ForeignKeyBuilder, ForeignKeyQueryCompiler, AlterTableQueryBuilder, CloneTableQueryBuilder, AlterTableQueryCompiler, ColumnAlterationType, AlterColumnQueryCompiler, TableAliasCompiler, DropTableCompiler, DropEventQueryBuilder, TableHistoryQueryCompiler, EventQueryBuilder } from '@spinajs/orm';
-import { use } from 'typescript-mix';
-import { NewInstance, Inject, Container } from '@spinajs/di';
-import _ from 'lodash';
-let SqlTableAliasCompiler = class SqlTableAliasCompiler {
-    compile(builder, tbl) {
-        let table = '';
-        if (builder.Database) {
-            table += `\`${builder.Database}\`.`;
-        }
-        table += `\`${tbl ? tbl : builder.Table}\``;
-        if (builder.TableAlias) {
-            table += ` as \`${builder.TableAlias}\``;
-        }
-        return table;
-    }
-};
-SqlTableAliasCompiler = __decorate([
-    NewInstance()
-], SqlTableAliasCompiler);
-export { SqlTableAliasCompiler };
-let SqlQueryCompiler = class SqlQueryCompiler extends SelectQueryCompiler {
-    constructor(_builder, _container) {
-        super();
-        this._builder = _builder;
-        this._container = _container;
-        if (_builder === null && _builder === undefined) {
-            throw new InvalidArgument('builder cannot be null or undefined');
-        }
-    }
-    tryConvertValue(v) {
-        let val = v;
-        const converters = this._container.get('__orm_db_value_converters__');
-        if (converters && v && converters.has(v.constructor.name)) {
-            const converter = this._container.resolve(converters.get(v.constructor.name));
-            val = converter.toDB(val, null, null);
-        }
-        return val;
-    }
-};
-SqlQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [Object, Object])
-], SqlQueryCompiler);
-export { SqlQueryCompiler };
-let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends OrderByQueryCompiler {
-    constructor(builder) {
-        super();
-        if (!builder) {
-            throw new InvalidOperation('builder cannot be null or undefined');
-        }
-        this._builder = builder;
-    }
-    compile() {
-        const sort = this._builder.getSort();
-        let stmt = '';
-        const bindings = [];
-        if (sort) {
-            stmt = ` ORDER BY ${sort.column} ${sort.order}`;
-        }
-        return {
-            bindings,
-            expression: stmt,
-        };
-    }
-};
-SqlOrderByQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [OrderByBuilder])
-], SqlOrderByQueryCompiler);
-export { SqlOrderByQueryCompiler };
-let SqlWithRecursiveCompiler = class SqlWithRecursiveCompiler {
-    recursive(builder) {
-        const statement = builder.CteRecursive.build();
-        let exprr = `WITH RECURSIVE recursive_cte(${statement.Statements[0]}) AS`;
-        exprr += ` ( `;
-        exprr += statement.Statements[1];
-        exprr += ` UNION ALL `;
-        exprr += statement.Statements[2];
-        exprr += ` ) `;
-        exprr += 'SELECT * FROM recursive_cte';
-        return {
-            bindings: statement.Bindings,
-            expression: exprr,
-        };
-    }
-};
-SqlWithRecursiveCompiler = __decorate([
-    NewInstance()
-], SqlWithRecursiveCompiler);
-export { SqlWithRecursiveCompiler };
-let SqlForeignKeyQueryCompiler = class SqlForeignKeyQueryCompiler {
-    constructor(_builder) {
-        this._builder = _builder;
-        if (!_builder) {
-            throw new Error('foreign key query builder cannot be null');
-        }
-    }
-    compile() {
-        const exprr = `FOREIGN KEY (${this._builder.ForeignKeyField}) REFERENCES ${this._builder.Table}(${this._builder.PrimaryKey}) ON DELETE ${this._builder.OnDeleteAction} ON UPDATE ${this._builder.OnUpdateAction}`;
-        return {
-            bindings: [],
-            expression: exprr,
-        };
-    }
-};
-SqlForeignKeyQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [ForeignKeyBuilder])
-], SqlForeignKeyQueryCompiler);
-export { SqlForeignKeyQueryCompiler };
-let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends LimitQueryCompiler {
-    constructor(builder) {
-        super();
-        if (!builder) {
-            throw new InvalidOperation('builder cannot be null or undefined');
-        }
-        this._builder = builder;
-    }
-    compile() {
-        const limits = this._builder.getLimits();
-        const bindings = [];
-        let stmt = '';
-        if (limits.limit > 0) {
-            stmt += ` LIMIT ?`;
-            bindings.push(limits.limit);
-        }
-        else {
-            if (limits.offset > 0) {
-                stmt += ` LIMIT 18446744073709551615`;
-            }
-        }
-        if (limits.offset > 0) {
-            stmt += ` OFFSET ?`;
-            bindings.push(limits.offset);
-        }
-        return {
-            bindings,
-            expression: stmt,
-        };
-    }
-};
-SqlLimitQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [LimitBuilder])
-], SqlLimitQueryCompiler);
-export { SqlLimitQueryCompiler };
-let SqlGroupByCompiler = class SqlGroupByCompiler {
-    group(builder) {
-        let bindings = [];
-        let stmt = ' GROUP BY ';
-        const builds = builder.GroupStatements.map((x) => x.build());
-        stmt += builds.map((x) => x.Statements).join(',');
-        bindings = builds.map((x) => x.Bindings);
-        return {
-            bindings,
-            expression: builds.length != 0 ? stmt : '',
-        };
-    }
-};
-SqlGroupByCompiler = __decorate([
-    NewInstance()
-], SqlGroupByCompiler);
-export { SqlGroupByCompiler };
-let SqlColumnsCompiler = class SqlColumnsCompiler {
-    columns(builder) {
-        return {
-            bindings: [],
-            expression: builder
-                .getColumns()
-                .map((c) => {
-                return c.build().Statements[0];
-            })
-                .join(','),
-        };
-    }
-};
-SqlColumnsCompiler = __decorate([
-    NewInstance()
-], SqlColumnsCompiler);
-export { SqlColumnsCompiler };
-let SqlWhereCompiler = class SqlWhereCompiler {
-    where(builder) {
-        const where = [];
-        const bindings = [];
-        builder.Statements.map((x) => {
-            return x.build();
-        }).forEach((r) => {
-            where.push(...r.Statements);
-            if (Array.isArray(r.Bindings)) {
-                bindings.push(...r.Bindings);
-            }
-        });
-        return {
-            bindings,
-            expression: where.join(` ${builder.Op.toUpperCase()} `),
-        };
-    }
-};
-SqlWhereCompiler = __decorate([
-    NewInstance()
-], SqlWhereCompiler);
-export { SqlWhereCompiler };
-let SqlJoinCompiler = class SqlJoinCompiler {
-    join(builder) {
-        const result = builder.JoinStatements.map((s) => s.build());
-        return {
-            bindings: _.flatMap(result, (r) => r.Bindings),
-            expression: _.flatMap(result, (r) => r.Statements).join(' '),
-        };
-    }
-};
-SqlJoinCompiler = __decorate([
-    NewInstance()
-], SqlJoinCompiler);
-export { SqlJoinCompiler };
-let SqlSelectQueryCompiler = class SqlSelectQueryCompiler extends SqlQueryCompiler {
-    constructor(_container, builder) {
-        super(builder, _container);
-    }
-    compile() {
-        if (this._builder.CteRecursive) {
-            return this.recursive(this._builder);
-        }
-        const columns = this.select();
-        const from = this.from();
-        const limit = this.limit();
-        const sort = this.sort();
-        const where = this.where(this._builder);
-        const join = this.join(this._builder);
-        const group = this.group(this._builder);
-        const expression = columns + ' ' + from + (join.expression ? ` ${join.expression}` : '') + (where.expression ? ` WHERE ${where.expression}` : '') + group.expression + sort.expression + limit.expression;
-        const bindings = [];
-        bindings.push(...join.bindings);
-        bindings.push(...where.bindings);
-        bindings.push(...sort.bindings);
-        bindings.push(...limit.bindings);
-        bindings.push(...group.bindings);
-        return {
-            bindings,
-            expression: expression.trim(),
-        };
-    }
-    limit() {
-        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
-        return compiler.compile();
-    }
-    sort() {
-        const compiler = this._container.resolve(OrderByQueryCompiler, [this._builder]);
-        return compiler.compile();
-    }
-    select() {
-        let _stmt = 'SELECT ';
-        if (this._builder.IsDistinct) {
-            _stmt += 'DISTINCT ';
-        }
-        if (this._builder.getColumns().length === 0) {
-            return _stmt + '*';
-        }
-        return _stmt + this.columns(this._builder).expression;
-    }
-    from() {
-        return 'FROM ' + this._container.resolve(TableAliasCompiler).compile(this._builder);
-    }
-};
-__decorate([
-    use(SqlWhereCompiler, SqlColumnsCompiler, TableAliasCompiler, SqlJoinCompiler, SqlWithRecursiveCompiler, SqlGroupByCompiler),
-    __metadata("design:type", Object)
-], SqlSelectQueryCompiler.prototype, "this", void 0);
-SqlSelectQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, SelectQueryBuilder])
-], SqlSelectQueryCompiler);
-export { SqlSelectQueryCompiler };
-let SqlUpdateQueryCompiler = class SqlUpdateQueryCompiler extends SqlQueryCompiler {
-    constructor(_container, builder) {
-        super(builder, _container);
-        this._container = _container;
-    }
-    compile() {
-        const table = this.table();
-        const set = this.set();
-        const where = this.where(this._builder);
-        const bindings = [];
-        bindings.push(...set.bindings);
-        bindings.push(...where.bindings);
-        return {
-            bindings,
-            expression: `${table} ${set.expression} WHERE ${where.expression}`,
-        };
-    }
-    set() {
-        let bindings = [];
-        const exprr = [];
-        for (const prop of Object.keys(this._builder.Value)) {
-            const v = this._builder.Value[`${prop}`];
-            exprr.push(`\`${prop}\` = ?`);
-            bindings = bindings.concat(this.tryConvertValue(v));
-        }
-        return {
-            bindings,
-            expression: exprr.join(','),
-        };
-    }
-    table() {
-        return `UPDATE ${this._container.resolve(TableAliasCompiler).compile(this._builder)} SET`;
-    }
-};
-__decorate([
-    use(SqlWhereCompiler, TableAliasCompiler),
-    __metadata("design:type", Object)
-], SqlUpdateQueryCompiler.prototype, "this", void 0);
-SqlUpdateQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, UpdateQueryBuilder])
-], SqlUpdateQueryCompiler);
-export { SqlUpdateQueryCompiler };
-let SqlDeleteQueryCompiler = class SqlDeleteQueryCompiler extends SqlQueryCompiler {
-    constructor(_container, builder) {
-        super(builder, _container);
-    }
-    compile() {
-        const _bindings = [];
-        const _from = this.from();
-        const _limit = this.limit();
-        const _where = this.where(this._builder);
-        let _expression = '';
-        _expression = _from + (_where.expression ? ` WHERE ${_where.expression}` : '') + _limit.expression;
-        _bindings.push(..._where.bindings);
-        _bindings.push(..._limit.bindings);
-        return {
-            bindings: _bindings,
-            expression: _expression.trim(),
-        };
-    }
-    limit() {
-        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
-        return compiler.compile();
-    }
-    from() {
-        return `DELETE FROM ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
-    }
-};
-__decorate([
-    use(SqlWhereCompiler, TableAliasCompiler),
-    __metadata("design:type", Object)
-], SqlDeleteQueryCompiler.prototype, "this", void 0);
-SqlDeleteQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, DeleteQueryBuilder])
-], SqlDeleteQueryCompiler);
-export { SqlDeleteQueryCompiler };
-let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
-    constructor(builder) {
-        this._builder = builder;
-    }
-    compile() {
-        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;
-            }
-        });
-        return {
-            bindings,
-            expression: `ON DUPLICATE KEY UPDATE ${columns}`,
-        };
-    }
-};
-SqlOnDuplicateQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [OnDuplicateQueryBuilder])
-], SqlOnDuplicateQueryCompiler);
-export { SqlOnDuplicateQueryCompiler };
-let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends IndexQueryCompiler {
-    constructor(builder) {
-        super();
-        this._builder = builder;
-    }
-    compile() {
-        return {
-            bindings: [],
-            expression: `CREATE ${this._builder.Unique ? 'UNIQUE ' : ''}INDEX \`${this._builder.Name}\` ON \`${this._builder.Table}\` (${this._builder.Columns.map((c) => `\`${c}\``).join(',')});`,
-        };
-    }
-};
-SqlIndexQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [IndexQueryBuilder])
-], SqlIndexQueryCompiler);
-export { SqlIndexQueryCompiler };
-let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompiler {
-    constructor(_container, builder) {
-        super(builder, _container);
-    }
-    compile() {
-        const into = this.into();
-        const columns = this.columns();
-        const values = this.values();
-        const upsort = this.upsort();
-        return {
-            bindings: values.bindings.concat(upsort.bindings),
-            expression: `${into} ${columns} ${values.data} ${upsort.expression}`.trim(),
-        };
-    }
-    upsort() {
-        if (this._builder.Update) {
-            return this._container.resolve(OnDuplicateQueryCompiler, [this._builder.DuplicateQueryBuilder]).compile();
-        }
-        return {
-            bindings: [],
-            expression: '',
-        };
-    }
-    values() {
-        if (this._builder.Values.length === 0) {
-            throw new InvalidArgument('values count invalid');
-        }
-        const bindings = [];
-        let data = 'VALUES ';
-        data += this._builder.Values.map((val) => {
-            const toInsert = val
-                .filter((v, i) => {
-                // eslint-disable-next-line security/detect-object-injection
-                const descriptor = this._builder.getColumns()[i].Descriptor;
-                if (descriptor) {
-                    if (!descriptor.Nullable && (v === null || v === undefined) && !descriptor.AutoIncrement) {
-                        throw new InvalidArgument(`value column ${descriptor.Name} cannot be null`);
-                    }
-                    if (descriptor.AutoIncrement && descriptor.PrimaryKey)
-                        return false;
-                }
-                return true;
-            })
-                .map((v) => {
-                if (v === undefined) {
-                    return 'DEFAULT';
-                }
-                if (v === null) {
-                    return 'NULL';
-                }
-                bindings.push(this.tryConvertValue(v));
-                return '?';
-            });
-            return `(` + toInsert.join(',') + ')';
-        }).join(',');
-        return {
-            bindings,
-            data,
-        };
-    }
-    columns() {
-        const columns = this._builder
-            .getColumns()
-            .filter((c) => {
-            const descriptor = c.Descriptor;
-            if (descriptor && descriptor.AutoIncrement && descriptor.PrimaryKey)
-                return false;
-            return true;
-        })
-            .map((c) => {
-            return c.Column;
-        })
-            .map((c) => {
-            return `\`${c instanceof RawQuery ? c.Query : c}\``;
-        });
-        if (columns.length === 0) {
-            throw new InvalidArgument('invalid column count');
-        }
-        return `(` + columns.join(',') + ')';
-    }
-    into() {
-        return `INSERT${this._builder.Ignore ? ' IGNORE' : ''} INTO ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
-    }
-};
-__decorate([
-    use(TableAliasCompiler),
-    __metadata("design:type", Object)
-], SqlInsertQueryCompiler.prototype, "this", void 0);
-SqlInsertQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, InsertQueryBuilder])
-], SqlInsertQueryCompiler);
-export { SqlInsertQueryCompiler };
-let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends DropTableCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        const exists = this.builder.Exists ? ' IF EXISTS' : '';
-        const exprr = `DROP TABLE${exists} ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
-        return {
-            bindings: [],
-            expression: exprr,
-        };
-    }
-};
-SqlDropTableQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Container, DropTableQueryBuilder])
-], SqlDropTableQueryCompiler);
-export { SqlDropTableQueryCompiler };
-let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends AlterTableQueryCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        const _table = this._table();
-        let _outputs = [];
-        if (this.builder.DroppedColumns.length !== 0) {
-            _outputs = _outputs.concat(this.builder.DroppedColumns.map((c) => {
-                return {
-                    bindings: [],
-                    expression: `${_table} DROP COLUMN ${c}`,
-                };
-            }));
-        }
-        if (this.builder.NewTableName) {
-            _outputs.push({
-                bindings: [],
-                expression: `${_table} RENAME TO ${this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.NewTableName)}`,
-            });
-        }
-        if (this.builder.Columns.length !== 0) {
-            _outputs = _outputs.concat(this.builder.Columns.map((c) => {
-                const compiler = this.container.resolve(AlterColumnQueryCompiler, [c]).compile();
-                return {
-                    bindings: compiler.bindings,
-                    expression: `${_table} ${compiler.expression}`,
-                };
-            }));
-        }
-        return _outputs;
-    }
-    _table() {
-        return `ALTER TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
-    }
-};
-SqlAlterTableQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Container, AlterTableQueryBuilder])
-], SqlAlterTableQueryCompiler);
-export { SqlAlterTableQueryCompiler };
-let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends TableCloneQueryCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        const _tblName = this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.CloneSource);
-        const _table = this._table();
-        const out1 = {
-            bindings: [],
-            expression: `${_table} LIKE ${_tblName}`,
-        };
-        if (!this.builder.Shallow) {
-            const fOut = this.builder.Filter !== undefined
-                ? this.builder.Filter.toDB()
-                : {
-                    bindings: [],
-                    // if no filter is provided, copy all the data
-                    expression: `SELECT * FROM ${_tblName}`,
-                };
-            const fExprr = `INSERT INTO \`${this.builder.Table}\` ${fOut.expression}`;
-            return [
-                out1,
-                {
-                    bindings: fOut.bindings,
-                    expression: fExprr,
-                },
-            ];
-        }
-        return [out1];
-    }
-    _table() {
-        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
-    }
-};
-__decorate([
-    use(TableAliasCompiler),
-    __metadata("design:type", Object)
-], SqlTableCloneQueryCompiler.prototype, "this", void 0);
-SqlTableCloneQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Container, CloneTableQueryBuilder])
-], SqlTableCloneQueryCompiler);
-export { SqlTableCloneQueryCompiler };
-let SqlTruncateTableQueryCompiler = class SqlTruncateTableQueryCompiler extends TableQueryCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        return {
-            bindings: [],
-            expression: `TRUNCATE TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`,
-        };
-    }
-};
-SqlTruncateTableQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [Container, TableQueryBuilder])
-], SqlTruncateTableQueryCompiler);
-export { SqlTruncateTableQueryCompiler };
-let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends TableHistoryQueryCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        const tblAliasCompiler = this.container.resolve(TableAliasCompiler);
-        const hTtblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}__history`);
-        const tblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}`);
-        const hTriggerName = `${this.builder.Table}__history`;
-        const tblTriggerName = this.builder.Table;
-        const dropUnique = this.builder.Columns.filter((c) => c.Unique).map((c) => {
-            return {
-                bindings: [],
-                expression: `ALTER TABLE ${hTtblName} DROP INDEX ${c.Name}`,
-            };
-        });
-        const pKey = this.builder.Columns.find((c) => c.PrimaryKey);
-        return [
-            // clone table
-            {
-                bindings: [],
-                expression: `CREATE TABLE ${hTtblName} LIKE ${tblAliasCompiler.compile(this.builder)}`,
-            },
-            ...dropUnique,
-            {
-                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);
+};
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable prettier/prettier */
+import { InvalidOperation, InvalidArgument } from '@spinajs/exceptions';
+import { LimitBuilder, DropTableQueryBuilder, AlterColumnQueryBuilder, TableCloneQueryCompiler, OnDuplicateQueryBuilder, DeleteQueryBuilder, LimitQueryCompiler, InsertQueryBuilder, OrderByBuilder, SelectQueryBuilder, UpdateQueryBuilder, SelectQueryCompiler, TableQueryCompiler, TableQueryBuilder, ColumnQueryBuilder, ColumnQueryCompiler, RawQuery, OrderByQueryCompiler, OnDuplicateQueryCompiler, IndexQueryCompiler, IndexQueryBuilder, ForeignKeyBuilder, ForeignKeyQueryCompiler, AlterTableQueryBuilder, CloneTableQueryBuilder, AlterTableQueryCompiler, ColumnAlterationType, AlterColumnQueryCompiler, TableAliasCompiler, DropTableCompiler, DropEventQueryBuilder, TableHistoryQueryCompiler, EventQueryBuilder } from '@spinajs/orm';
+import { use } from 'typescript-mix';
+import { NewInstance, Inject, Container } from '@spinajs/di';
+import _ from 'lodash';
+let SqlTableAliasCompiler = class SqlTableAliasCompiler {
+    compile(builder, tbl) {
+        let table = '';
+        if (builder.Database) {
+            table += `\`${builder.Database}\`.`;
+        }
+        table += `\`${tbl ? tbl : builder.Table}\``;
+        if (builder.TableAlias) {
+            table += ` as \`${builder.TableAlias}\``;
+        }
+        return table;
+    }
+};
+SqlTableAliasCompiler = __decorate([
+    NewInstance()
+], SqlTableAliasCompiler);
+export { SqlTableAliasCompiler };
+let SqlQueryCompiler = class SqlQueryCompiler extends SelectQueryCompiler {
+    constructor(_builder, _container) {
+        super();
+        this._builder = _builder;
+        this._container = _container;
+        if (_builder === null && _builder === undefined) {
+            throw new InvalidArgument('builder cannot be null or undefined');
+        }
+    }
+    tryConvertValue(v) {
+        let val = v;
+        const converters = this._container.get('__orm_db_value_converters__');
+        if (converters && v && converters.has(v.constructor.name)) {
+            const converter = this._container.resolve(converters.get(v.constructor.name));
+            val = converter.toDB(val, null, null);
+        }
+        return val;
+    }
+};
+SqlQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [Object, Object])
+], SqlQueryCompiler);
+export { SqlQueryCompiler };
+let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends OrderByQueryCompiler {
+    constructor(builder) {
+        super();
+        if (!builder) {
+            throw new InvalidOperation('builder cannot be null or undefined');
+        }
+        this._builder = builder;
+    }
+    compile() {
+        const sort = this._builder.getSort();
+        let stmt = '';
+        const bindings = [];
+        if (sort) {
+            stmt = ` ORDER BY ${sort.column} ${sort.order}`;
+        }
+        return {
+            bindings,
+            expression: stmt,
+        };
+    }
+};
+SqlOrderByQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [OrderByBuilder])
+], SqlOrderByQueryCompiler);
+export { SqlOrderByQueryCompiler };
+let SqlWithRecursiveCompiler = class SqlWithRecursiveCompiler {
+    recursive(builder) {
+        const statement = builder.CteRecursive.build();
+        let exprr = `WITH RECURSIVE recursive_cte(${statement.Statements[0]}) AS`;
+        exprr += ` ( `;
+        exprr += statement.Statements[1];
+        exprr += ` UNION ALL `;
+        exprr += statement.Statements[2];
+        exprr += ` ) `;
+        exprr += 'SELECT * FROM recursive_cte';
+        return {
+            bindings: statement.Bindings,
+            expression: exprr,
+        };
+    }
+};
+SqlWithRecursiveCompiler = __decorate([
+    NewInstance()
+], SqlWithRecursiveCompiler);
+export { SqlWithRecursiveCompiler };
+let SqlForeignKeyQueryCompiler = class SqlForeignKeyQueryCompiler {
+    constructor(_builder) {
+        this._builder = _builder;
+        if (!_builder) {
+            throw new Error('foreign key query builder cannot be null');
+        }
+    }
+    compile() {
+        const exprr = `FOREIGN KEY (${this._builder.ForeignKeyField}) REFERENCES ${this._builder.Table}(${this._builder.PrimaryKey}) ON DELETE ${this._builder.OnDeleteAction} ON UPDATE ${this._builder.OnUpdateAction}`;
+        return {
+            bindings: [],
+            expression: exprr,
+        };
+    }
+};
+SqlForeignKeyQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [ForeignKeyBuilder])
+], SqlForeignKeyQueryCompiler);
+export { SqlForeignKeyQueryCompiler };
+let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends LimitQueryCompiler {
+    constructor(builder) {
+        super();
+        if (!builder) {
+            throw new InvalidOperation('builder cannot be null or undefined');
+        }
+        this._builder = builder;
+    }
+    compile() {
+        const limits = this._builder.getLimits();
+        const bindings = [];
+        let stmt = '';
+        if (limits.limit > 0) {
+            stmt += ` LIMIT ?`;
+            bindings.push(limits.limit);
+        }
+        else {
+            if (limits.offset > 0) {
+                stmt += ` LIMIT 18446744073709551615`;
+            }
+        }
+        if (limits.offset > 0) {
+            stmt += ` OFFSET ?`;
+            bindings.push(limits.offset);
+        }
+        return {
+            bindings,
+            expression: stmt,
+        };
+    }
+};
+SqlLimitQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [LimitBuilder])
+], SqlLimitQueryCompiler);
+export { SqlLimitQueryCompiler };
+let SqlGroupByCompiler = class SqlGroupByCompiler {
+    group(builder) {
+        let bindings = [];
+        let stmt = ' GROUP BY ';
+        const builds = builder.GroupStatements.map((x) => x.build());
+        stmt += builds.map((x) => x.Statements).join(',');
+        bindings = builds.map((x) => x.Bindings);
+        return {
+            bindings,
+            expression: builds.length != 0 ? stmt : '',
+        };
+    }
+};
+SqlGroupByCompiler = __decorate([
+    NewInstance()
+], SqlGroupByCompiler);
+export { SqlGroupByCompiler };
+let SqlColumnsCompiler = class SqlColumnsCompiler {
+    columns(builder) {
+        return {
+            bindings: [],
+            expression: builder
+                .getColumns()
+                .map((c) => {
+                return c.build().Statements[0];
+            })
+                .join(','),
+        };
+    }
+};
+SqlColumnsCompiler = __decorate([
+    NewInstance()
+], SqlColumnsCompiler);
+export { SqlColumnsCompiler };
+let SqlWhereCompiler = class SqlWhereCompiler {
+    where(builder) {
+        const where = [];
+        const bindings = [];
+        builder.Statements.map((x) => {
+            return x.build();
+        }).forEach((r) => {
+            where.push(...r.Statements);
+            if (Array.isArray(r.Bindings)) {
+                bindings.push(...r.Bindings);
+            }
+        });
+        return {
+            bindings,
+            expression: where.join(` ${builder.Op.toUpperCase()} `),
+        };
+    }
+};
+SqlWhereCompiler = __decorate([
+    NewInstance()
+], SqlWhereCompiler);
+export { SqlWhereCompiler };
+let SqlJoinCompiler = class SqlJoinCompiler {
+    join(builder) {
+        const result = builder.JoinStatements.map((s) => s.build());
+        return {
+            bindings: _.flatMap(result, (r) => r.Bindings),
+            expression: _.flatMap(result, (r) => r.Statements).join(' '),
+        };
+    }
+};
+SqlJoinCompiler = __decorate([
+    NewInstance()
+], SqlJoinCompiler);
+export { SqlJoinCompiler };
+let SqlSelectQueryCompiler = class SqlSelectQueryCompiler extends SqlQueryCompiler {
+    constructor(_container, builder) {
+        super(builder, _container);
+    }
+    compile() {
+        if (this._builder.CteRecursive) {
+            return this.recursive(this._builder);
+        }
+        const columns = this.select();
+        const from = this.from();
+        const limit = this.limit();
+        const sort = this.sort();
+        const where = this.where(this._builder);
+        const join = this.join(this._builder);
+        const group = this.group(this._builder);
+        const expression = columns + ' ' + from + (join.expression ? ` ${join.expression}` : '') + (where.expression ? ` WHERE ${where.expression}` : '') + group.expression + sort.expression + limit.expression;
+        const bindings = [];
+        bindings.push(...join.bindings);
+        bindings.push(...where.bindings);
+        bindings.push(...sort.bindings);
+        bindings.push(...limit.bindings);
+        bindings.push(...group.bindings);
+        return {
+            bindings,
+            expression: expression.trim(),
+        };
+    }
+    limit() {
+        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
+        return compiler.compile();
+    }
+    sort() {
+        const compiler = this._container.resolve(OrderByQueryCompiler, [this._builder]);
+        return compiler.compile();
+    }
+    select() {
+        let _stmt = 'SELECT ';
+        if (this._builder.IsDistinct) {
+            _stmt += 'DISTINCT ';
+        }
+        if (this._builder.getColumns().length === 0) {
+            return _stmt + '*';
+        }
+        return _stmt + this.columns(this._builder).expression;
+    }
+    from() {
+        return 'FROM ' + this._container.resolve(TableAliasCompiler).compile(this._builder);
+    }
+};
+__decorate([
+    use(SqlWhereCompiler, SqlColumnsCompiler, TableAliasCompiler, SqlJoinCompiler, SqlWithRecursiveCompiler, SqlGroupByCompiler),
+    __metadata("design:type", Object)
+], SqlSelectQueryCompiler.prototype, "this", void 0);
+SqlSelectQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, SelectQueryBuilder])
+], SqlSelectQueryCompiler);
+export { SqlSelectQueryCompiler };
+let SqlUpdateQueryCompiler = class SqlUpdateQueryCompiler extends SqlQueryCompiler {
+    constructor(_container, builder) {
+        super(builder, _container);
+        this._container = _container;
+    }
+    compile() {
+        const table = this.table();
+        const set = this.set();
+        const where = this.where(this._builder);
+        const bindings = [];
+        bindings.push(...set.bindings);
+        bindings.push(...where.bindings);
+        return {
+            bindings,
+            expression: `${table} ${set.expression} WHERE ${where.expression}`,
+        };
+    }
+    set() {
+        let bindings = [];
+        const exprr = [];
+        for (const prop of Object.keys(this._builder.Value)) {
+            const v = this._builder.Value[`${prop}`];
+            exprr.push(`\`${prop}\` = ?`);
+            bindings = bindings.concat(this.tryConvertValue(v));
+        }
+        return {
+            bindings,
+            expression: exprr.join(','),
+        };
+    }
+    table() {
+        return `UPDATE ${this._container.resolve(TableAliasCompiler).compile(this._builder)} SET`;
+    }
+};
+__decorate([
+    use(SqlWhereCompiler, TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlUpdateQueryCompiler.prototype, "this", void 0);
+SqlUpdateQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, UpdateQueryBuilder])
+], SqlUpdateQueryCompiler);
+export { SqlUpdateQueryCompiler };
+let SqlDeleteQueryCompiler = class SqlDeleteQueryCompiler extends SqlQueryCompiler {
+    constructor(_container, builder) {
+        super(builder, _container);
+    }
+    compile() {
+        const _bindings = [];
+        const _from = this.from();
+        const _limit = this.limit();
+        const _where = this.where(this._builder);
+        let _expression = '';
+        _expression = _from + (_where.expression ? ` WHERE ${_where.expression}` : '') + _limit.expression;
+        _bindings.push(..._where.bindings);
+        _bindings.push(..._limit.bindings);
+        return {
+            bindings: _bindings,
+            expression: _expression.trim(),
+        };
+    }
+    limit() {
+        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
+        return compiler.compile();
+    }
+    from() {
+        return `DELETE FROM ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
+    }
+};
+__decorate([
+    use(SqlWhereCompiler, TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlDeleteQueryCompiler.prototype, "this", void 0);
+SqlDeleteQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, DeleteQueryBuilder])
+], SqlDeleteQueryCompiler);
+export { SqlDeleteQueryCompiler };
+let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
+    constructor(builder) {
+        this._builder = builder;
+    }
+    compile() {
+        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;
+            }
+        });
+        return {
+            bindings,
+            expression: `ON DUPLICATE KEY UPDATE ${columns}`,
+        };
+    }
+};
+SqlOnDuplicateQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [OnDuplicateQueryBuilder])
+], SqlOnDuplicateQueryCompiler);
+export { SqlOnDuplicateQueryCompiler };
+let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends IndexQueryCompiler {
+    constructor(builder) {
+        super();
+        this._builder = builder;
+    }
+    compile() {
+        return {
+            bindings: [],
+            expression: `CREATE ${this._builder.Unique ? 'UNIQUE ' : ''}INDEX \`${this._builder.Name}\` ON \`${this._builder.Table}\` (${this._builder.Columns.map((c) => `\`${c}\``).join(',')});`,
+        };
+    }
+};
+SqlIndexQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [IndexQueryBuilder])
+], SqlIndexQueryCompiler);
+export { SqlIndexQueryCompiler };
+let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompiler {
+    constructor(_container, builder) {
+        super(builder, _container);
+    }
+    compile() {
+        const into = this.into();
+        const columns = this.columns();
+        const values = this.values();
+        const upsort = this.upsort();
+        return {
+            bindings: values.bindings.concat(upsort.bindings),
+            expression: `${into} ${columns} ${values.data} ${upsort.expression}`.trim(),
+        };
+    }
+    upsort() {
+        if (this._builder.Update) {
+            return this._container.resolve(OnDuplicateQueryCompiler, [this._builder.DuplicateQueryBuilder]).compile();
+        }
+        return {
+            bindings: [],
+            expression: '',
+        };
+    }
+    values() {
+        if (this._builder.Values.length === 0) {
+            throw new InvalidArgument('values count invalid');
+        }
+        const bindings = [];
+        let data = 'VALUES ';
+        data += this._builder.Values.map((val) => {
+            const toInsert = val
+                .filter((v, i) => {
+                // eslint-disable-next-line security/detect-object-injection
+                const descriptor = this._builder.getColumns()[i].Descriptor;
+                if (descriptor) {
+                    if (!descriptor.Nullable && (v === null || v === undefined) && !descriptor.AutoIncrement) {
+                        throw new InvalidArgument(`value column ${descriptor.Name} cannot be null`);
+                    }
+                    if (descriptor.AutoIncrement && descriptor.PrimaryKey)
+                        return false;
+                }
+                return true;
+            })
+                .map((v) => {
+                if (v === undefined) {
+                    return 'DEFAULT';
+                }
+                if (v === null) {
+                    return 'NULL';
+                }
+                bindings.push(this.tryConvertValue(v));
+                return '?';
+            });
+            return `(` + toInsert.join(',') + ')';
+        }).join(',');
+        return {
+            bindings,
+            data,
+        };
+    }
+    columns() {
+        const columns = this._builder
+            .getColumns()
+            .filter((c) => {
+            const descriptor = c.Descriptor;
+            if (descriptor && descriptor.AutoIncrement && descriptor.PrimaryKey)
+                return false;
+            return true;
+        })
+            .map((c) => {
+            return c.Column;
+        })
+            .map((c) => {
+            return `\`${c instanceof RawQuery ? c.Query : c}\``;
+        });
+        if (columns.length === 0) {
+            throw new InvalidArgument('invalid column count');
+        }
+        return `(` + columns.join(',') + ')';
+    }
+    into() {
+        return `INSERT${this._builder.Ignore ? ' IGNORE' : ''} INTO ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
+    }
+};
+__decorate([
+    use(TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlInsertQueryCompiler.prototype, "this", void 0);
+SqlInsertQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, InsertQueryBuilder])
+], SqlInsertQueryCompiler);
+export { SqlInsertQueryCompiler };
+let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends DropTableCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const exists = this.builder.Exists ? ' IF EXISTS' : '';
+        const exprr = `DROP TABLE${exists} ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
+        return {
+            bindings: [],
+            expression: exprr,
+        };
+    }
+};
+SqlDropTableQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, DropTableQueryBuilder])
+], SqlDropTableQueryCompiler);
+export { SqlDropTableQueryCompiler };
+let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends AlterTableQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const _table = this._table();
+        let _outputs = [];
+        if (this.builder.DroppedColumns.length !== 0) {
+            _outputs = _outputs.concat(this.builder.DroppedColumns.map((c) => {
+                return {
+                    bindings: [],
+                    expression: `${_table} DROP COLUMN ${c}`,
+                };
+            }));
+        }
+        if (this.builder.NewTableName) {
+            _outputs.push({
+                bindings: [],
+                expression: `${_table} RENAME TO ${this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.NewTableName)}`,
+            });
+        }
+        if (this.builder.Columns.length !== 0) {
+            _outputs = _outputs.concat(this.builder.Columns.map((c) => {
+                const compiler = this.container.resolve(AlterColumnQueryCompiler, [c]).compile();
+                return {
+                    bindings: compiler.bindings,
+                    expression: `${_table} ${compiler.expression}`,
+                };
+            }));
+        }
+        return _outputs;
+    }
+    _table() {
+        return `ALTER TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+SqlAlterTableQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, AlterTableQueryBuilder])
+], SqlAlterTableQueryCompiler);
+export { SqlAlterTableQueryCompiler };
+let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends TableCloneQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const _tblName = this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.CloneSource);
+        const _table = this._table();
+        const out1 = {
+            bindings: [],
+            expression: `${_table} LIKE ${_tblName}`,
+        };
+        if (!this.builder.Shallow) {
+            const fOut = this.builder.Filter !== undefined
+                ? this.builder.Filter.toDB()
+                : {
+                    bindings: [],
+                    // if no filter is provided, copy all the data
+                    expression: `SELECT * FROM ${_tblName}`,
+                };
+            const fExprr = `INSERT INTO \`${this.builder.Table}\` ${fOut.expression}`;
+            return [
+                out1,
+                {
+                    bindings: fOut.bindings,
+                    expression: fExprr,
+                },
+            ];
+        }
+        return [out1];
+    }
+    _table() {
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+__decorate([
+    use(TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlTableCloneQueryCompiler.prototype, "this", void 0);
+SqlTableCloneQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, CloneTableQueryBuilder])
+], SqlTableCloneQueryCompiler);
+export { SqlTableCloneQueryCompiler };
+let SqlTruncateTableQueryCompiler = class SqlTruncateTableQueryCompiler extends TableQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        return {
+            bindings: [],
+            expression: `TRUNCATE TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`,
+        };
+    }
+};
+SqlTruncateTableQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [Container, TableQueryBuilder])
+], SqlTruncateTableQueryCompiler);
+export { SqlTruncateTableQueryCompiler };
+let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends TableHistoryQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const tblAliasCompiler = this.container.resolve(TableAliasCompiler);
+        const hTtblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}__history`);
+        const tblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}`);
+        const hTriggerName = `${this.builder.Table}__history`;
+        const tblTriggerName = this.builder.Table;
+        const dropUnique = this.builder.Columns.filter((c) => c.Unique).map((c) => {
+            return {
+                bindings: [],
+                expression: `ALTER TABLE ${hTtblName} DROP INDEX ${c.Name}`,
+            };
+        });
+        const pKey = this.builder.Columns.find((c) => c.PrimaryKey);
+        return [
+            // clone table
+            {
+                bindings: [],
+                expression: `CREATE TABLE ${hTtblName} LIKE ${tblAliasCompiler.compile(this.builder)}`,
+            },
+            ...dropUnique,
+            {
+                bindings: [],
                 expression: `ALTER TABLE ${hTtblName} 
                       CHANGE COLUMN ${pKey.Name} ${pKey.Name} INT NOT NULL ,
-                     DROP PRIMARY KEY;`,
-            },
-            // remove primary key & add history columns
-            {
-                bindings: [],
-                expression: `ALTER TABLE ${hTtblName} ADD __action__ VARCHAR(8) DEFAULT 'insert' FIRST, ADD __revision__ INT(6) NOT NULL AFTER __action__, ADD __start__ DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP AFTER __revision__, ADD __end__ DATETIME AFTER __start__`,
-            },
-            {
-                bindings: [],
-                expression: `ALTER TABLE ${hTtblName}  ADD PRIMARY KEY (${pKey.Name}, __revision__)`,
-            },
-            {
-                bindings: [],
+                     DROP PRIMARY KEY;`,
+            },
+            // remove primary key & add history columns
+            {
+                bindings: [],
+                expression: `ALTER TABLE ${hTtblName} ADD __action__ VARCHAR(8) DEFAULT 'insert' FIRST, ADD __revision__ INT(6) NOT NULL AFTER __action__, ADD __start__ DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP AFTER __revision__, ADD __end__ DATETIME AFTER __start__`,
+            },
+            {
+                bindings: [],
+                expression: `ALTER TABLE ${hTtblName}  ADD PRIMARY KEY (${pKey.Name}, __revision__)`,
+            },
+            {
+                bindings: [],
                 expression: `DELIMITER $$ 
         CREATE TRIGGER ${hTriggerName}__insert_trigger BEFORE INSERT ON ${hTtblName} FOR EACH ROW 
         BEGIN 
           DECLARE rev INT;
           SET rev = (SELECT IFNULL(MAX(__revision__), 0) FROM ${hTtblName} WHERE Id = NEW.Id);
           SET NEW.__revision__ = rev + 1; 
-        END;`,
-            },
-            // create tracking triggers
-            {
-                bindings: [],
-                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__insert_trigger`,
-            },
-            {
-                bindings: [],
-                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__update_trigger`,
-            },
-            {
-                bindings: [],
-                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__delete_trigger`,
-            },
-            // insert into history table & update __end__ date for all operations
-            {
-                bindings: [],
+        END;`,
+            },
+            // create tracking triggers
+            {
+                bindings: [],
+                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__insert_trigger`,
+            },
+            {
+                bindings: [],
+                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__update_trigger`,
+            },
+            {
+                bindings: [],
+                expression: `DROP TRIGGER IF EXISTS ${tblTriggerName}__delete_trigger`,
+            },
+            // insert into history table & update __end__ date for all operations
+            {
+                bindings: [],
                 expression: `DELIMITER $$ 
                      CREATE TRIGGER ${tblTriggerName}__insert_trigger AFTER INSERT ON ${tblName} FOR EACH ROW BEGIN 
                         DECLARE rev INT;
                         SET rev = (SELECT IFNULL(MAX(__revision__), 0) FROM ${hTtblName} WHERE Id = NEW.Id);
                         UPDATE ${hTtblName} SET __end__ = NOW() WHERE Id = NEW.Id AND __revision__ = rev;
                         INSERT INTO ${hTtblName} SELECT 'insert', 0, NOW(), NULL, d.* FROM ${tblName} AS d WHERE d.${pKey.Name} = NEW.${pKey.Name}; 
-                    END;`,
-            },
-            {
-                bindings: [],
+                    END;`,
+            },
+            {
+                bindings: [],
                 expression: `DELIMITER $$ 
                      CREATE TRIGGER ${tblTriggerName}__update_trigger AFTER UPDATE ON ${tblName} FOR EACH ROW BEGIN 
                         DECLARE rev INT;
                         SET rev = (SELECT IFNULL(MAX(__revision__), 0) FROM ${hTtblName} WHERE Id = NEW.Id);
                         UPDATE ${hTtblName} SET __end__ = NOW() WHERE Id = NEW.Id AND __revision__ = rev;
                         INSERT INTO ${hTtblName} SELECT 'update', 0, NOW(), NULL, d.* FROM ${tblName} AS d WHERE d.${pKey.Name} = NEW.${pKey.Name}; 
-                      END;`,
-            },
-            {
-                bindings: [],
+                      END;`,
+            },
+            {
+                bindings: [],
                 expression: `DELIMITER $$ 
                      CREATE TRIGGER ${tblTriggerName}__delete_trigger BEFORE DELETE ON ${tblName} FOR EACH ROW BEGIN 
                         DECLARE rev INT;
                         SET rev = (SELECT IFNULL(MAX(__revision__), 0) FROM ${hTtblName} WHERE Id = NEW.Id);
                         UPDATE ${hTtblName} SET __end__ = NOW() WHERE Id = NEW.Id AND __revision__ = rev;
                         INSERT INTO ${hTtblName} SELECT 'delete', 0, NOW(), NULL, d.* FROM ${tblName} AS d WHERE d.${pKey.Name} = NEW.${pKey.Name}; 
-                     END;`,
-            },
-        ];
-    }
-};
-SqlTableHistoryQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Container, TableQueryBuilder])
-], SqlTableHistoryQueryCompiler);
-export { SqlTableHistoryQueryCompiler };
-let SqlTableQueryCompiler = class SqlTableQueryCompiler extends TableQueryCompiler {
-    constructor(container, builder) {
-        super();
-        this.container = container;
-        this.builder = builder;
-    }
-    compile() {
-        const _table = this._table();
-        const _columns = this._columns();
-        const _keys = this._foreignKeys();
-        const _primaryKey = this._primaryKeys();
-        const createOutput = {
-            bindings: [],
-            expression: `${_table} (${_columns} ${_primaryKey ? ',' + _primaryKey : ''} ${_keys ? ',' + _keys : ''})`,
-        };
-        if (this.builder.TrackHistory) {
-            const hCompiler = this.container.resolve(TableHistoryQueryCompiler, [this.builder]);
-            return [createOutput, ...hCompiler.compile()];
-        }
-        else {
-            return [createOutput];
-        }
-    }
-    _columns() {
-        return this.builder.Columns.map((c) => {
-            return this.container.resolve(ColumnQueryCompiler, [c]).compile().expression;
-        }).join(',');
-    }
-    _foreignKeys() {
-        return this.builder.ForeignKeys.map((f) => {
-            return this.container.resolve(ForeignKeyQueryCompiler, [f]).compile().expression;
-        }).join(',');
-    }
-    _primaryKeys() {
-        const _keys = this.builder.Columns.filter((x) => x.PrimaryKey)
-            .map((c) => `\`${c.Name}\``)
-            .join(',');
-        if (!_.isEmpty(_keys)) {
-            return `PRIMARY KEY (${_keys})`;
-        }
-        return '';
-    }
-    _table() {
-        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
-    }
-};
-SqlTableQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Container, TableQueryBuilder])
-], SqlTableQueryCompiler);
-export { SqlTableQueryCompiler };
-let SqlColumnQueryCompiler = class SqlColumnQueryCompiler {
-    constructor(builder) {
-        this.builder = builder;
-        this._statementsMappings = {
-            set: (builder) => `SET(${builder.Args[0].map((a) => `'${a}\'`).join(',')})`,
-            string: (builder) => `VARCHAR(${builder.Args[0] ? builder.Args[0] : 255})`,
-            boolean: () => `TINYINT(1)`,
-            float: (builder) => {
-                const _precision = builder.Args[0] ? builder.Args[0] : 8;
-                const _scale = builder.Args[1] ? builder.Args[1] : 2;
-                return `${builder.Type.toUpperCase()}(${_precision},${_scale})`;
-            },
-            double: (builder) => this._statementsMappings.float(builder),
-            decimal: (builder) => this._statementsMappings.float(builder),
-            enum: (builder) => `${builder.Type.toUpperCase()}(${builder.Args[0].map((a) => `'${a}'`).join(',')})`,
-            binary: (builder) => `BINARY(${builder.Args[0] ?? 255}`,
-            smallint: (builder) => builder.Type.toUpperCase(),
-            tinyint: (builder) => builder.Type.toUpperCase(),
-            mediumint: (builder) => builder.Type.toUpperCase(),
-            int: (builder) => builder.Type.toUpperCase(),
-            bigint: (builder) => builder.Type.toUpperCase(),
-            tinytext: (builder) => builder.Type.toUpperCase(),
-            mediumtext: (builder) => builder.Type.toUpperCase(),
-            longtext: (builder) => builder.Type.toUpperCase(),
-            text: (builder) => builder.Type.toUpperCase(),
-            bit: (builder) => builder.Type.toUpperCase(),
-            date: (builder) => builder.Type.toUpperCase(),
-            time: (builder) => builder.Type.toUpperCase(),
-            dateTime: (builder) => builder.Type.toUpperCase(),
-            timestamp: (builder) => builder.Type.toUpperCase(),
-            json: (builder) => builder.Type.toUpperCase(),
-            tinyblob: (builder) => builder.Type.toUpperCase(),
-            mediumblob: (builder) => builder.Type.toUpperCase(),
-            longblob: (builder) => builder.Type.toUpperCase(),
-            // COLUMN ADDITIONA PROPS
-            unsigned: () => 'UNSIGNED',
-            charset: (builder) => `CHARACTER SET '${builder.Charset}'`,
-            collation: (builder) => `COLLATE '${builder.Collation}'`,
-            notnull: () => `NOT NULL`,
-            default: () => this._defaultCompiler(),
-            autoincrement: () => `AUTO_INCREMENT`,
-            comment: (builder) => `COMMENT '${builder.Comment}'`,
-        };
-        if (!builder) {
-            throw new Error('column query builder cannot be null');
-        }
-    }
-    compile() {
-        const _stmt = [];
-        _stmt.push(`\`${this.builder.Name}\``);
-        _stmt.push(this._statementsMappings[this.builder.Type](this.builder));
-        if (this.builder.Unsigned) {
-            _stmt.push(this._statementsMappings.unsigned());
-        }
-        if (this.builder.Charset) {
-            _stmt.push(this._statementsMappings.charset(this.builder));
-        }
-        if (this.builder.Collation) {
-            _stmt.push(this._statementsMappings.collation(this.builder));
-        }
-        if (this.builder.NotNull) {
-            _stmt.push(this._statementsMappings.notnull());
-        }
-        if (this.builder.Default) {
-            _stmt.push(this._statementsMappings.default());
-        }
-        if (this.builder.AutoIncrement) {
-            _stmt.push(this._statementsMappings.autoincrement());
-        }
-        if (this.builder.Comment) {
-            _stmt.push(this._statementsMappings.comment(this.builder));
-        }
-        if (this.builder.Unique) {
-            _stmt.push('UNIQUE');
-        }
-        return {
-            bindings: [],
-            expression: _stmt.filter((x) => !_.isEmpty(x)).join(' '),
-        };
-    }
-    _defaultCompiler() {
-        let _stmt = '';
-        if (_.isNil(this.builder.Default) || (_.isNil(this.builder.Default.Query) && _.isNil(this.builder.Default.Value))) {
-            return _stmt;
-        }
-        if (_.isString(this.builder.Default.Value)) {
-            _stmt = `DEFAULT '${this.builder.Default.Value.trim()}'`;
-        }
-        else if (_.isNumber(this.builder.Default.Value)) {
-            _stmt = `DEFAULT ${this.builder.Default.Value}`;
-        }
-        else if (this.builder.Default.Query instanceof RawQuery) {
-            _stmt = `DEFAULT ${this.builder.Default.Query.Query}`;
-        }
-        return _stmt;
-    }
-};
-SqlColumnQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [ColumnQueryBuilder])
-], SqlColumnQueryCompiler);
-export { SqlColumnQueryCompiler };
-let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlColumnQueryCompiler {
-    constructor(builder) {
-        super(builder);
-    }
-    compile() {
-        const builder = this.builder;
-        if (builder.AlterType === ColumnAlterationType.Rename) {
-            const bld = this.builder;
-            return {
-                bindings: [],
-                expression: `RENAME COLUMN \`${bld.OldName}\` TO \`${bld.Name}\``,
-            };
-        }
-        const cDefinition = super.compile();
-        if (builder.AlterType === ColumnAlterationType.Add) {
-            return {
-                bindings: cDefinition.bindings,
-                expression: `ADD ${cDefinition.expression} ${builder.AfterColumn ? `AFTER \`${builder.AfterColumn}\`` : ''}`,
-            };
-        }
-        if (builder.AlterType === ColumnAlterationType.Modify) {
-            return {
-                bindings: cDefinition.bindings,
-                expression: `MODIFY ${cDefinition.expression}`,
-            };
-        }
-    }
-};
-SqlAlterColumnQueryCompiler = __decorate([
-    NewInstance(),
-    __metadata("design:paramtypes", [AlterColumnQueryBuilder])
-], SqlAlterColumnQueryCompiler);
-export { SqlAlterColumnQueryCompiler };
-let SqlEventQueryCompiler = class SqlEventQueryCompiler extends SqlQueryCompiler {
-    constructor(container, builder) {
-        super(builder, container);
-    }
-    compile() {
-        const schedule = this._createSchedule();
-        const action = this._action();
-        return {
-            bindings: action.bindings,
-            expression: `CREATE EVENT ${this._builder.Name} ON SCHEDULE ${schedule} DO BEGIN ${action.expression} END`,
-        };
-    }
-    _createSchedule() {
-        if (this._builder.FromNowInverval) {
-            return `AT CURRENT_TIMESTAMP + INTERVAL ${this._getInterval(this._builder.FromNowInverval)}`;
-        }
-        if (this._builder.At) {
-            return `AT ${this._builder.At.toFormat(`yyyy-mm-dd HH:mm:ss`)}`;
-        }
-        if (this._builder.EveryInterval) {
-            return `EVERY ${this._getInterval(this._builder.EveryInterval)}`;
-        }
-    }
-    _getInterval(desc) {
-        return Object.getOwnPropertyNames(desc)
-            .map((x) => {
-            if (desc[`${x}`] > 0) {
-                return `${desc[`${x}`]} ${x.toUpperCase()}`;
-            }
-            return null;
-        })
-            .find((x) => x !== null);
-    }
-    _action() {
-        if (this._builder.RawSql) {
-            const res = this._builder.RawSql.build();
-            return {
-                expression: res.Statements.join(';'),
-                bindings: res.Bindings,
-            };
-        }
-        else {
-            const qResult = this._builder.Queries.reduce((prev, curr) => {
-                const res = curr.toDB();
-                if (Array.isArray(res)) {
-                    res.forEach((x) => {
-                        prev.bindings = prev.bindings.concat(x.bindings);
-                        prev.expression.push(x.expression);
-                    });
-                }
-                else {
-                    prev.bindings = prev.bindings.concat(res.bindings);
-                    prev.expression.push(res.expression);
-                }
-                return prev;
-            }, {
-                expression: [],
-                bindings: [],
-            });
-            return {
-                expression: qResult.expression.join(';'),
-                bindings: qResult.bindings,
-            };
-        }
-    }
-};
-SqlEventQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, EventQueryBuilder])
-], SqlEventQueryCompiler);
-export { SqlEventQueryCompiler };
-let SqlDropEventQueryCompiler = class SqlDropEventQueryCompiler extends SqlQueryCompiler {
-    constructor(container, builder) {
-        super(builder, container);
-    }
-    compile() {
-        return {
-            bindings: [],
-            expression: `DROP EVENT IF EXISTS ${this._builder.Name}`,
-        };
-    }
-};
-SqlDropEventQueryCompiler = __decorate([
-    NewInstance(),
-    Inject(Container),
-    __metadata("design:paramtypes", [Object, DropEventQueryBuilder])
-], SqlDropEventQueryCompiler);
-export { SqlDropEventQueryCompiler };
+                     END;`,
+            },
+        ];
+    }
+};
+SqlTableHistoryQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, TableQueryBuilder])
+], SqlTableHistoryQueryCompiler);
+export { SqlTableHistoryQueryCompiler };
+let SqlTableQueryCompiler = class SqlTableQueryCompiler extends TableQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const _table = this._table();
+        const _columns = this._columns();
+        const _keys = this._foreignKeys();
+        const _primaryKey = this._primaryKeys();
+        const createOutput = {
+            bindings: [],
+            expression: `${_table} (${_columns} ${_primaryKey ? ',' + _primaryKey : ''} ${_keys ? ',' + _keys : ''})`,
+        };
+        if (this.builder.TrackHistory) {
+            const hCompiler = this.container.resolve(TableHistoryQueryCompiler, [this.builder]);
+            return [createOutput, ...hCompiler.compile()];
+        }
+        else {
+            return [createOutput];
+        }
+    }
+    _columns() {
+        return this.builder.Columns.map((c) => {
+            return this.container.resolve(ColumnQueryCompiler, [c]).compile().expression;
+        }).join(',');
+    }
+    _foreignKeys() {
+        return this.builder.ForeignKeys.map((f) => {
+            return this.container.resolve(ForeignKeyQueryCompiler, [f]).compile().expression;
+        }).join(',');
+    }
+    _primaryKeys() {
+        const _keys = this.builder.Columns.filter((x) => x.PrimaryKey)
+            .map((c) => `\`${c.Name}\``)
+            .join(',');
+        if (!_.isEmpty(_keys)) {
+            return `PRIMARY KEY (${_keys})`;
+        }
+        return '';
+    }
+    _table() {
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+SqlTableQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, TableQueryBuilder])
+], SqlTableQueryCompiler);
+export { SqlTableQueryCompiler };
+let SqlColumnQueryCompiler = class SqlColumnQueryCompiler {
+    constructor(builder) {
+        this.builder = builder;
+        this._statementsMappings = {
+            set: (builder) => `SET(${builder.Args[0].map((a) => `'${a}\'`).join(',')})`,
+            string: (builder) => `VARCHAR(${builder.Args[0] ? builder.Args[0] : 255})`,
+            boolean: () => `TINYINT(1)`,
+            float: (builder) => {
+                const _precision = builder.Args[0] ? builder.Args[0] : 8;
+                const _scale = builder.Args[1] ? builder.Args[1] : 2;
+                return `${builder.Type.toUpperCase()}(${_precision},${_scale})`;
+            },
+            double: (builder) => this._statementsMappings.float(builder),
+            decimal: (builder) => this._statementsMappings.float(builder),
+            enum: (builder) => `${builder.Type.toUpperCase()}(${builder.Args[0].map((a) => `'${a}'`).join(',')})`,
+            binary: (builder) => `BINARY(${builder.Args[0] ?? 255}`,
+            smallint: (builder) => builder.Type.toUpperCase(),
+            tinyint: (builder) => builder.Type.toUpperCase(),
+            mediumint: (builder) => builder.Type.toUpperCase(),
+            int: (builder) => builder.Type.toUpperCase(),
+            bigint: (builder) => builder.Type.toUpperCase(),
+            tinytext: (builder) => builder.Type.toUpperCase(),
+            mediumtext: (builder) => builder.Type.toUpperCase(),
+            longtext: (builder) => builder.Type.toUpperCase(),
+            text: (builder) => builder.Type.toUpperCase(),
+            bit: (builder) => builder.Type.toUpperCase(),
+            date: (builder) => builder.Type.toUpperCase(),
+            time: (builder) => builder.Type.toUpperCase(),
+            dateTime: (builder) => builder.Type.toUpperCase(),
+            timestamp: (builder) => builder.Type.toUpperCase(),
+            json: (builder) => builder.Type.toUpperCase(),
+            tinyblob: (builder) => builder.Type.toUpperCase(),
+            mediumblob: (builder) => builder.Type.toUpperCase(),
+            longblob: (builder) => builder.Type.toUpperCase(),
+            // COLUMN ADDITIONA PROPS
+            unsigned: () => 'UNSIGNED',
+            charset: (builder) => `CHARACTER SET '${builder.Charset}'`,
+            collation: (builder) => `COLLATE '${builder.Collation}'`,
+            notnull: () => `NOT NULL`,
+            default: () => this._defaultCompiler(),
+            autoincrement: () => `AUTO_INCREMENT`,
+            comment: (builder) => `COMMENT '${builder.Comment}'`,
+        };
+        if (!builder) {
+            throw new Error('column query builder cannot be null');
+        }
+    }
+    compile() {
+        const _stmt = [];
+        _stmt.push(`\`${this.builder.Name}\``);
+        _stmt.push(this._statementsMappings[this.builder.Type](this.builder));
+        if (this.builder.Unsigned) {
+            _stmt.push(this._statementsMappings.unsigned());
+        }
+        if (this.builder.Charset) {
+            _stmt.push(this._statementsMappings.charset(this.builder));
+        }
+        if (this.builder.Collation) {
+            _stmt.push(this._statementsMappings.collation(this.builder));
+        }
+        if (this.builder.NotNull) {
+            _stmt.push(this._statementsMappings.notnull());
+        }
+        if (this.builder.Default) {
+            _stmt.push(this._statementsMappings.default());
+        }
+        if (this.builder.AutoIncrement) {
+            _stmt.push(this._statementsMappings.autoincrement());
+        }
+        if (this.builder.Comment) {
+            _stmt.push(this._statementsMappings.comment(this.builder));
+        }
+        if (this.builder.Unique) {
+            _stmt.push('UNIQUE');
+        }
+        return {
+            bindings: [],
+            expression: _stmt.filter((x) => !_.isEmpty(x)).join(' '),
+        };
+    }
+    _defaultCompiler() {
+        let _stmt = '';
+        if (_.isNil(this.builder.Default) || (_.isNil(this.builder.Default.Query) && _.isNil(this.builder.Default.Value))) {
+            return _stmt;
+        }
+        if (_.isString(this.builder.Default.Value)) {
+            _stmt = `DEFAULT '${this.builder.Default.Value.trim()}'`;
+        }
+        else if (_.isNumber(this.builder.Default.Value)) {
+            _stmt = `DEFAULT ${this.builder.Default.Value}`;
+        }
+        else if (this.builder.Default.Query instanceof RawQuery) {
+            _stmt = `DEFAULT ${this.builder.Default.Query.Query}`;
+        }
+        return _stmt;
+    }
+};
+SqlColumnQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [ColumnQueryBuilder])
+], SqlColumnQueryCompiler);
+export { SqlColumnQueryCompiler };
+let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlColumnQueryCompiler {
+    constructor(builder) {
+        super(builder);
+    }
+    compile() {
+        const builder = this.builder;
+        if (builder.AlterType === ColumnAlterationType.Rename) {
+            const bld = this.builder;
+            return {
+                bindings: [],
+                expression: `RENAME COLUMN \`${bld.OldName}\` TO \`${bld.Name}\``,
+            };
+        }
+        const cDefinition = super.compile();
+        if (builder.AlterType === ColumnAlterationType.Add) {
+            return {
+                bindings: cDefinition.bindings,
+                expression: `ADD ${cDefinition.expression} ${builder.AfterColumn ? `AFTER \`${builder.AfterColumn}\`` : ''}`,
+            };
+        }
+        if (builder.AlterType === ColumnAlterationType.Modify) {
+            return {
+                bindings: cDefinition.bindings,
+                expression: `MODIFY ${cDefinition.expression}`,
+            };
+        }
+    }
+};
+SqlAlterColumnQueryCompiler = __decorate([
+    NewInstance(),
+    __metadata("design:paramtypes", [AlterColumnQueryBuilder])
+], SqlAlterColumnQueryCompiler);
+export { SqlAlterColumnQueryCompiler };
+let SqlEventQueryCompiler = class SqlEventQueryCompiler extends SqlQueryCompiler {
+    constructor(container, builder) {
+        super(builder, container);
+    }
+    compile() {
+        const schedule = this._createSchedule();
+        const action = this._action();
+        return {
+            bindings: action.bindings,
+            expression: `CREATE EVENT ${this._builder.Name} ON SCHEDULE ${schedule} DO BEGIN ${action.expression} END`,
+        };
+    }
+    _createSchedule() {
+        if (this._builder.FromNowInverval) {
+            return `AT CURRENT_TIMESTAMP + INTERVAL ${this._getInterval(this._builder.FromNowInverval)}`;
+        }
+        if (this._builder.At) {
+            return `AT ${this._builder.At.toFormat(`yyyy-mm-dd HH:mm:ss`)}`;
+        }
+        if (this._builder.EveryInterval) {
+            return `EVERY ${this._getInterval(this._builder.EveryInterval)}`;
+        }
+    }
+    _getInterval(desc) {
+        return Object.getOwnPropertyNames(desc)
+            .map((x) => {
+            if (desc[`${x}`] > 0) {
+                return `${desc[`${x}`]} ${x.toUpperCase()}`;
+            }
+            return null;
+        })
+            .find((x) => x !== null);
+    }
+    _action() {
+        if (this._builder.RawSql) {
+            const res = this._builder.RawSql.build();
+            return {
+                expression: res.Statements.join(';'),
+                bindings: res.Bindings,
+            };
+        }
+        else {
+            const qResult = this._builder.Queries.reduce((prev, curr) => {
+                const res = curr.toDB();
+                if (Array.isArray(res)) {
+                    res.forEach((x) => {
+                        prev.bindings = prev.bindings.concat(x.bindings);
+                        prev.expression.push(x.expression);
+                    });
+                }
+                else {
+                    prev.bindings = prev.bindings.concat(res.bindings);
+                    prev.expression.push(res.expression);
+                }
+                return prev;
+            }, {
+                expression: [],
+                bindings: [],
+            });
+            return {
+                expression: qResult.expression.join(';'),
+                bindings: qResult.bindings,
+            };
+        }
+    }
+};
+SqlEventQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, EventQueryBuilder])
+], SqlEventQueryCompiler);
+export { SqlEventQueryCompiler };
+let SqlDropEventQueryCompiler = class SqlDropEventQueryCompiler extends SqlQueryCompiler {
+    constructor(container, builder) {
+        super(builder, container);
+    }
+    compile() {
+        return {
+            bindings: [],
+            expression: `DROP EVENT IF EXISTS ${this._builder.Name}`,
+        };
+    }
+};
+SqlDropEventQueryCompiler = __decorate([
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, DropEventQueryBuilder])
+], SqlDropEventQueryCompiler);
+export { SqlDropEventQueryCompiler };
 //# sourceMappingURL=compilers.js.map