@sqb/builder 4.1.5 → 4.5.0

package/esm/enums.js

@@ -0,0 +1,95 @@
+export var JoinType;
+(function (JoinType) {
+    JoinType["INNER"] = "inner";
+    JoinType["LEFT"] = "left";
+    JoinType["LEFT_OUTER"] = "left outer";
+    JoinType["RIGHT"] = "right";
+    JoinType["RIGHT_OUTER"] = "right outer";
+    JoinType["OUTER"] = "outer";
+    JoinType["FULL_OUTER"] = "full outer";
+})(JoinType || (JoinType = {}));
+export var SerializationType;
+(function (SerializationType) {
+    SerializationType["SELECT_QUERY"] = "select_query";
+    SerializationType["SELECT_QUERY_COLUMNS"] = "select_query.columns";
+    SerializationType["SELECT_QUERY_FROM"] = "select_query.from";
+    SerializationType["SELECT_QUERY_JOIN"] = "select_query.join";
+    SerializationType["SELECT_QUERY_GROUPBY"] = "select_query.groupby";
+    SerializationType["SELECT_QUERY_ORDERBY"] = "select_query.orderby";
+    SerializationType["INSERT_QUERY"] = "insert_query";
+    SerializationType["INSERT_QUERY_COLUMNS"] = "insert_query.columns";
+    SerializationType["INSERT_QUERY_VALUES"] = "insert_query.values";
+    SerializationType["UPDATE_QUERY"] = "update_query";
+    SerializationType["UPDATE_QUERY_VALUES"] = "update_query.values";
+    SerializationType["DELETE_QUERY"] = "delete_query";
+    SerializationType["SELECT_COLUMN"] = "select_column";
+    SerializationType["GROUP_COLUMN"] = "group_column";
+    SerializationType["ORDER_COLUMN"] = "order_column";
+    SerializationType["RETURNING_COLUMN"] = "returning_column";
+    SerializationType["TABLE_NAME"] = "table_name";
+    SerializationType["JOIN"] = "join";
+    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["MAX_STATEMENT"] = "max_expression";
+    SerializationType["MIN_STATEMENT"] = "min_expression";
+    SerializationType["SEQUENCE_GETTER_STATEMENT"] = "sequence_getter_statement";
+    SerializationType["STRINGAGG_STATEMENT"] = "StringAGG_expression";
+    SerializationType["COUNT_STATEMENT"] = "count_expression";
+    SerializationType["CONDITIONS_BLOCK"] = "conditions_block";
+    SerializationType["COMPARISON_EXPRESSION"] = "comparison_expression";
+    SerializationType["LOGICAL_EXPRESSION"] = "logical_expression";
+    SerializationType["RETURNING_BLOCK"] = "returning_block";
+    SerializationType["DATE_VALUE"] = "date_value";
+    SerializationType["STRING_VALUE"] = "string_value";
+    SerializationType["BOOLEAN_VALUE"] = "boolean_value";
+    SerializationType["NUMBER_VALUE"] = "number_value";
+    SerializationType["EXTERNAL_PARAMETER"] = "external_parameter";
+    SerializationType["ARRAY"] = "array";
+})(SerializationType || (SerializationType = {}));
+export var OperatorType;
+(function (OperatorType) {
+    OperatorType["and"] = "and";
+    OperatorType["or"] = "or";
+    OperatorType["eq"] = "eq";
+    OperatorType["ne"] = "ne";
+    OperatorType["gt"] = "gt";
+    OperatorType["gte"] = "gte";
+    OperatorType["lt"] = "lt";
+    OperatorType["lte"] = "lte";
+    OperatorType["between"] = "between";
+    OperatorType["notBetween"] = "notBetween";
+    OperatorType["in"] = "in";
+    OperatorType["notIn"] = "notIn";
+    OperatorType["like"] = "like";
+    OperatorType["notLike"] = "nlike";
+    OperatorType["iLike"] = "iLike";
+    OperatorType["notILike"] = "nIlike";
+    OperatorType["is"] = "is";
+    OperatorType["isNot"] = "isNot";
+    OperatorType["exists"] = "exists";
+    OperatorType["notExists"] = "notExists";
+})(OperatorType || (OperatorType = {}));
+export var DataType;
+(function (DataType) {
+    DataType["BOOL"] = "BOOL";
+    DataType["CHAR"] = "CHAR";
+    DataType["VARCHAR"] = "VARCHAR";
+    DataType["SMALLINT"] = "SMALLINT";
+    DataType["INTEGER"] = "INTEGER";
+    DataType["BIGINT"] = "BIGINT";
+    DataType["FLOAT"] = "FLOAT";
+    DataType["DOUBLE"] = "DOUBLE";
+    DataType["NUMBER"] = "NUMBER";
+    DataType["DATE"] = "DATE";
+    DataType["TIMESTAMP"] = "TIMESTAMP";
+    DataType["TIMESTAMPTZ"] = "TIMESTAMPTZ";
+    DataType["TIME"] = "TIME";
+    DataType["BINARY"] = "BINARY";
+    DataType["TEXT"] = "TEXT";
+    DataType["GUID"] = "GUID";
+    DataType["JSON"] = "JSON";
+})(DataType || (DataType = {}));

