@sqb/builder 4.0.8 → 4.0.12

package/dist/sql-objects/operators/OpBetween.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpBetween = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpBetween extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.between;
+        this._symbol = 'between';
+        if (right && right[1] == null)
+            right[1] = right[0];
+    }
+    _serialize(ctx) {
+        if (!(this._right && this._right.length > 0))
+            return '';
+        const left = this.__serializeItem(ctx, this._left);
+        const right = [
+            this.__serializeItem(ctx, this._right[0], true),
+            this.__serializeItem(ctx, this._right[1], true)
+        ];
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left,
+            right
+        };
+        return this.__serialize(ctx, o);
+    }
+    __defaultSerialize(ctx, o) {
+        return o.left.expression + ' ' + o.symbol + ' ' +
+            o.right[0].expression + ' and ' + o.right[1].expression;
+    }
+}
+exports.OpBetween = OpBetween;

package/dist/sql-objects/operators/OpEq.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { Serializable } from '../../Serializable';
+import { OperatorType } from '../../enums';
+export declare class OpEq extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right: any);
+}

package/dist/sql-objects/operators/OpEq.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpEq = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpEq extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.eq;
+        this._symbol = '=';
+    }
+}
+exports.OpEq = OpEq;

package/dist/sql-objects/operators/OpExists.d.ts

@@ -0,0 +1,11 @@
+import { OperatorType } from '../../enums';
+import { SelectQuery } from '../../query/SelectQuery';
+import { CompOperator } from './CompOperator';
+import { SerializeContext } from '../../SerializeContext';
+export declare class OpExists extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(query: SelectQuery);
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/operators/OpExists.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpExists = void 0;
+const enums_1 = require("../../enums");
+const CompOperator_1 = require("./CompOperator");
+const typeguards_1 = require("../../typeguards");
+class OpExists extends CompOperator_1.CompOperator {
+    constructor(query) {
+        super(query);
+        this._operatorType = enums_1.OperatorType.exists;
+        this._symbol = 'exists';
+        if (!(typeof query === 'object' && (0, typeguards_1.isSelectQuery)(query)))
+            throw new TypeError('You must provide a SelectQuery in `exists()`');
+    }
+    _serialize(ctx) {
+        const left = this.__serializeItem(ctx, this._left);
+        if (this._isArray)
+            left.isArray = true;
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left
+        };
+        return this.__serialize(ctx, o);
+    }
+    __defaultSerialize(ctx, o) {
+        return o.left.expression ? o.symbol + ' ' + o.left.expression : '';
+    }
+}
+exports.OpExists = OpExists;

package/dist/sql-objects/operators/OpGt.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpGt extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpGt.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpGt = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpGt extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.gt;
+        this._symbol = '>';
+    }
+}
+exports.OpGt = OpGt;

package/dist/sql-objects/operators/OpGte.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpGte extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpGte.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpGte = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpGte extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.gte;
+        this._symbol = '>=';
+    }
+}
+exports.OpGte = OpGte;

package/dist/sql-objects/operators/OpILike.d.ts

@@ -0,0 +1,6 @@
+import { OpLike } from './OpLike';
+import { OperatorType } from '../../enums';
+export declare class OpILike extends OpLike {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpILike.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpILike = void 0;
+const OpLike_1 = require("./OpLike");
+const enums_1 = require("../../enums");
+class OpILike extends OpLike_1.OpLike {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.iLike;
+        this._symbol = 'ilike';
+    }
+}
+exports.OpILike = OpILike;

package/dist/sql-objects/operators/OpIn.d.ts

@@ -0,0 +1,9 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { SerializeContext } from '../../SerializeContext';
+export declare class OpIn extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: any, right: any);
+    _serialize(ctx: SerializeContext): string;
+}

package/dist/sql-objects/operators/OpIn.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIn = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+const typeguards_1 = require("../../typeguards");
+class OpIn extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, Array.isArray(right) || (0, typeguards_1.isSerializable)(right) ? right : [right]);
+        this._operatorType = enums_1.OperatorType.in;
+        this._symbol = 'in';
+    }
+    _serialize(ctx) {
+        if (Array.isArray(this._right) && !this._right.length)
+            return '';
+        return super._serialize(ctx);
+    }
+}
+exports.OpIn = OpIn;

package/dist/sql-objects/operators/OpIs.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpIs extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpIs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIs = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpIs extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.is;
+        this._symbol = 'is';
+    }
+}
+exports.OpIs = OpIs;

package/dist/sql-objects/operators/OpIsNot.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpIsNot extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpIsNot.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpIsNot = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpIsNot extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.isNot;
+        this._symbol = 'is not';
+    }
+}
+exports.OpIsNot = OpIsNot;

package/dist/sql-objects/operators/OpLike.d.ts

@@ -0,0 +1,10 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+import { SerializeContext } from '../../SerializeContext';
+export declare class OpLike extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+    protected __serialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/operators/OpLike.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLike = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+const typeguards_1 = require("../../typeguards");
+class OpLike extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.like;
+        this._symbol = 'like';
+    }
+    __serialize(ctx, o) {
+        if (o.right && typeof o.right !== 'string' && !(0, typeguards_1.isSerializable)(o.right))
+            o.right = ctx.anyToSQL(o.right);
+        if (!o.right)
+            return '';
+        o.right = ctx.anyToSQL(o.right);
+        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+    }
+}
+exports.OpLike = OpLike;

