@sqb/builder 4.1.5 → 4.5.0

package/esm/sql-objects/param-expression.js

@@ -0,0 +1,52 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class ParamExpression extends Serializable {
+    _name;
+    _dataType;
+    _isArray;
+    constructor(arg) {
+        super();
+        if (typeof arg === 'object') {
+            this._name = arg.name;
+            this._dataType = arg.dataType;
+            this._isArray = arg.isArray;
+        }
+        else
+            this._name = arg;
+    }
+    get _type() {
+        return SerializationType.EXTERNAL_PARAMETER;
+    }
+    /**
+     * Performs serialization
+     */
+    _serialize(ctx) {
+        const o = {
+            name: this._name,
+            dataType: this._dataType,
+            isArray: this._isArray,
+        };
+        return ctx.serialize(this._type, o, () => this.__defaultSerialize(ctx, o));
+    }
+    __defaultSerialize(ctx, o) {
+        let prmValue = (ctx.params && ctx.params[o.name]) ?? null;
+        if (prmValue != null && o.isArray && !Array.isArray(prmValue))
+            prmValue = [prmValue];
+        ctx.preparedParams = ctx.preparedParams || {};
+        if (Array.isArray(ctx.preparedParams))
+            ctx.preparedParams.push(prmValue);
+        else
+            ctx.preparedParams[o.name] = prmValue;
+        const paramOps = {
+            dataType: this._dataType,
+            isArray: this._isArray,
+        };
+        ctx.paramOptions = ctx.paramOptions ||
+            (Array.isArray(ctx.preparedParams) ? [] : {});
+        if (Array.isArray(ctx.paramOptions))
+            ctx.paramOptions.push(paramOps);
+        else
+            ctx.paramOptions[o.name] = paramOps;
+        return ':' + o.name;
+    }
+}