package/{dist → esm}/extensions.d.ts

@@ -1,4 +1,4 @@
-import { SerializerExtension } from './types';
+import { SerializerExtension } from './types.js';
 export declare let serializers: SerializerExtension[];
 export declare function registerSerializer(...extension: SerializerExtension[]): void;
 export declare function unRegisterSerializer(...extension: SerializerExtension[]): void;

package/esm/extensions.js

@@ -0,0 +1,11 @@
+export let serializers = [];
+export function registerSerializer(...extension) {
+    for (const ext of extension) {
+        if (!ext.dialect)
+            throw new TypeError('A SerializerExtension must contain "dialect" property');
+        serializers.push(ext);
+    }
+}
+export function unRegisterSerializer(...extension) {
+    serializers = serializers.filter(x => !extension.includes(x));
+}

package/esm/helpers.js

@@ -0,0 +1,27 @@
+/**
+ * Prints array with line feeding
+ */
+export function printArray(arr, sep, lfLen) {
+    let out = '';
+    let line = '';
+    let k = 0;
+    lfLen = lfLen || 60;
+    sep = sep || ',';
+    for (const s of arr) {
+        /* istanbul ignore next */
+        if (s === undefined)
+            continue;
+        line += (k > 0 ? sep : '');
+        if (line.length > lfLen) {
+            out += (out ? '\n' : '') + line;
+            line = '';
+        }
+        else
+            line += line ? ' ' : '';
+        line += s;
+        k++;
+    }
+    if (line)
+        out += (out ? '\n' : '') + line;
+    return out;
+}

package/esm/index.d.ts

@@ -0,0 +1,20 @@
+export { registerSerializer, unRegisterSerializer } from './extensions.js';
+export * from './helpers.js';
+export * from './serializable.js';
+export * from './serialize-context.js';
+export * from './query/query.js';
+export * from './query/select-query.js';
+export * from './query/insert-query.js';
+export * from './query/update-query.js';
+export * from './query/delete-query.js';
+export * from './sql-objects/operator.js';
+export * from './sql-objects/operators/logical-operator.js';
+export * from './sql-objects/operators/comp-operator.js';
+export * from './sql-objects/join-statement.js';
+export * from './types.js';
+export * from './enums.js';
+export * from './sqlobject.initializers.js';
+export * from './op.initializers.js';
+export * from './typeguards.js';
+export { op } from './op.initializers.js';
+export * as classes from './classes.ns.js';

package/esm/index.js

@@ -0,0 +1,20 @@
+export { registerSerializer, unRegisterSerializer } from './extensions.js';
+export * from './helpers.js';
+export * from './serializable.js';
+export * from './serialize-context.js';
+export * from './query/query.js';
+export * from './query/select-query.js';
+export * from './query/insert-query.js';
+export * from './query/update-query.js';
+export * from './query/delete-query.js';
+export * from './sql-objects/operator.js';
+export * from './sql-objects/operators/logical-operator.js';
+export * from './sql-objects/operators/comp-operator.js';
+export * from './sql-objects/join-statement.js';
+export * from './types.js';
+export * from './enums.js';
+export * from './sqlobject.initializers.js';
+export * from './op.initializers.js';
+export * from './typeguards.js';
+export { op } from './op.initializers.js';
+export * as classes from './classes.ns.js';