package/dist/sql-objects/operators/OpLt.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpLt extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpLt.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLt = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpLt extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.lt;
+        this._symbol = '<';
+    }
+}
+exports.OpLt = OpLt;

package/dist/sql-objects/operators/OpLte.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpLte extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpLte.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpLte = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpLte extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.lte;
+        this._symbol = '<=';
+    }
+}
+exports.OpLte = OpLte;

package/dist/sql-objects/operators/OpNe.d.ts

@@ -0,0 +1,8 @@
+import { CompOperator } from './CompOperator';
+import { OperatorType } from '../../enums';
+import { Serializable } from '../../Serializable';
+export declare class OpNe extends CompOperator {
+    _operatorType: OperatorType;
+    _symbol: string;
+    constructor(left: string | Serializable, right?: any);
+}

package/dist/sql-objects/operators/OpNe.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNe = void 0;
+const CompOperator_1 = require("./CompOperator");
+const enums_1 = require("../../enums");
+class OpNe extends CompOperator_1.CompOperator {
+    constructor(left, right) {
+        super(left, right);
+        this._operatorType = enums_1.OperatorType.ne;
+        this._symbol = '!=';
+    }
+}
+exports.OpNe = OpNe;

package/dist/sql-objects/operators/OpNotBetween.d.ts

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums';
+import { OpBetween } from './OpBetween';
+export declare class OpNotBetween extends OpBetween {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpNotBetween.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotBetween = void 0;
+const enums_1 = require("../../enums");
+const OpBetween_1 = require("./OpBetween");
+class OpNotBetween extends OpBetween_1.OpBetween {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.notBetween;
+        this._symbol = 'not between';
+    }
+}
+exports.OpNotBetween = OpNotBetween;

package/dist/sql-objects/operators/OpNotExists.d.ts

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums';
+import { OpExists } from './OpExists';
+export declare class OpNotExists extends OpExists {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpNotExists.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotExists = void 0;
+const enums_1 = require("../../enums");
+const OpExists_1 = require("./OpExists");
+class OpNotExists extends OpExists_1.OpExists {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.notExists;
+        this._symbol = 'not exists';
+    }
+}
+exports.OpNotExists = OpNotExists;

package/dist/sql-objects/operators/OpNotILike.d.ts

@@ -0,0 +1,6 @@
+import { OperatorType } from '../../enums';
+import { OpILike } from './OpILike';
+export declare class OpNotILike extends OpILike {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpNotILike.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotILike = void 0;
+const enums_1 = require("../../enums");
+const OpILike_1 = require("./OpILike");
+class OpNotILike extends OpILike_1.OpILike {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.notILike;
+        this._symbol = 'not ilike';
+    }
+}
+exports.OpNotILike = OpNotILike;

package/dist/sql-objects/operators/OpNotIn.d.ts

@@ -0,0 +1,6 @@
+import { OpIn } from './OpIn';
+import { OperatorType } from '../../enums';
+export declare class OpNotIn extends OpIn {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpNotIn.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotIn = void 0;
+const OpIn_1 = require("./OpIn");
+const enums_1 = require("../../enums");
+class OpNotIn extends OpIn_1.OpIn {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.notIn;
+        this._symbol = 'not in';
+    }
+}
+exports.OpNotIn = OpNotIn;

package/dist/sql-objects/operators/OpNotLike.d.ts

@@ -0,0 +1,6 @@
+import { OpLike } from './OpLike';
+import { OperatorType } from '../../enums';
+export declare class OpNotLike extends OpLike {
+    _operatorType: OperatorType;
+    _symbol: string;
+}

package/dist/sql-objects/operators/OpNotLike.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpNotLike = void 0;
+const OpLike_1 = require("./OpLike");
+const enums_1 = require("../../enums");
+class OpNotLike extends OpLike_1.OpLike {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.notLike;
+        this._symbol = 'not like';
+    }
+}
+exports.OpNotLike = OpNotLike;

package/dist/sql-objects/operators/OpOr.d.ts

@@ -0,0 +1,5 @@
+import { LogicalOperator } from './LogicalOperator';
+import { OperatorType } from '../../enums';
+export declare class OpOr extends LogicalOperator {
+    _operatorType: OperatorType;
+}

package/dist/sql-objects/operators/OpOr.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpOr = void 0;
+const LogicalOperator_1 = require("./LogicalOperator");
+const enums_1 = require("../../enums");
+class OpOr extends LogicalOperator_1.LogicalOperator {
+    constructor() {
+        super(...arguments);
+        this._operatorType = enums_1.OperatorType.or;
+    }
+}
+exports.OpOr = OpOr;

package/dist/sqlobject.initializers.d.ts