package/{dist/sql-objects/RawStatement.d.ts → esm/sql-objects/raw-statement.d.ts}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
 export declare class RawStatement extends Serializable {
     _text: string;
     constructor(str: string);

package/esm/sql-objects/raw-statement.js

@@ -0,0 +1,15 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class RawStatement extends Serializable {
+    _text;
+    constructor(str) {
+        super();
+        this._text = str;
+    }
+    get _type() {
+        return SerializationType.RAW;
+    }
+    _serialize(ctx) {
+        return ctx.serialize(this._type, this._text, () => this._text);
+    }
+}

package/{dist/sql-objects/ReturningColumn.d.ts → esm/sql-objects/returning-column.d.ts}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums';
-import { SerializeContext } from '../SerializeContext';
-import { BaseField } from './BaseField';
+import { SerializationType } from '../enums.js';
+import { SerializeContext } from '../serialize-context.js';
+import { BaseField } from './base-field.js';
 export declare class ReturningColumn extends BaseField {
     _alias: string;
     constructor(field: string);

package/esm/sql-objects/returning-column.js

@@ -0,0 +1,29 @@
+import { SerializationType } from '../enums.js';
+import { BaseField } from './base-field.js';
+const RETURNING_COLUMN_PATTERN = /^([a-zA-Z]\w*) *(?:as)? *(\w+)?$/;
+export class ReturningColumn extends BaseField {
+    _alias;
+    constructor(field) {
+        super();
+        const m = field.match(RETURNING_COLUMN_PATTERN);
+        if (!m)
+            throw new TypeError(`"${field}" does not match returning column format`);
+        this._field = m[1];
+        this._alias = m[2];
+    }
+    get _type() {
+        return SerializationType.RETURNING_COLUMN;
+    }
+    _serialize(ctx) {
+        const o = {
+            field: this._field,
+            alias: this._alias
+        };
+        ctx.returningFields = ctx.returningFields || [];
+        ctx.returningFields.push(o);
+        return ctx.serialize(this._type, o, () => {
+            return ctx.escapeReserved(o.field) +
+                (o.alias ? ' as ' + ctx.escapeReserved(o.alias) : '');
+        });
+    }
+}

package/esm/sql-objects/sequence-getter-statement.d.ts

@@ -0,0 +1,24 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+export declare class SequenceGetterStatement extends Serializable {
+    _expression: string;
+    _next: boolean;
+    _alias?: string;
+    constructor(expression: string, next?: boolean);
+    get _type(): SerializationType;
+    next(value: boolean): this;
+    /**
+     * 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/esm/sql-objects/sequence-getter-statement.js

@@ -0,0 +1,47 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class SequenceGetterStatement extends Serializable {
+    _expression;
+    _next;
+    _alias;
+    constructor(expression, next) {
+        super();
+        this._expression = expression;
+        this._next = !!next;
+    }
+    get _type() {
+        return SerializationType.SEQUENCE_GETTER_STATEMENT;
+    }
+    next(value) {
+        this._next = value;
+        return this;
+    }
+    /**
+     * 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 = {
+            genName: this._expression,
+            next: this._next,
+            alias: this._alias
+        };
+        return ctx.serialize(this._type, q, () => this.__defaultSerialize(ctx, q));
+    }
+    __defaultSerialize(ctx, o) {
+        return (o.next ? 'nextval' : 'currval') + '(\'' + o.genName + '\')' +
+            (o.alias ? ' ' + o.alias : '');
+    }
+}

package/esm/sql-objects/string-agg-statement.d.ts

@@ -0,0 +1,31 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+import { OrderColumn } from './order-column.js';
+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/esm/sql-objects/string-agg-statement.js

@@ -0,0 +1,78 @@
+import { SerializationType } from '../enums.js';
+import { printArray } from '../helpers.js';
+import { Serializable } from '../serializable.js';
+import { FieldExpression } from './field-expression.js';
+import { OrderColumn } from './order-column.js';
+export class StringAGGStatement extends Serializable {
+    _field;
+    _delimiter;
+    _orderBy;
+    _alias;
+    constructor(field, delimiter) {
+        super();
+        this._field = typeof field === 'string' ? new FieldExpression(field) : field;
+        this._delimiter = delimiter || ',';
+    }
+    get _type() {
+        return 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(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(SerializationType.SELECT_QUERY_ORDERBY, arr, () => {
+            const s = 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 : '');
+    }
+}

package/{dist/sql-objects/TableName.d.ts → esm/sql-objects/table-name.d.ts}

@@ -1,6 +1,6 @@
-import { SerializationType } from '../enums';
-import { Serializable } from '../Serializable';
-import { SerializeContext } from '../SerializeContext';
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
 export declare class TableName extends Serializable {
     schema?: string;
     table?: string;

package/esm/sql-objects/table-name.js

@@ -0,0 +1,30 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class TableName extends Serializable {
+    schema;
+    table;
+    alias;
+    constructor(tableName) {
+        super();
+        const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
+        if (!m)
+            throw new TypeError(`(${tableName}) does not match table name format`);
+        if (m[1])
+            this.schema = m[1];
+        if (m[2])
+            this.table = m[2];
+        if (m[3])
+            this.alias = m[3];
+    }
+    get _type() {
+        return SerializationType.TABLE_NAME;
+    }
+    _serialize(ctx) {
+        return ctx.serialize(this._type, {
+            schema: this.schema,
+            table: this.table,
+            alias: this.alias
+        }, () => (this.schema ? this.schema + '.' : '') + this.table +
+            (this.alias ? ' ' + this.alias : ''));
+    }
+}

package/esm/sql-objects/upper-statement.d.ts

@@ -0,0 +1,22 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+import { SerializeContext } from '../serialize-context.js';
+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/esm/sql-objects/upper-statement.js

@@ -0,0 +1,37 @@
+import { SerializationType } from '../enums.js';
+import { Serializable } from '../serializable.js';
+export class UpperStatement extends Serializable {
+    _expression;
+    _alias;
+    constructor(expression) {
+        super();
+        this._expression = expression;
+    }
+    get _type() {
+        return 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 : '');
+    }
+}

package/esm/sqlobject.initializers.d.ts

@@ -0,0 +1,54 @@
+import { DataType } from './enums.js';
+import { DeleteQuery } from './query/delete-query.js';
+import { InsertQuery } from './query/insert-query.js';
+import { SelectQuery } from './query/select-query.js';
+import { UpdateQuery } from './query/update-query.js';
+import { Serializable } from './serializable.js';
+import { CaseStatement } from './sql-objects/case-statement.js';
+import { CoalesceStatement } from './sql-objects/coalesce-statement.js';
+import { CountStatement } from './sql-objects/count-statement.js';
+import { FieldExpression } from './sql-objects/field-expression.js';
+import { JoinStatement } from './sql-objects/join-statement.js';
+import { LowerStatement } from './sql-objects/lower-statement.js';
+import { MaxStatement } from './sql-objects/max-statement.js';
+import { MinStatement } from './sql-objects/min-statement.js';
+import { ParamExpression } from './sql-objects/param-expression.js';
+import { RawStatement } from './sql-objects/raw-statement.js';
+import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
+import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
+import { UpperStatement } from './sql-objects/upper-statement.js';
+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 Coalesce(...expressions: any[]): CoalesceStatement;
+export declare function Lower(expression: any): LowerStatement;
+export declare function Upper(expression: any): UpperStatement;
+export declare function Min(expression: any): MinStatement;
+export declare function Max(expression: any): MaxStatement;
+export declare function StringAGG(field: any): StringAGGStatement;
+export declare function Count(): CountStatement;
+export declare function SequenceNext(expression: string): SequenceGetterStatement;
+export declare function SequenceCurr(expression: string): SequenceGetterStatement;
+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/esm/sqlobject.initializers.js

@@ -0,0 +1,101 @@
+import { JoinType } from './enums.js';
+import { DeleteQuery } from './query/delete-query.js';
+import { InsertQuery } from './query/insert-query.js';
+import { SelectQuery } from './query/select-query.js';
+import { UpdateQuery } from './query/update-query.js';
+import { CaseStatement } from './sql-objects/case-statement.js';
+import { CoalesceStatement } from './sql-objects/coalesce-statement.js';
+import { CountStatement } from './sql-objects/count-statement.js';
+import { FieldExpression } from './sql-objects/field-expression.js';
+import { JoinStatement } from './sql-objects/join-statement.js';
+import { LowerStatement } from './sql-objects/lower-statement.js';
+import { MaxStatement } from './sql-objects/max-statement.js';
+import { MinStatement } from './sql-objects/min-statement.js';
+import { ParamExpression } from './sql-objects/param-expression.js';
+import { RawStatement } from './sql-objects/raw-statement.js';
+import { SequenceGetterStatement } from './sql-objects/sequence-getter-statement.js';
+import { StringAGGStatement } from './sql-objects/string-agg-statement.js';
+import { UpperStatement } from './sql-objects/upper-statement.js';
+export function Raw(text) {
+    return new RawStatement(text);
+}
+export function Select(...column) {
+    return new SelectQuery(...column);
+}
+export function Insert(tableName, input) {
+    return new InsertQuery(tableName, input);
+}
+export function Update(tableName, input) {
+    return new UpdateQuery(tableName, input);
+}
+export function Delete(tableName) {
+    return new DeleteQuery(tableName);
+}
+export function Join(table) {
+    return new JoinStatement(JoinType.INNER, table);
+}
+export function InnerJoin(table) {
+    return new JoinStatement(JoinType.INNER, table);
+}
+export function LeftJoin(table) {
+    return new JoinStatement(JoinType.LEFT, table);
+}
+export function LeftOuterJoin(table) {
+    return new JoinStatement(JoinType.LEFT_OUTER, table);
+}
+export function RightJoin(table) {
+    return new JoinStatement(JoinType.RIGHT, table);
+}
+export function RightOuterJoin(table) {
+    return new JoinStatement(JoinType.RIGHT_OUTER, table);
+}
+export function OuterJoin(table) {
+    return new JoinStatement(JoinType.OUTER, table);
+}
+export function FullOuterJoin(table) {
+    return new JoinStatement(JoinType.FULL_OUTER, table);
+}
+export function Case() {
+    return new CaseStatement();
+}
+export function Coalesce(...expressions) {
+    return new CoalesceStatement(...expressions);
+}
+export function Lower(expression) {
+    return new LowerStatement(expression);
+}
+export function Upper(expression) {
+    return new UpperStatement(expression);
+}
+export function Min(expression) {
+    return new MinStatement(expression);
+}
+export function Max(expression) {
+    return new MaxStatement(expression);
+}
+export function StringAGG(field) {
+    return new StringAGGStatement(field);
+}
+export function Count() {
+    return new CountStatement();
+}
+export function SequenceNext(expression) {
+    return new SequenceGetterStatement(expression, true);
+}
+export function SequenceCurr(expression) {
+    return new SequenceGetterStatement(expression, false);
+}
+export function Param(arg0, arg1, arg2) {
+    if (typeof arg0 === 'object')
+        return new ParamExpression(arg0);
+    return new ParamExpression({
+        name: arg0,
+        dataType: arg1,
+        isArray: arg2
+    });
+}
+export function Field(arg0, arg1, arg2) {
+    if (typeof arg0 === 'object')
+        return new FieldExpression(arg0);
+    return new FieldExpression(arg0, arg1, arg2);
+}

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

@@ -1,21 +1,22 @@
-import type { DeleteQuery } from './query/DeleteQuery';
-import type { InsertQuery } from './query/InsertQuery';
-import type { SelectQuery } from './query/SelectQuery';
-import type { UpdateQuery } from './query/UpdateQuery';
-import { Serializable } from './Serializable';
-import type { CaseStatement } from './sql-objects/CaseStatement';
-import { CountStatement } from './sql-objects/CountStatement';
-import type { FieldExpression } from './sql-objects/FieldExpression';
-import type { GroupColumn } from './sql-objects/GroupColumn';
-import type { JoinStatement } from './sql-objects/JoinStatement';
-import type { CompOperator } from './sql-objects/operators/CompOperator';
-import type { LogicalOperator } from './sql-objects/operators/LogicalOperator';
-import type { OrderColumn } from './sql-objects/OrderColumn';
-import type { ParamExpression } from './sql-objects/ParamExpression';
-import type { RawStatement } from './sql-objects/RawStatement';
-import type { ReturningColumn } from './sql-objects/ReturningColumn';
-import type { TableName } from './sql-objects/TableName';
+import type { DeleteQuery } from './query/delete-query.js';
+import type { InsertQuery } from './query/insert-query.js';
+import type { SelectQuery } from './query/select-query.js';
+import type { UpdateQuery } from './query/update-query.js';
+import { Serializable } from './serializable.js';
+import type { CaseStatement } from './sql-objects/case-statement.js';
+import { CountStatement } from './sql-objects/count-statement.js';
+import type { FieldExpression } from './sql-objects/field-expression.js';
+import type { GroupColumn } from './sql-objects/group-column.js';
+import type { JoinStatement } from './sql-objects/join-statement.js';
+import type { CompOperator } from './sql-objects/operators/comp-operator.js';
+import type { LogicalOperator } from './sql-objects/operators/logical-operator.js';
+import type { OrderColumn } from './sql-objects/order-column.js';
+import type { ParamExpression } from './sql-objects/param-expression.js';
+import type { RawStatement } from './sql-objects/raw-statement.js';
+import type { ReturningColumn } from './sql-objects/returning-column.js';
+import type { TableName } from './sql-objects/table-name.js';
 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/esm/typeguards.js

@@ -0,0 +1,57 @@
+import { SerializationType } from './enums.js';
+import { Query } from './query/query.js';
+import { Serializable } from './serializable.js';
+export function isSerializable(value) {
+    return value instanceof Serializable;
+}
+export function isQuery(value) {
+    return value instanceof Query;
+}
+export function isRawStatement(value) {
+    return isSerializable(value) && value._type === SerializationType.RAW;
+}
+export function isSelectQuery(value) {
+    return isSerializable(value) && value._type === SerializationType.SELECT_QUERY;
+}
+export function isInsertQuery(value) {
+    return isSerializable(value) && value._type === SerializationType.INSERT_QUERY;
+}
+export function isIUpdateQuery(value) {
+    return isSerializable(value) && value._type === SerializationType.UPDATE_QUERY;
+}
+export function isDeleteQuery(value) {
+    return isSerializable(value) && value._type === SerializationType.DELETE_QUERY;
+}
+export function isJoinStatement(value) {
+    return isSerializable(value) && value._type === SerializationType.JOIN;
+}
+export function isCaseStatement(value) {
+    return isSerializable(value) && value._type === SerializationType.CASE_STATEMENT;
+}
+export function isCountStatement(value) {
+    return isSerializable(value) && value._type === SerializationType.COUNT_STATEMENT;
+}
+export function isParamExpression(value) {
+    return isSerializable(value) && value._type === SerializationType.EXTERNAL_PARAMETER;
+}
+export function isLogicalOperator(value) {
+    return isSerializable(value) && value._type === SerializationType.LOGICAL_EXPRESSION;
+}
+export function isCompOperator(value) {
+    return isSerializable(value) && value._type === SerializationType.COMPARISON_EXPRESSION;
+}
+export function isSelectColumn(value) {
+    return isSerializable(value) && value._type === SerializationType.SELECT_COLUMN;
+}
+export function isOrderColumn(value) {
+    return isSerializable(value) && value._type === SerializationType.ORDER_COLUMN;
+}
+export function isGroupColumn(value) {
+    return isSerializable(value) && value._type === SerializationType.GROUP_COLUMN;
+}
+export function isReturningColumn(value) {
+    return isSerializable(value) && value._type === SerializationType.RETURNING_COLUMN;
+}
+export function isTableName(value) {
+    return isSerializable(value) && value._type === SerializationType.TABLE_NAME;
+}