package/{dist → esm}/op.initializers.d.ts

@@ -1,25 +1,25 @@
-import { SelectQuery } from './query/SelectQuery';
-import { Serializable } from './Serializable';
-import { Operator } from './sql-objects/Operator';
-import { OpAnd } from './sql-objects/operators/OpAnd';
-import { OpEq } from './sql-objects/operators/OpEq';
-import { OpExists } from './sql-objects/operators/OpExists';
-import { OpGt } from './sql-objects/operators/OpGt';
-import { OpGte } from './sql-objects/operators/OpGte';
-import { OpILike } from './sql-objects/operators/OpILike';
-import { OpIn } from './sql-objects/operators/OpIn';
-import { OpIs } from './sql-objects/operators/OpIs';
-import { OpIsNot } from './sql-objects/operators/OpIsNot';
-import { OpLike } from './sql-objects/operators/OpLike';
-import { OpLt } from './sql-objects/operators/OpLt';
-import { OpLte } from './sql-objects/operators/OpLte';
-import { OpNe } from './sql-objects/operators/OpNe';
-import { OpNotExists } from './sql-objects/operators/OpNotExists';
-import { OpNotILike } from './sql-objects/operators/OpNotILike';
-import { OpNotIn } from './sql-objects/operators/OpNotIn';
-import { OpNotLike } from './sql-objects/operators/OpNotLike';
-import { OpOr } from './sql-objects/operators/OpOr';
-import { RawStatement } from './sql-objects/RawStatement';
+import { SelectQuery } from './query/select-query.js';
+import { Serializable } from './serializable.js';
+import { Operator } from './sql-objects/operator.js';
+import { OpAnd } from './sql-objects/operators/op-and.js';
+import { OpEq } from './sql-objects/operators/op-eq.js';
+import { OpExists } from './sql-objects/operators/op-exists.js';
+import { OpGt } from './sql-objects/operators/op-gt.js';
+import { OpGte } from './sql-objects/operators/op-gte.js';
+import { OpILike } from './sql-objects/operators/op-ilike.js';
+import { OpIn } from './sql-objects/operators/op-in.js';
+import { OpIs } from './sql-objects/operators/op-is.js';
+import { OpIsNot } from './sql-objects/operators/op-is-not.js';
+import { OpLike } from './sql-objects/operators/op-like.js';
+import { OpLt } from './sql-objects/operators/op-lt.js';
+import { OpLte } from './sql-objects/operators/op-lte.js';
+import { OpNe } from './sql-objects/operators/op-ne.js';
+import { OpNotExists } from './sql-objects/operators/op-not-exists.js';
+import { OpNotILike } from './sql-objects/operators/op-not-ilike.js';
+import { OpNotIn } from './sql-objects/operators/op-not-in.js';
+import { OpNotLike } from './sql-objects/operators/op-not-like.js';
+import { OpOr } from './sql-objects/operators/op-or.js';
+import { RawStatement } from './sql-objects/raw-statement.js';
 declare function And(...args: (Operator | RawStatement)[]): OpAnd;
 declare function Or(...args: (Operator | RawStatement)[]): OpOr;
 declare function Eq(expression: string | Serializable, value: any): OpEq;

package/esm/op.initializers.js

