@spinajs/orm-sql 2.0.86 → 2.0.87

package/lib/cjs/compilers.js

@@ -0,0 +1,1037 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDropEventQueryCompiler = exports.SqlEventQueryCompiler = exports.SqlAlterColumnQueryCompiler = exports.SqlColumnQueryCompiler = exports.SqlTableQueryCompiler = exports.SqlTableHistoryQueryCompiler = exports.SqlTruncateTableQueryCompiler = exports.SqlTableCloneQueryCompiler = exports.SqlAlterTableQueryCompiler = exports.SqlDropTableQueryCompiler = exports.SqlInsertQueryCompiler = exports.SqlIndexQueryCompiler = exports.SqlOnDuplicateQueryCompiler = exports.SqlDeleteQueryCompiler = exports.SqlUpdateQueryCompiler = exports.SqlSelectQueryCompiler = exports.SqlJoinCompiler = exports.SqlWhereCompiler = exports.SqlColumnsCompiler = exports.SqlGroupByCompiler = exports.SqlLimitQueryCompiler = exports.SqlForeignKeyQueryCompiler = exports.SqlWithRecursiveCompiler = exports.SqlOrderByQueryCompiler = exports.SqlQueryCompiler = exports.SqlTableAliasCompiler = void 0;
+/* 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 */
+const exceptions_1 = require("@spinajs/exceptions");
+const orm_1 = require("@spinajs/orm");
+const typescript_mix_1 = require("typescript-mix");
+const di_1 = require("@spinajs/di");
+const lodash_1 = __importDefault(require("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([
+    (0, di_1.NewInstance)()
+], SqlTableAliasCompiler);
+exports.SqlTableAliasCompiler = SqlTableAliasCompiler;
+let SqlQueryCompiler = class SqlQueryCompiler extends orm_1.SelectQueryCompiler {
+    constructor(_builder, _container) {
+        super();
+        this._builder = _builder;
+        this._container = _container;
+        if (_builder === null && _builder === undefined) {
+            throw new exceptions_1.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([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [Object, Object])
+], SqlQueryCompiler);
+exports.SqlQueryCompiler = SqlQueryCompiler;
+let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends orm_1.OrderByQueryCompiler {
+    constructor(builder) {
+        super();
+        if (!builder) {
+            throw new exceptions_1.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 ? ?`;
+            bindings.push(sort.column, sort.order);
+        }
+        return {
+            bindings,
+            expression: stmt,
+        };
+    }
+};
+SqlOrderByQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.OrderByBuilder])
+], SqlOrderByQueryCompiler);
+exports.SqlOrderByQueryCompiler = 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([
+    (0, di_1.NewInstance)()
+], SqlWithRecursiveCompiler);
+exports.SqlWithRecursiveCompiler = 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([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.ForeignKeyBuilder])
+], SqlForeignKeyQueryCompiler);
+exports.SqlForeignKeyQueryCompiler = SqlForeignKeyQueryCompiler;
+let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends orm_1.LimitQueryCompiler {
+    constructor(builder) {
+        super();
+        if (!builder) {
+            throw new exceptions_1.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([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.LimitBuilder])
+], SqlLimitQueryCompiler);
+exports.SqlLimitQueryCompiler = 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([
+    (0, di_1.NewInstance)()
+], SqlGroupByCompiler);
+exports.SqlGroupByCompiler = SqlGroupByCompiler;
+let SqlColumnsCompiler = class SqlColumnsCompiler {
+    columns(builder) {
+        return {
+            bindings: [],
+            expression: builder
+                .getColumns()
+                .map((c) => {
+                return c.build().Statements[0];
+            })
+                .join(','),
+        };
+    }
+};
+SqlColumnsCompiler = __decorate([
+    (0, di_1.NewInstance)()
+], SqlColumnsCompiler);
+exports.SqlColumnsCompiler = 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([
+    (0, di_1.NewInstance)()
+], SqlWhereCompiler);
+exports.SqlWhereCompiler = SqlWhereCompiler;
+let SqlJoinCompiler = class SqlJoinCompiler {
+    join(builder) {
+        const result = builder.JoinStatements.map((s) => s.build());
+        return {
+            bindings: lodash_1.default.flatMap(result, (r) => r.Bindings),
+            expression: lodash_1.default.flatMap(result, (r) => r.Statements).join(' '),
+        };
+    }
+};
+SqlJoinCompiler = __decorate([
+    (0, di_1.NewInstance)()
+], SqlJoinCompiler);
+exports.SqlJoinCompiler = 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(orm_1.LimitQueryCompiler, [this._builder]);
+        return compiler.compile();
+    }
+    sort() {
+        const compiler = this._container.resolve(orm_1.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(orm_1.TableAliasCompiler).compile(this._builder);
+    }
+};
+__decorate([
+    (0, typescript_mix_1.use)(SqlWhereCompiler, SqlColumnsCompiler, orm_1.TableAliasCompiler, SqlJoinCompiler, SqlWithRecursiveCompiler, SqlGroupByCompiler),
+    __metadata("design:type", Object)
+], SqlSelectQueryCompiler.prototype, "this", void 0);
+SqlSelectQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.SelectQueryBuilder])
+], SqlSelectQueryCompiler);
+exports.SqlSelectQueryCompiler = 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(orm_1.TableAliasCompiler).compile(this._builder)} SET`;
+    }
+};
+__decorate([
+    (0, typescript_mix_1.use)(SqlWhereCompiler, orm_1.TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlUpdateQueryCompiler.prototype, "this", void 0);
+SqlUpdateQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.UpdateQueryBuilder])
+], SqlUpdateQueryCompiler);
+exports.SqlUpdateQueryCompiler = 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(orm_1.LimitQueryCompiler, [this._builder]);
+        return compiler.compile();
+    }
+    from() {
+        return `DELETE FROM ${this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder)}`;
+    }
+};
+__decorate([
+    (0, typescript_mix_1.use)(SqlWhereCompiler, orm_1.TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlDeleteQueryCompiler.prototype, "this", void 0);
+SqlDeleteQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.DeleteQueryBuilder])
+], SqlDeleteQueryCompiler);
+exports.SqlDeleteQueryCompiler = SqlDeleteQueryCompiler;
+let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
+    constructor(builder) {
+        this._builder = builder;
+    }
+    compile() {
+        const columns = this._builder
+            .getColumnsToUpdate()
+            .map((c) => {
+            if (lodash_1.default.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 (lodash_1.default.isString(c)) {
+                return parent.Values[0][valueMap.indexOf(c)];
+            }
+            else {
+                return c.Bindings;
+            }
+        });
+        return {
+            bindings,
+            expression: `ON DUPLICATE KEY UPDATE ${columns}`,
+        };
+    }
+};
+SqlOnDuplicateQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.OnDuplicateQueryBuilder])
+], SqlOnDuplicateQueryCompiler);
+exports.SqlOnDuplicateQueryCompiler = SqlOnDuplicateQueryCompiler;
+let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends orm_1.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([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.IndexQueryBuilder])
+], SqlIndexQueryCompiler);
+exports.SqlIndexQueryCompiler = 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(orm_1.OnDuplicateQueryCompiler, [this._builder.DuplicateQueryBuilder]).compile();
+        }
+        return {
+            bindings: [],
+            expression: '',
+        };
+    }
+    values() {
+        if (this._builder.Values.length === 0) {
+            throw new exceptions_1.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 exceptions_1.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 orm_1.RawQuery ? c.Query : c}\``;
+        });
+        if (columns.length === 0) {
+            throw new exceptions_1.InvalidArgument('invalid column count');
+        }
+        return `(` + columns.join(',') + ')';
+    }
+    into() {
+        return `INSERT${this._builder.Ignore ? ' IGNORE' : ''} INTO ${this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder)}`;
+    }
+};
+__decorate([
+    (0, typescript_mix_1.use)(orm_1.TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlInsertQueryCompiler.prototype, "this", void 0);
+SqlInsertQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.InsertQueryBuilder])
+], SqlInsertQueryCompiler);
+exports.SqlInsertQueryCompiler = SqlInsertQueryCompiler;
+let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends orm_1.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(orm_1.TableAliasCompiler).compile(this.builder)}`;
+        return {
+            bindings: [],
+            expression: exprr,
+        };
+    }
+};
+SqlDropTableQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.DropTableQueryBuilder])
+], SqlDropTableQueryCompiler);
+exports.SqlDropTableQueryCompiler = SqlDropTableQueryCompiler;
+let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends orm_1.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(orm_1.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(orm_1.AlterColumnQueryCompiler, [c]).compile();
+                return {
+                    bindings: compiler.bindings,
+                    expression: `${_table} ${compiler.expression}`,
+                };
+            }));
+        }
+        return _outputs;
+    }
+    _table() {
+        return `ALTER TABLE ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+SqlAlterTableQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.AlterTableQueryBuilder])
+], SqlAlterTableQueryCompiler);
+exports.SqlAlterTableQueryCompiler = SqlAlterTableQueryCompiler;
+let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends orm_1.TableCloneQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const _tblName = this.container.resolve(orm_1.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(orm_1.TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+__decorate([
+    (0, typescript_mix_1.use)(orm_1.TableAliasCompiler),
+    __metadata("design:type", Object)
+], SqlTableCloneQueryCompiler.prototype, "this", void 0);
+SqlTableCloneQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.CloneTableQueryBuilder])
+], SqlTableCloneQueryCompiler);
+exports.SqlTableCloneQueryCompiler = SqlTableCloneQueryCompiler;
+let SqlTruncateTableQueryCompiler = class SqlTruncateTableQueryCompiler extends orm_1.TableQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        return {
+            bindings: [],
+            expression: `TRUNCATE TABLE ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`,
+        };
+    }
+};
+SqlTruncateTableQueryCompiler = __decorate([
+    (0, di_1.Inject)(di_1.Container),
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.TableQueryBuilder])
+], SqlTruncateTableQueryCompiler);
+exports.SqlTruncateTableQueryCompiler = SqlTruncateTableQueryCompiler;
+let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends orm_1.TableHistoryQueryCompiler {
+    constructor(container, builder) {
+        super();
+        this.container = container;
+        this.builder = builder;
+    }
+    compile() {
+        const tblAliasCompiler = this.container.resolve(orm_1.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: [],
+                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: [],
+                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: [],
+                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: [],
+                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([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.TableQueryBuilder])
+], SqlTableHistoryQueryCompiler);
+exports.SqlTableHistoryQueryCompiler = SqlTableHistoryQueryCompiler;
+let SqlTableQueryCompiler = class SqlTableQueryCompiler extends orm_1.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(orm_1.TableHistoryQueryCompiler, [this.builder]);
+            return [createOutput, ...hCompiler.compile()];
+        }
+        else {
+            return [createOutput];
+        }
+    }
+    _columns() {
+        return this.builder.Columns.map((c) => {
+            return this.container.resolve(orm_1.ColumnQueryCompiler, [c]).compile().expression;
+        }).join(',');
+    }
+    _foreignKeys() {
+        return this.builder.ForeignKeys.map((f) => {
+            return this.container.resolve(orm_1.ForeignKeyQueryCompiler, [f]).compile().expression;
+        }).join(',');
+    }
+    _primaryKeys() {
+        const _keys = this.builder.Columns.filter((x) => x.PrimaryKey)
+            .map((c) => `\`${c.Name}\``)
+            .join(',');
+        if (!lodash_1.default.isEmpty(_keys)) {
+            return `PRIMARY KEY (${_keys})`;
+        }
+        return '';
+    }
+    _table() {
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+    }
+};
+SqlTableQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, orm_1.TableQueryBuilder])
+], SqlTableQueryCompiler);
+exports.SqlTableQueryCompiler = 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) => !lodash_1.default.isEmpty(x)).join(' '),
+        };
+    }
+    _defaultCompiler() {
+        let _stmt = '';
+        if (lodash_1.default.isNil(this.builder.Default) || (lodash_1.default.isNil(this.builder.Default.Query) && lodash_1.default.isNil(this.builder.Default.Value))) {
+            return _stmt;
+        }
+        if (lodash_1.default.isString(this.builder.Default.Value)) {
+            _stmt = `DEFAULT '${this.builder.Default.Value.trim()}'`;
+        }
+        else if (lodash_1.default.isNumber(this.builder.Default.Value)) {
+            _stmt = `DEFAULT ${this.builder.Default.Value}`;
+        }
+        else if (this.builder.Default.Query instanceof orm_1.RawQuery) {
+            _stmt = `DEFAULT ${this.builder.Default.Query.Query}`;
+        }
+        return _stmt;
+    }
+};
+SqlColumnQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.ColumnQueryBuilder])
+], SqlColumnQueryCompiler);
+exports.SqlColumnQueryCompiler = SqlColumnQueryCompiler;
+let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlColumnQueryCompiler {
+    constructor(builder) {
+        super(builder);
+    }
+    compile() {
+        const builder = this.builder;
+        if (builder.AlterType === orm_1.ColumnAlterationType.Rename) {
+            const bld = this.builder;
+            return {
+                bindings: [],
+                expression: `RENAME COLUMN \`${bld.OldName}\` TO \`${bld.Name}\``,
+            };
+        }
+        const cDefinition = super.compile();
+        if (builder.AlterType === orm_1.ColumnAlterationType.Add) {
+            return {
+                bindings: cDefinition.bindings,
+                expression: `ADD ${cDefinition.expression} ${builder.AfterColumn ? `AFTER \`${builder.AfterColumn}\`` : ''}`,
+            };
+        }
+        if (builder.AlterType === orm_1.ColumnAlterationType.Modify) {
+            return {
+                bindings: cDefinition.bindings,
+                expression: `MODIFY ${cDefinition.expression}`,
+            };
+        }
+    }
+};
+SqlAlterColumnQueryCompiler = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [orm_1.AlterColumnQueryBuilder])
+], SqlAlterColumnQueryCompiler);
+exports.SqlAlterColumnQueryCompiler = 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([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.EventQueryBuilder])
+], SqlEventQueryCompiler);
+exports.SqlEventQueryCompiler = 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([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [Object, orm_1.DropEventQueryBuilder])
+], SqlDropEventQueryCompiler);
+exports.SqlDropEventQueryCompiler = SqlDropEventQueryCompiler;
+//# sourceMappingURL=compilers.js.map