@sqb/builder 4.1.4 → 4.2.1

package/dist/SerializeContext.js

@@ -4,6 +4,7 @@ exports.SerializeContext = void 0;
 const enums_1 = require("./enums");
 const extensions_1 = require("./extensions");
 const Serializable_1 = require("./Serializable");
+const typeguards_1 = require("./typeguards");
 class SerializeContext {
     constructor(opts) {
         this.reservedWords = [
@@ -52,11 +53,11 @@ class SerializeContext {
             return this.serialize(enums_1.SerializationType.ARRAY, vv, () => '(' + v.join(',')) + ')';
         }
         if (typeof v === 'object') {
-            if (v.isSerializable) {
+            if ((0, typeguards_1.isSerializable)(v)) {
                 const s = v._serialize(this);
-                return s ? (v.isQuery ? '(' + s + ')' : s) :
+                return s ? ((0, typeguards_1.isQuery)(v) || (0, typeguards_1.isLogicalOperator)(v) ? '(' + s + ')' : s) :
                     /* istanbul ignore next */
-                    'null';
+                    '';
             }
             if (v instanceof Date) {
                 return this.serialize(enums_1.SerializationType.DATE_VALUE, v, () => this.dateToSQL(v));

package/dist/enums.d.ts

@@ -29,6 +29,10 @@ export declare enum SerializationType {
     JOIN_CONDITIONS = "join_conditions",
     RAW = "raw",
     CASE_STATEMENT = "case_expression",
+    COALESCE_STATEMENT = "coalesce_expression",
+    LOWER_STATEMENT = "lower_expression",
+    UPPER_STATEMENT = "upper_expression",
+    STRINGAGG_STATEMENT = "StringAGG_expression",
     COUNT_STATEMENT = "count_expression",
     CONDITIONS_BLOCK = "conditions_block",
     COMPARISON_EXPRESSION = "comparison_expression",

package/dist/enums.js

@@ -34,6 +34,10 @@ var SerializationType;
     SerializationType["JOIN_CONDITIONS"] = "join_conditions";
     SerializationType["RAW"] = "raw";
     SerializationType["CASE_STATEMENT"] = "case_expression";
+    SerializationType["COALESCE_STATEMENT"] = "coalesce_expression";
+    SerializationType["LOWER_STATEMENT"] = "lower_expression";
+    SerializationType["UPPER_STATEMENT"] = "upper_expression";
+    SerializationType["STRINGAGG_STATEMENT"] = "StringAGG_expression";
     SerializationType["COUNT_STATEMENT"] = "count_expression";
     SerializationType["CONDITIONS_BLOCK"] = "conditions_block";
     SerializationType["COMPARISON_EXPRESSION"] = "comparison_expression";

package/dist/query/InsertQuery.js

@@ -66,9 +66,8 @@ class InsertQuery extends ReturningQuery_1.ReturningQuery {
         const arr = [];
         const allValues = this._input;
         for (const n of Object.keys(allValues)) {
-            const s = ctx.anyToSQL(allValues[n]);
-            if (s)
-                arr.push((0, typeguards_1.isSelectQuery)(allValues[n]) ? '(' + s + ')' : s);
+            const s = ctx.anyToSQL(allValues[n]) || 'null';
+            arr.push(s);
         }
         return ctx.serialize(enums_1.SerializationType.INSERT_QUERY_VALUES, arr, () => (0, helpers_1.printArray)(arr));
     }

package/dist/query/SelectQuery.d.ts

@@ -12,8 +12,8 @@ export declare class SelectQuery extends Query {
     _columns?: Serializable[];
     _joins?: JoinStatement[];
     _where?: LogicalOperator;
-    _groupBy?: (GroupColumn | RawStatement)[];
-    _orderBy?: (OrderColumn | RawStatement)[];
+    _groupBy?: (GroupColumn | Serializable)[];
+    _orderBy?: (OrderColumn | Serializable)[];
     _limit?: number;
     _offset?: number;
     _alias?: string;
@@ -39,11 +39,11 @@ export declare class SelectQuery extends Query {
     /**
      * Defines "where" part of query
      */
-    groupBy(...field: (string | RawStatement)[]): this;
+    groupBy(...field: (string | Serializable)[]): this;
     /**
      * Defines "order by" part of query.
      */
-    orderBy(...field: (string | RawStatement)[]): this;
+    orderBy(...field: (string | Serializable)[]): this;
     /**
      * Sets alias for sub-select queries
      */

package/dist/query/SelectQuery.js

@@ -183,12 +183,13 @@ class SelectQuery extends Query_1.Query {
         const arr = [];
         if (this._columns)
             for (const t of this._columns) {
-                const s = t._serialize(ctx);
+                const s = ctx.anyToSQL(t);
+                // t._serialize(ctx);
                 if (s) {
                     if (t instanceof SelectQuery) {
                         if (!t._alias)
                             throw new TypeError('Alias required for sub-select in columns');
-                        arr.push('(' + s + ') ' + t._alias);
+                        arr.push(s + ' ' + t._alias);
                     }
                     else
                         arr.push(s);

package/dist/query/UpdateQuery.js

@@ -56,7 +56,7 @@ class UpdateQuery extends ReturningQuery_1.ReturningQuery {
             const value = ctx.anyToSQL(allValues[n]);
             arr.push({
                 field: n,
-                value: (0, typeguards_1.isSelectQuery)(allValues[n]) ? '(' + value + ')' : value
+                value
             });
         }
         return ctx.serialize(enums_1.SerializationType.UPDATE_QUERY_VALUES, arr, () => {

package/dist/sql-objects/CoalesceStatement.d.ts

@@ -0,0 +1,22 @@
+import { SerializationType } from '../enums';
+import { Serializable } from '../Serializable';
+import { SerializeContext } from '../SerializeContext';
+export declare class CoalesceStatement extends Serializable {
+    _expressions: any[];
+    _alias?: string;
+    constructor(...expressions: any[]);
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/CoalesceStatement.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoalesceStatement = void 0;
+const enums_1 = require("../enums");
+const Serializable_1 = require("../Serializable");
+class CoalesceStatement extends Serializable_1.Serializable {
+    constructor(...expressions) {
+        super();
+        this._expressions = expressions;
+    }
+    get _type() {
+        return enums_1.SerializationType.COALESCE_STATEMENT;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        if (!this._expressions.length)
+            return '';
+        const q = {
+            expressions: [],
+        };
+        for (const x of this._expressions) {
+            q.expressions.push(ctx.anyToSQL(x));
+        }
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'coalesce(' + o.expressions.join(', ') + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}
+exports.CoalesceStatement = CoalesceStatement;

package/dist/sql-objects/LowerStatement.d.ts

@@ -0,0 +1,22 @@
+import { SerializationType } from '../enums';
+import { Serializable } from '../Serializable';
+import { SerializeContext } from '../SerializeContext';
+export declare class LowerStatement extends Serializable {
+    _expression: any;
+    _alias?: string;
+    constructor(expression: any);
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/LowerStatement.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LowerStatement = void 0;
+const enums_1 = require("../enums");
+const Serializable_1 = require("../Serializable");
+class LowerStatement extends Serializable_1.Serializable {
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return enums_1.SerializationType.LOWER_STATEMENT;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        if (!this._expression)
+            return '';
+        const q = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'lower(' + o + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}
+exports.LowerStatement = LowerStatement;

package/dist/sql-objects/StringAggStatement.d.ts

@@ -0,0 +1,31 @@
+import { SerializationType } from '../enums';
+import { Serializable } from '../Serializable';
+import { SerializeContext } from '../SerializeContext';
+import { OrderColumn } from './OrderColumn';
+export declare class StringAGGStatement extends Serializable {
+    _field: Serializable;
+    _delimiter: string;
+    _orderBy?: (OrderColumn | Serializable)[];
+    _alias?: string;
+    constructor(field: string | Serializable, delimiter?: string);
+    get _type(): SerializationType;
+    delimiter(value: string): this;
+    /**
+     * Defines "order by" part of StringAGG.
+     */
+    orderBy(...field: (string | Serializable)[]): this;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __serializeOrderColumns(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/StringAggStatement.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringAGGStatement = void 0;
+const enums_1 = require("../enums");
+const helpers_1 = require("../helpers");
+const Serializable_1 = require("../Serializable");
+const FieldExpression_1 = require("./FieldExpression");
+const OrderColumn_1 = require("./OrderColumn");
+class StringAGGStatement extends Serializable_1.Serializable {
+    constructor(field, delimiter) {
+        super();
+        this._field = typeof field === 'string' ? new FieldExpression_1.FieldExpression(field) : field;
+        this._delimiter = delimiter || ',';
+    }
+    get _type() {
+        return enums_1.SerializationType.STRINGAGG_STATEMENT;
+    }
+    delimiter(value) {
+        this._delimiter = value;
+        return this;
+    }
+    /**
+     * Defines "order by" part of StringAGG.
+     */
+    orderBy(...field) {
+        this._orderBy = this._orderBy || [];
+        for (const arg of field) {
+            if (!arg)
+                continue;
+            this._orderBy.push(typeof arg === 'string' ? new OrderColumn_1.OrderColumn(arg) : arg);
+        }
+        return this;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        const q = {
+            field: ctx.anyToSQL(this._field),
+            delimiter: this._delimiter,
+            orderBy: this.__serializeOrderColumns(ctx),
+            alias: this._alias
+        };
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __serializeOrderColumns(ctx) {
+        const arr = [];
+        if (this._orderBy)
+            for (const t of this._orderBy) {
+                const s = t._serialize(ctx);
+                /* istanbul ignore else */
+                if (s)
+                    arr.push(s);
+            }
+        return ctx.serialize(enums_1.SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
+            const s = (0, helpers_1.printArray)(arr);
+            return s ? 'order by ' + s : '';
+        });
+    }
+    __defaultSerialize(ctx, o) {
+        return 'string_agg(' + o.field +
+            ',\'' + o.delimiter + '\'' +
+            (o.orderBy ? ' ' + o.orderBy : '') + ')' +
+            (o.alias ? ' ' + o.alias : '');
+    }
+}
+exports.StringAGGStatement = StringAGGStatement;

package/dist/sql-objects/UpperStatement.d.ts

@@ -0,0 +1,22 @@
+import { SerializationType } from '../enums';
+import { Serializable } from '../Serializable';
+import { SerializeContext } from '../SerializeContext';
+export declare class UpperStatement extends Serializable {
+    _expression: any;
+    _alias?: string;
+    constructor(expression: any);
+    get _type(): SerializationType;
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias: string): this;
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx: SerializeContext): string;
+    protected __defaultSerialize(ctx: SerializeContext, o: any): string;
+}

package/dist/sql-objects/UpperStatement.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpperStatement = void 0;
+const enums_1 = require("../enums");
+const Serializable_1 = require("../Serializable");
+class UpperStatement extends Serializable_1.Serializable {
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return enums_1.SerializationType.UPPER_STATEMENT;
+    }
+    /**
+     * Sets alias to case expression.
+     */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    /**
+     * Performs serialization
+     *
+     * @param {Object} ctx
+     * @return {string}
+     * @override
+     */
+    _serialize(ctx) {
+        if (!this._expression)
+            return '';
+        const q = ctx.anyToSQL(this._expression);
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return 'upper(' + o + ')' +
+            (this._alias ? ' ' + this._alias : '');
+    }
+}
+exports.UpperStatement = UpperStatement;

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

@@ -4,7 +4,6 @@ exports.CompOperator = void 0;
 const enums_1 = require("../../enums");
 const Serializable_1 = require("../../Serializable");
 const sqlobject_initializers_1 = require("../../sqlobject.initializers");
-const typeguards_1 = require("../../typeguards");
 const FieldExpression_1 = require("../FieldExpression");
 const Operator_1 = require("../Operator");
 const ParamExpression_1 = require("../ParamExpression");
@@ -49,9 +48,9 @@ class CompOperator extends Operator_1.Operator {
             x = (0, sqlobject_initializers_1.Param)(name);
         }
         if (x instanceof Serializable_1.Serializable) {
-            const expression = x._serialize(ctx);
+            const expression = ctx.anyToSQL(x);
             const result = {
-                expression: (0, typeguards_1.isSelectQuery)(x) ? '(' + expression + ')' : expression
+                expression
             };
             if (x instanceof FieldExpression_1.FieldExpression) {
                 result.dataType = result._dataType;

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

@@ -43,16 +43,17 @@ class LogicalOperator extends Operator_1.Operator {
     _serialize(ctx) {
         const arr = [];
         for (const t of this._items) {
-            const s = t._serialize(ctx);
+            const s = ctx.anyToSQL(t);
             /* istanbul ignore else */
             if (s)
-                arr.push((0, typeguards_1.isLogicalOperator)(t) ? '(' + s + ')' : s);
+                arr.push(s);
         }
         return ctx.serialize(enums_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
             const s = (0, helpers_1.printArray)(arr, ' ' + String(this._operatorType));
             return (s.indexOf('\n') > 0) ? s.replace('\n', '\n\t') + '\b' : s;
         });
     }
+    // noinspection JSMethodCanBeStatic
     _wrapObject(obj) {
         const result = [];
         for (const n of Object.getOwnPropertyNames(obj)) {

package/dist/sqlobject.initializers.d.ts

@@ -5,11 +5,15 @@ import { SelectQuery } from './query/SelectQuery';
 import { UpdateQuery } from './query/UpdateQuery';
 import { Serializable } from './Serializable';
 import { CaseStatement } from './sql-objects/CaseStatement';
+import { CoalesceStatement } from './sql-objects/CoalesceStatement';
 import { CountStatement } from './sql-objects/CountStatement';
 import { FieldExpression } from './sql-objects/FieldExpression';
 import { JoinStatement } from './sql-objects/JoinStatement';
+import { LowerStatement } from './sql-objects/LowerStatement';
 import { ParamExpression } from './sql-objects/ParamExpression';
 import { RawStatement } from './sql-objects/RawStatement';
+import { StringAGGStatement } from './sql-objects/StringAggStatement';
+import { UpperStatement } from './sql-objects/UpperStatement';
 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;
@@ -24,6 +28,10 @@ export declare function RightOuterJoin(table: string | SelectQuery | RawStatemen
 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 Coalesce(...expressions: any[]): CoalesceStatement;
+export declare function Lower(expression: any): LowerStatement;
+export declare function Upper(expression: any): UpperStatement;
+export declare function StringAGG(field: any): StringAGGStatement;
 export declare function Count(): CountStatement;
 export declare function Param(name: string, dataType?: DataType, isArray?: boolean): ParamExpression;
 export declare function Param(args: {

package/dist/sqlobject.initializers.js

@@ -1,17 +1,21 @@
 "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;
+exports.Field = exports.Param = exports.Count = exports.StringAGG = exports.Upper = exports.Lower = exports.Coalesce = 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 DeleteQuery_1 = require("./query/DeleteQuery");
 const InsertQuery_1 = require("./query/InsertQuery");
 const SelectQuery_1 = require("./query/SelectQuery");
 const UpdateQuery_1 = require("./query/UpdateQuery");
 const CaseStatement_1 = require("./sql-objects/CaseStatement");
+const CoalesceStatement_1 = require("./sql-objects/CoalesceStatement");
 const CountStatement_1 = require("./sql-objects/CountStatement");
 const FieldExpression_1 = require("./sql-objects/FieldExpression");
 const JoinStatement_1 = require("./sql-objects/JoinStatement");
+const LowerStatement_1 = require("./sql-objects/LowerStatement");
 const ParamExpression_1 = require("./sql-objects/ParamExpression");
 const RawStatement_1 = require("./sql-objects/RawStatement");
+const StringAggStatement_1 = require("./sql-objects/StringAggStatement");
+const UpperStatement_1 = require("./sql-objects/UpperStatement");
 function Raw(text) {
     return new RawStatement_1.RawStatement(text);
 }
@@ -68,6 +72,22 @@ function Case() {
     return new CaseStatement_1.CaseStatement();
 }
 exports.Case = Case;
+function Coalesce(...expressions) {
+    return new CoalesceStatement_1.CoalesceStatement(...expressions);
+}
+exports.Coalesce = Coalesce;
+function Lower(expression) {
+    return new LowerStatement_1.LowerStatement(expression);
+}
+exports.Lower = Lower;
+function Upper(expression) {
+    return new UpperStatement_1.UpperStatement(expression);
+}
+exports.Upper = Upper;
+function StringAGG(field) {
+    return new StringAggStatement_1.StringAGGStatement(field);
+}
+exports.StringAGG = StringAGG;
 function Count() {
     return new CountStatement_1.CountStatement();
 }

package/dist/typeguards.d.ts

@@ -16,6 +16,7 @@ import type { RawStatement } from './sql-objects/RawStatement';
 import type { ReturningColumn } from './sql-objects/ReturningColumn';
 import type { TableName } from './sql-objects/TableName';
 export declare function isSerializable(value: any): value is Serializable;
+export declare function isQuery(value: any): value is Serializable;
 export declare function isRawStatement(value: any): value is RawStatement;
 export declare function isSelectQuery(value: any): value is SelectQuery;
 export declare function isInsertQuery(value: any): value is InsertQuery;

package/dist/typeguards.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTableName = exports.isReturningColumn = exports.isGroupColumn = exports.isOrderColumn = exports.isSelectColumn = exports.isCompOperator = exports.isLogicalOperator = exports.isParamExpression = exports.isCountStatement = exports.isCaseStatement = exports.isJoinStatement = exports.isDeleteQuery = exports.isIUpdateQuery = exports.isInsertQuery = exports.isSelectQuery = exports.isRawStatement = exports.isSerializable = void 0;
+exports.isTableName = exports.isReturningColumn = exports.isGroupColumn = exports.isOrderColumn = exports.isSelectColumn = exports.isCompOperator = exports.isLogicalOperator = exports.isParamExpression = exports.isCountStatement = exports.isCaseStatement = exports.isJoinStatement = exports.isDeleteQuery = exports.isIUpdateQuery = exports.isInsertQuery = exports.isSelectQuery = exports.isRawStatement = exports.isQuery = exports.isSerializable = void 0;
 const enums_1 = require("./enums");
+const Query_1 = require("./query/Query");
 const Serializable_1 = require("./Serializable");
 function isSerializable(value) {
     return value instanceof Serializable_1.Serializable;
 }
 exports.isSerializable = isSerializable;
+function isQuery(value) {
+    return value instanceof Query_1.Query;
+}
+exports.isQuery = isQuery;
 function isRawStatement(value) {
     return isSerializable(value) && value._type === enums_1.SerializationType.RAW;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "4.1.4",
+  "version": "4.2.1",
   "author": "Panates",
   "private": false,
   "contributors": [
@@ -10,7 +10,8 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/sqbjs/sqb.git"
+    "url": "https://github.com/sqbjs/sqb.git",
+    "directory": "packages/builder"
   },
   "keywords": [
     "javascript",