@@ -0,0 +1,126 @@
+import { WrapOps } from './sql-objects/operators/logical-operator.js';
+import { OpAnd } from './sql-objects/operators/op-and.js';
+import { OpBetween } from './sql-objects/operators/op-between.js';
+import { OpEq } from './sql-objects/operators/op-eq.js';
+import { OpExists } from './sql-objects/operators/op-exists.js';
+import { OpGt } from './sql-objects/operators/op-gt.js';
+import { OpGte } from './sql-objects/operators/op-gte.js';
+import { OpILike } from './sql-objects/operators/op-ilike.js';
+import { OpIn } from './sql-objects/operators/op-in.js';
+import { OpIs } from './sql-objects/operators/op-is.js';
+import { OpIsNot } from './sql-objects/operators/op-is-not.js';
+import { OpLike } from './sql-objects/operators/op-like.js';
+import { OpLt } from './sql-objects/operators/op-lt.js';
+import { OpLte } from './sql-objects/operators/op-lte.js';
+import { OpNe } from './sql-objects/operators/op-ne.js';
+import { OpNotBetween } from './sql-objects/operators/op-not-between.js';
+import { OpNotExists } from './sql-objects/operators/op-not-exists.js';
+import { OpNotILike } from './sql-objects/operators/op-not-ilike.js';
+import { OpNotIn } from './sql-objects/operators/op-not-in.js';
+import { OpNotLike } from './sql-objects/operators/op-not-like.js';
+import { OpOr } from './sql-objects/operators/op-or.js';
+function And(...args) {
+    return new OpAnd(...args);
+}
+function Or(...args) {
+    return new OpOr(...args);
+}
+function Eq(expression, value) {
+    return new OpEq(expression, value);
+}
+function Ne(expression, value) {
+    return new OpNe(expression, value);
+}
+function Gt(expression, value) {
+    return new OpGt(expression, value);
+}
+function Gte(expression, value) {
+    return new OpGte(expression, value);
+}
+function Lt(expression, value) {
+    return new OpLt(expression, value);
+}
+function Lte(expression, value) {
+    return new OpLte(expression, value);
+}
+function Between(expression, value1, value2) {
+    const values = Array.isArray(value1) ? value1 : [value1, value2];
+    return new OpBetween(expression, values);
+}
+function NotBetween(expression, value1, value2) {
+    const values = Array.isArray(value1) ? value1 : [value1, value2];
+    return new OpNotBetween(expression, values);
+}
+function In(expression, value) {
+    return new OpIn(expression, value);
+}
+function NotIn(expression, value) {
+    return new OpNotIn(expression, value);
+}
+function Like(expression, value) {
+    return new OpLike(expression, value);
+}
+function NotLike(expression, value) {
+    return new OpNotLike(expression, value);
+}
+function Ilike(expression, value) {
+    return new OpILike(expression, value);
+}
+function NotILike(expression, value) {
+    return new OpNotILike(expression, value);
+}
+function Is(expression, value) {
+    return new OpIs(expression, value);
+}
+function IsNot(expression, value) {
+    return new OpIsNot(expression, value);
+}
+function Exists(expression) {
+    return new OpExists(expression);
+}
+function NotExists(expression) {
+    return new OpNotExists(expression);
+}
+const op = {
+    and: And,
+    or: Or,
+    eq: Eq,
+    '=': Eq,
+    ne: Ne,
+    '!=': Ne,
+    gt: Gt,
+    '>': Gt,
+    gte: Gte,
+    '>=': Gte,
+    lt: Lt,
+    '<': Lt,
+    lte: Lte,
+    '<=': Lte,
+    between: Between,
+    btw: Between,
+    notBetween: NotBetween,
+    nbtw: NotBetween,
+    '!between': NotBetween,
+    '!btw': NotBetween,
+    in: In,
+    notIn: NotIn,
+    nin: NotIn,
+    '!in': NotIn,
+    like: Like,
+    notLike: NotLike,
+    nlike: NotLike,
+    '!like': NotLike,
+    ilike: Ilike,
+    notILike: NotILike,
+    nilike: NotILike,
+    '!ilike': NotILike,
+    is: Is,
+    isNot: IsNot,
+    '!is': IsNot,
+    exists: Exists,
+    notExists: NotExists,
+    '!exists': NotExists
+};
+Object.assign(WrapOps, op);
+export { op };
+export { And, Or, Eq, Eq as Equal, Ne, Ne as NotEqual, Gt, Gt as GreaterThan, Gte, Gte as GreaterAnEqualTo, Lt, Lt as LowerThan, Lte, Lte as LowerAndEqualTo, Between, NotBetween, In, NotIn, NotIn as Nin, Like, NotLike, NotLike as NLike, Ilike, NotILike, NotILike as Nilike, Is, IsNot, Exists, NotExists };

package/{dist/query/DeleteQuery.d.ts → esm/query/delete-query.d.ts}