@@ -0,0 +1,39 @@
+import { DataType } from './enums';
+import { Serializable } from './Serializable';
+import { SelectQuery } from './query/SelectQuery';
+import { InsertQuery } from './query/InsertQuery';
+import { UpdateQuery } from './query/UpdateQuery';
+import { DeleteQuery } from './query/DeleteQuery';
+import { RawStatement } from './sql-objects/RawStatement';
+import { JoinStatement } from './sql-objects/JoinStatement';
+import { CaseStatement } from './sql-objects/CaseStatement';
+import { CountStatement } from './sql-objects/CountStatement';
+import { ParamExpression } from './sql-objects/ParamExpression';
+import { FieldExpression } from './sql-objects/FieldExpression';
+export declare function Raw(text: string): RawStatement;
+export declare function Select(...column: (string | string[] | Serializable)[]): SelectQuery;
+export declare function Insert(tableName: string | RawStatement, input: any): InsertQuery;
+export declare function Update(tableName: string | RawStatement, input: any): UpdateQuery;
+export declare function Delete(tableName: string | RawStatement): DeleteQuery;
+export declare function Join(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function InnerJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function LeftJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function LeftOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function RightJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function RightOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function OuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function FullOuterJoin(table: string | SelectQuery | RawStatement): JoinStatement;
+export declare function Case(): CaseStatement;
+export declare function Count(): CountStatement;
+export declare function Param(name: string, dataType?: DataType, isArray?: boolean): ParamExpression;
+export declare function Param(args: {
+    name: string;
+    dataType?: DataType;
+    isArray?: boolean;
+}): ParamExpression;
+export declare function Field(name: string, dataType?: DataType, isArray?: boolean): FieldExpression;
+export declare function Field(args: {
+    name: string;
+    dataType?: DataType;
+    isArray?: boolean;
+}): FieldExpression;

package/dist/sqlobject.initializers.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = exports.Param = exports.Count = exports.Case = exports.FullOuterJoin = exports.OuterJoin = exports.RightOuterJoin = exports.RightJoin = exports.LeftOuterJoin = exports.LeftJoin = exports.InnerJoin = exports.Join = exports.Delete = exports.Update = exports.Insert = exports.Select = exports.Raw = void 0;
+const enums_1 = require("./enums");
+const SelectQuery_1 = require("./query/SelectQuery");
+const InsertQuery_1 = require("./query/InsertQuery");
+const UpdateQuery_1 = require("./query/UpdateQuery");
+const DeleteQuery_1 = require("./query/DeleteQuery");
+const RawStatement_1 = require("./sql-objects/RawStatement");
+const JoinStatement_1 = require("./sql-objects/JoinStatement");
+const CaseStatement_1 = require("./sql-objects/CaseStatement");
+const CountStatement_1 = require("./sql-objects/CountStatement");
+const ParamExpression_1 = require("./sql-objects/ParamExpression");
+const FieldExpression_1 = require("./sql-objects/FieldExpression");
+function Raw(text) {
+    return new RawStatement_1.RawStatement(text);
+}
+exports.Raw = Raw;
+function Select(...column) {
+    return new SelectQuery_1.SelectQuery(...column);
+}
+exports.Select = Select;
+function Insert(tableName, input) {
+    return new InsertQuery_1.InsertQuery(tableName, input);
+}
+exports.Insert = Insert;
+function Update(tableName, input) {
+    return new UpdateQuery_1.UpdateQuery(tableName, input);
+}
+exports.Update = Update;
+function Delete(tableName) {
+    return new DeleteQuery_1.DeleteQuery(tableName);
+}
+exports.Delete = Delete;
+function Join(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.INNER, table);
+}
+exports.Join = Join;
+function InnerJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.INNER, table);
+}
+exports.InnerJoin = InnerJoin;
+function LeftJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.LEFT, table);
+}
+exports.LeftJoin = LeftJoin;
+function LeftOuterJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.LEFT_OUTER, table);
+}
+exports.LeftOuterJoin = LeftOuterJoin;
+function RightJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.RIGHT, table);
+}
+exports.RightJoin = RightJoin;
+function RightOuterJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.RIGHT_OUTER, table);
+}
+exports.RightOuterJoin = RightOuterJoin;
+function OuterJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.OUTER, table);
+}
+exports.OuterJoin = OuterJoin;
+function FullOuterJoin(table) {
+    return new JoinStatement_1.JoinStatement(enums_1.JoinType.FULL_OUTER, table);
+}
+exports.FullOuterJoin = FullOuterJoin;
+function Case() {
+    return new CaseStatement_1.CaseStatement();
+}
+exports.Case = Case;
+function Count() {
+    return new CountStatement_1.CountStatement();
+}
+exports.Count = Count;
+function Param(arg0, arg1, arg2) {
+    if (typeof arg0 === 'object')
+        return new ParamExpression_1.ParamExpression(arg0);
+    return new ParamExpression_1.ParamExpression({
+        name: arg0,
+        dataType: arg1,
+        isArray: arg2
+    });
+}
+exports.Param = Param;
+function Field(arg0, arg1, arg2) {
+    if (typeof arg0 === 'object')
+        return new FieldExpression_1.FieldExpression(arg0);
+    return new FieldExpression_1.FieldExpression(arg0, arg1, arg2);
+}
+exports.Field = Field;