@@ -1,9 +1,9 @@
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import { LogicalOperator } from '../sql-objects/operators/LogicalOperator';
-import { RawStatement } from '../sql-objects/RawStatement';
-import { TableName } from '../sql-objects/TableName';
-import { Query } from './Query';
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { LogicalOperator } from '../sql-objects/operators/logical-operator.js';
+import { RawStatement } from '../sql-objects/raw-statement.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { Query } from './query.js';
 export declare class DeleteQuery extends Query {
     _table: TableName | RawStatement;
     _where?: LogicalOperator;

package/esm/query/delete-query.js

@@ -0,0 +1,51 @@
+import { SerializationType } from '../enums.js';
+import { OpAnd } from '../sql-objects/operators/op-and.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { isRawStatement } from '../typeguards.js';
+import { Query } from './query.js';
+export class DeleteQuery extends Query {
+    _table;
+    _where;
+    constructor(tableName) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || isRawStatement(tableName)))
+            throw new TypeError('String or Raw instance required as first argument (tableName) for UpdateQuery');
+        this._table = typeof tableName === 'string' ? new TableName(tableName) : tableName;
+    }
+    get _type() {
+        return SerializationType.DELETE_QUERY;
+    }
+    /**
+     * Defines "where" part of query
+     */
+    where(...operator) {
+        this._where = this._where || new OpAnd();
+        this._where.add(...operator);
+        return this;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            table: this._table._serialize(ctx),
+            where: this._serializeWhere(ctx)
+        };
+        let out = 'delete from ' + o.table;
+        if (o.where)
+            out += '\n' + o.where;
+        return out;
+    }
+    /**
+     *
+     */
+    _serializeWhere(ctx) {
+        if (!this._where)
+            return '';
+        const s = this._where._serialize(ctx);
+        return ctx.serialize(SerializationType.CONDITIONS_BLOCK, s, () => {
+            /* istanbul ignore next */
+            return s ? 'where ' + s : '';
+        });
+    }
+}

package/{dist/query/InsertQuery.d.ts → esm/query/insert-query.d.ts}

@@ -1,8 +1,8 @@
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import type { RawStatement } from '../sql-objects/RawStatement';
-import { TableName } from '../sql-objects/TableName';
-import { ReturningQuery } from './ReturningQuery';
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import type { RawStatement } from '../sql-objects/raw-statement.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { ReturningQuery } from './returning-query.js';
 export declare class InsertQuery extends ReturningQuery {
     _table: TableName | RawStatement;
     _input: any;

package/esm/query/insert-query.js

@@ -0,0 +1,73 @@
+import { SerializationType } from '../enums.js';
+import { printArray } from '../helpers.js';
+import { TableName } from '../sql-objects/table-name.js';
+import { isRawStatement, isSelectQuery, isSerializable } from '../typeguards.js';
+import { ReturningQuery } from './returning-query.js';
+export class InsertQuery extends ReturningQuery {
+    _table;
+    _input;
+    constructor(tableName, input) {
+        super();
+        if (!tableName || !(typeof tableName === 'string' || isRawStatement(tableName)))
+            throw new TypeError('String or Raw instance required as first argument (tableName) for InsertQuery');
+        if (!input || !((typeof input === 'object' && !Array.isArray(input)) ||
+            input.isSelect))
+            throw new TypeError('Object or SelectQuery instance required as second argument (input) for InsertQuery');
+        this._table = typeof tableName === 'string' ? new TableName(tableName) : tableName;
+        this._input = input;
+    }
+    get _type() {
+        return SerializationType.INSERT_QUERY;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            table: this._table._serialize(ctx),
+            columns: this.__serializeColumns(ctx),
+            values: this.__serializeValues(ctx),
+            returning: this.__serializeReturning(ctx)
+        };
+        let out = 'insert into ' + o.table + '\n\t(' +
+            o.columns + ')\n\bvalues\n\t(' + o.values + ')\b';
+        if (o.returning)
+            out += '\n' + o.returning;
+        return out;
+    }
+    /**
+     *
+     */
+    __serializeColumns(ctx) {
+        let arr;
+        if (isSelectQuery(this._input)) {
+            arr = [];
+            const cols = this._input._columns;
+            if (cols) {
+                for (const col of cols) {
+                    if (col._alias)
+                        arr.push(col._alias);
+                    else if (col._field)
+                        arr.push(col._field);
+                }
+            }
+        }
+        else
+            arr = Object.keys(this._input);
+        return ctx.serialize(SerializationType.INSERT_QUERY_COLUMNS, arr, () => printArray(arr));
+    }
+    /**
+     *
+     */
+    __serializeValues(ctx) {
+        if (isSerializable(this._input))
+            return this._input._serialize(ctx);
+        const arr = [];
+        const allValues = this._input;
+        for (const n of Object.keys(allValues)) {
+            const s = ctx.anyToSQL(allValues[n]) || 'null';
+            arr.push(s);
+        }
+        return ctx.serialize(SerializationType.INSERT_QUERY_VALUES, arr, () => printArray(arr));
+    }
+}

package/{dist/query/Query.d.ts → esm/query/query.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { Serializable } from '../Serializable';
-import { GenerateOptions, GenerateResult } from '../types';
+import { Serializable } from '../serializable.js';
+import { GenerateOptions, GenerateResult } from '../types.js';
 export declare interface Query extends EventEmitter {
 }
 export declare abstract class Query extends Serializable {

package/esm/query/query.js

@@ -0,0 +1,36 @@
+import { EventEmitter } from 'events';
+import flattenText from 'putil-flattentext';
+import merge from 'putil-merge';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+export class Query extends Serializable {
+    _params;
+    constructor() {
+        super();
+        EventEmitter.call(this);
+    }
+    /**
+     * Generates Sql script
+     */
+    generate(options) {
+        const ctx = new SerializeContext(options);
+        if (this._params)
+            ctx.params = { ...ctx.params, ...this._params };
+        ctx.serializeHooks = this.listeners('serialize');
+        /* generate output */
+        const sql = this._serialize(ctx);
+        return {
+            sql: flattenText(sql, { noWrap: !ctx.prettyPrint }),
+            params: ctx.preparedParams,
+            paramOptions: ctx.paramOptions,
+            returningFields: ctx.returningFields
+        };
+    }
+    values(obj) {
+        if (typeof obj !== 'object' || Array.isArray(obj))
+            throw new TypeError('Invalid argument');
+        this._params = obj;
+        return this;
+    }
+}
+merge(Query.prototype, EventEmitter.prototype, { descriptor: true });

package/{dist/query/ReturningQuery.d.ts → esm/query/returning-query.d.ts}

@@ -1,6 +1,6 @@
-import { SerializeContext } from '../SerializeContext';
-import { ReturningColumn } from '../sql-objects/ReturningColumn';
-import { Query } from './Query';
+import { SerializeContext } from '../serialize-context.js';
+import { ReturningColumn } from '../sql-objects/returning-column.js';
+import { Query } from './query.js';
 export declare abstract class ReturningQuery extends Query {
     _returningColumns?: ReturningColumn[];
     /**

package/esm/query/returning-query.js

@@ -0,0 +1,41 @@
+import { SerializationType } from '../enums.js';
+import { printArray } from '../helpers.js';
+import { ReturningColumn } from '../sql-objects/returning-column.js';
+import { Query } from './query.js';
+export class ReturningQuery extends Query {
+    _returningColumns;
+    /**
+     *
+     */
+    returning(...columns) {
+        if (!columns)
+            return this;
+        // noinspection JSMismatchedCollectionQueryUpdate
+        this._returningColumns = columns.length ?
+            columns.reduce((a, v) => {
+                if (v)
+                    a.push(new ReturningColumn(v));
+                return a;
+            }, []) : undefined;
+        return this;
+    }
+    /**
+     *
+     */
+    __serializeReturning(ctx) {
+        if (!(this._returningColumns && this._returningColumns.length))
+            return '';
+        const arr = [];
+        ctx.returningFields = [];
+        for (const t of this._returningColumns) {
+            const s = t._serialize(ctx);
+            /* istanbul ignore else */
+            if (s)
+                arr.push(s);
+        }
+        return ctx.serialize(SerializationType.RETURNING_BLOCK, arr, () => {
+            const s = printArray(arr);
+            return s ? 'returning ' + s : '';
+        });
+    }
+}