@sqb/builder 5.0.0 → 5.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/builder",
   "description": "Extensible multi-dialect SQL query builder written with TypeScript",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {

package/serializable.d.ts

@@ -1,16 +1,18 @@
 import type { SerializationType } from './enums.js';
 import type { SerializeContext } from './serialize-context.js';
-export interface Serializable {
+export interface SqlElement {
     _type: SerializationType;
     /**
      * Performs serialization
      */
     _serialize(ctx: SerializeContext): string;
 }
-interface SerializableCtor {
-    new (): Serializable;
-    (): Serializable;
-    prototype: Serializable;
+interface SqlElementCtor {
+    new (): SqlElement;
+    (): SqlElement;
+    prototype: SqlElement;
 }
-export declare const Serializable: SerializableCtor;
+export declare const SqlElement: SqlElementCtor;
+export declare const Serializable: SqlElementCtor;
+export type Serializable = SqlElement;
 export {};

package/serializable.js

@@ -1,7 +1,9 @@
-export const Serializable = function () {
+export const SqlElement = function () {
     if (!this)
-        return new Serializable();
-    if (this.constructor === Serializable) {
-        throw new TypeError('Serializable is abstract and cannot be instantiated');
+        return new SqlElement();
+    if (this.constructor === SqlElement) {
+        throw new TypeError('SqlElement is abstract and cannot be instantiated');
     }
 };
+/* Backward compatibility */
+export const Serializable = SqlElement;

package/serialize-context.js

@@ -1,6 +1,6 @@
 import { SerializationType } from './enums.js';
 import { SerializerRegistry } from './extensions.js';
-import { Serializable } from './serializable.js';
+import { SqlElement } from './serializable.js';
 import { isLogicalOperator, isQuery, isSerializable } from './type-guards.js';
 export class SerializeContext {
     rootQuery;
@@ -131,7 +131,7 @@ export class SerializeContext {
         if (typeof v === 'number') {
             return this.serialize(SerializationType.NUMBER_VALUE, v, () => this.numberToSQL(v));
         }
-        if (v instanceof Serializable)
+        if (v instanceof SqlElement)
             return v._serialize(this);
         return v;
     }

package/sql/elements/base-field.d.ts

@@ -1,6 +1,6 @@
 import { DataType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-export interface BaseField extends Serializable {
+import { SqlElement } from '../../serializable.js';
+export interface BaseField extends SqlElement {
     _dataType?: DataType;
     _isArray?: boolean;
     _isDataSet?: boolean;

package/sql/elements/base-field.js

@@ -1,12 +1,12 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 export const BaseField = function () {
     if (!(this instanceof BaseField))
         return new BaseField();
     if (this.constructor === BaseField) {
         throw new TypeError('BaseField is abstract and cannot be instantiated');
     }
-    Serializable.call(this);
+    SqlElement.call(this);
     this._field = '';
 };
-BaseField.prototype = Object.create(Serializable.prototype);
+BaseField.prototype = Object.create(SqlElement.prototype);
 BaseField.prototype.constructor = BaseField;

package/sql/elements/case.d.ts

@@ -1,12 +1,12 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { LogicalOperator } from '../operators/logical-operator.js';
 import { Operator } from '../operators/operator.js';
 import { Raw } from './raw.js';
-declare class CaseClass extends Serializable {
+declare class CaseClass extends SqlElement {
     _expressions: {
-        condition: Serializable;
+        condition: SqlElement;
         value: any;
     }[];
     _elseValue: any;

package/sql/elements/case.js

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { And } from '../operators/and.js';
-class CaseClass extends Serializable {
+class CaseClass extends SqlElement {
     _expressions;
     _elseValue;
     _condition;
@@ -84,7 +84,7 @@ class CaseClass extends Serializable {
 export const Case = function () {
     if (!(this instanceof Case))
         return new Case();
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expressions = [];
 };
 Case.prototype = CaseClass.prototype;

package/sql/elements/coalesce.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class CoalesceClass extends Serializable {
+declare class CoalesceClass extends SqlElement {
     _expressions: any[];
     _alias?: string;
     get _type(): SerializationType;

package/sql/elements/coalesce.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class CoalesceClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class CoalesceClass extends SqlElement {
     _expressions;
     _alias;
     get _type() {
@@ -41,7 +41,7 @@ class CoalesceClass extends Serializable {
 export const Coalesce = function (...expressions) {
     if (!(this instanceof Coalesce))
         return new Coalesce(...expressions);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expressions = expressions;
 };
 Coalesce.prototype = CoalesceClass.prototype;

package/sql/elements/count.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class CountClass extends Serializable {
+declare class CountClass extends SqlElement {
     _alias?: string;
     get _type(): SerializationType;
     /**

package/sql/elements/count.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class CountClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class CountClass extends SqlElement {
     _alias;
     get _type() {
         return SerializationType.COUNT_STATEMENT;
@@ -34,7 +34,7 @@ class CountClass extends Serializable {
 export const Count = function () {
     if (!(this instanceof Count))
         return new Count();
-    Serializable.call(this);
+    SqlElement.call(this);
 };
 Count.prototype = CountClass.prototype;
 Count.prototype.constructor = Count;

package/sql/elements/join.d.ts

@@ -1,16 +1,16 @@
 import { JoinType, SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import type { SerializeContext } from '../../serialize-context.js';
 import type { LogicalOperator } from '../operators/logical-operator.js';
 import type { Select } from '../select.js';
 import type { Raw } from './raw.js';
 import { TableName } from './table-name.js';
-declare class JoinClass extends Serializable {
+declare class JoinClass extends SqlElement {
     _joinType: JoinType;
     _table: TableName | Select | Raw;
     _conditions: LogicalOperator;
     get _type(): SerializationType;
-    on(...conditions: Serializable[]): this;
+    on(...conditions: SqlElement[]): this;
     _serialize(ctx: SerializeContext): string;
     protected __serializeConditions(ctx: any, join: JoinClass): any;
 }

package/sql/elements/join.js

@@ -1,9 +1,9 @@
 import { JoinType, SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { isRaw, isSelect, isTableName } from '../../type-guards.js';
 import { And } from '../operators/and.js';
 import { TableName } from './table-name.js';
-class JoinClass extends Serializable {
+class JoinClass extends SqlElement {
     _joinType;
     _table;
     _conditions = new And();
@@ -79,7 +79,7 @@ class JoinClass extends Serializable {
 export const Join = function (joinType, table) {
     if (!(this instanceof Join))
         return new Join(joinType, table);
-    Serializable.call(this);
+    SqlElement.call(this);
     // noinspection SuspiciousTypeOfGuard
     if (!(isSelect(table) ||
         isRaw(table) ||

package/sql/elements/lower.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class LowerClass extends Serializable {
+declare class LowerClass extends SqlElement {
     _expression: any;
     _alias?: string;
     get _type(): SerializationType;

package/sql/elements/lower.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class LowerClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class LowerClass extends SqlElement {
     _expression;
     _alias;
     get _type() {
@@ -33,7 +33,7 @@ class LowerClass extends Serializable {
 export const Lower = function (expression) {
     if (!(this instanceof Lower))
         return new Lower(expression);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expression = expression;
 };
 Lower.prototype = LowerClass.prototype;

package/sql/elements/max.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class MaxClass extends Serializable {
+declare class MaxClass extends SqlElement {
     _expression: any;
     _alias?: string;
     get _type(): SerializationType;

package/sql/elements/max.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class MaxClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class MaxClass extends SqlElement {
     _expression;
     _alias;
     get _type() {
@@ -33,7 +33,7 @@ class MaxClass extends Serializable {
 export const Max = function (expression) {
     if (!(this instanceof Max))
         return new Max(expression);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expression = expression;
 };
 Max.prototype = MaxClass.prototype;

package/sql/elements/min.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class MinClass extends Serializable {
+declare class MinClass extends SqlElement {
     _expression: any;
     _alias?: string;
     constructor(expression: any);

package/sql/elements/min.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class MinClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class MinClass extends SqlElement {
     _expression;
     _alias;
     constructor(expression) {

package/sql/elements/order-column.js

@@ -1,5 +1,5 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { BaseField } from './base-field.js';
 const ORDER_COLUMN_PATTERN = /^([-+])?((?:[a-zA-Z_][\w$]*\.){0,2})([a-zA-Z_][\w$]*|\*) *(asc|dsc|desc|ascending|descending)?$/i;
 class OrderColumnClass extends BaseField {
@@ -23,7 +23,7 @@ class OrderColumnClass extends BaseField {
 export const OrderColumn = function (value) {
     if (!(this instanceof OrderColumn))
         return new OrderColumn(value);
-    Serializable.call(this);
+    SqlElement.call(this);
     const m = value.match(ORDER_COLUMN_PATTERN);
     if (!m)
         throw new TypeError(`"${value}" does not match order column format`);

package/sql/elements/param.d.ts

@@ -1,7 +1,7 @@
 import { DataType, SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class ParamClass extends Serializable {
+declare class ParamClass extends SqlElement {
     _name: string;
     _dataType?: DataType;
     _isArray?: boolean;

package/sql/elements/param.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class ParamClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class ParamClass extends SqlElement {
     _name;
     _dataType;
     _isArray;
@@ -56,7 +56,7 @@ export const Param = function (...varArgs) {
     }
     if (!(this instanceof Param))
         return new Param(args);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._name = args.name;
     this._dataType = args.dataType;
     this._isArray = args.isArray;

package/sql/elements/raw.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class RawClass extends Serializable {
+declare class RawClass extends SqlElement {
     _text: string;
     get _type(): SerializationType;
     _serialize(ctx: SerializeContext): string;

package/sql/elements/raw.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class RawClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class RawClass extends SqlElement {
     _text;
     get _type() {
         return SerializationType.RAW;
@@ -12,7 +12,7 @@ class RawClass extends Serializable {
 export const Raw = function (str) {
     if (!(this instanceof Raw))
         return new Raw(str);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._text = str;
 };
 Raw.prototype = RawClass.prototype;

package/sql/elements/returning-column.js

@@ -1,5 +1,5 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { BaseField } from './base-field.js';
 const RETURNING_COLUMN_PATTERN = /^([a-zA-Z_]\w*) *(?:as)? *(\w+)?$/;
 class ReturningColumnClass extends BaseField {
@@ -21,7 +21,7 @@ class ReturningColumnClass extends BaseField {
 export const ReturningColumn = function (field) {
     if (!(this instanceof ReturningColumn))
         return new ReturningColumn(field);
-    Serializable.call(this);
+    SqlElement.call(this);
     const m = field.match(RETURNING_COLUMN_PATTERN);
     if (!m)
         throw new TypeError(`"${field}" does not match returning column format`);

package/sql/elements/sequence.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class SequenceClass extends Serializable {
+declare class SequenceClass extends SqlElement {
     _expression: string;
     _next: boolean;
     _alias?: string;

package/sql/elements/sequence.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class SequenceClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class SequenceClass extends SqlElement {
     _expression;
     _next;
     _alias;
@@ -46,7 +46,7 @@ class SequenceClass extends Serializable {
 export const Sequence = function (expression, next) {
     if (!(this instanceof Sequence))
         return new Sequence(expression, next);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expression = expression;
     this._next = !!next;
 };

package/sql/elements/string-agg.d.ts

@@ -1,18 +1,18 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { OrderColumn } from './order-column.js';
-declare class StringAggClass extends Serializable {
-    _field: Serializable;
+declare class StringAggClass extends SqlElement {
+    _field: SqlElement;
     _delimiter: string;
-    _orderBy?: (OrderColumn | Serializable)[];
+    _orderBy?: (OrderColumn | SqlElement)[];
     _alias?: string;
     get _type(): SerializationType;
     delimiter(value: string): this;
     /**
      * Defines "order by" part of StringAGG.
      */
-    orderBy(...field: (string | Serializable)[]): this;
+    orderBy(...field: (string | SqlElement)[]): this;
     /**
      * Sets alias to case expression.
      */
@@ -29,8 +29,8 @@ declare class StringAggClass extends Serializable {
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
 interface StringAggCtor {
-    new (field: string | Serializable, delimiter?: string): StringAgg;
-    (field: string | Serializable, delimiter?: string): StringAgg;
+    new (field: string | SqlElement, delimiter?: string): StringAgg;
+    (field: string | SqlElement, delimiter?: string): StringAgg;
     prototype: StringAgg;
 }
 export declare const StringAgg: StringAggCtor;

package/sql/elements/string-agg.js

@@ -1,9 +1,9 @@
 import { SerializationType } from '../../enums.js';
 import { printArray } from '../../helpers.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Field } from './field.js';
 import { OrderColumn } from './order-column.js';
-class StringAggClass extends Serializable {
+class StringAggClass extends SqlElement {
     _field;
     _delimiter;
     _orderBy;
@@ -79,7 +79,7 @@ class StringAggClass extends Serializable {
 export const StringAgg = function (field, delimiter) {
     if (!(this instanceof StringAgg))
         return new StringAgg(field, delimiter);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._field = typeof field === 'string' ? new Field(field) : field;
     this._delimiter = delimiter || ',';
 };

package/sql/elements/table-name.d.ts

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

package/sql/elements/table-name.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class TableNameClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class TableNameClass extends SqlElement {
     schema;
     table;
     alias;
@@ -22,7 +22,7 @@ class TableNameClass extends Serializable {
 export const TableName = function (tableName) {
     if (!(this instanceof TableName))
         return new TableName(tableName);
-    Serializable.call(this);
+    SqlElement.call(this);
     if (typeof tableName === 'string') {
         const m = tableName.match(/^(?:([a-zA-Z][\w$]*)\.)? *([a-zA-Z][\w$]*) *(?:as)? *(\w+)?$/);
         if (!m)

package/sql/elements/upper.d.ts

@@ -1,7 +1,7 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
-declare class UpperClass extends Serializable {
+declare class UpperClass extends SqlElement {
     _expression: any;
     _alias?: string;
     get _type(): SerializationType;

package/sql/elements/upper.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-class UpperClass extends Serializable {
+import { SqlElement } from '../../serializable.js';
+class UpperClass extends SqlElement {
     _expression;
     _alias;
     get _type() {
@@ -33,7 +33,7 @@ class UpperClass extends Serializable {
 export const Upper = function (expression) {
     if (!(this instanceof Upper))
         return new Upper(expression);
-    Serializable.call(this);
+    SqlElement.call(this);
     this._expression = expression;
 };
 Upper.prototype = UpperClass.prototype;

package/sql/insert.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { Serializable } from '../serializable.js';
+import { SqlElement } from '../serializable.js';
 import { isRaw, isSelect, isSerializable } from '../type-guards.js';
 import { TableName } from './elements/table-name.js';
 import { Query } from './query.js';
@@ -77,7 +77,7 @@ export const Insert = function (tableName, input) {
     }
     if (!input ||
         !((typeof input === 'object' && !Array.isArray(input)) ||
-            (input instanceof Serializable &&
+            (input instanceof SqlElement &&
                 (input._type === SerializationType.SELECT_QUERY ||
                     input._type === SerializationType.RAW)))) {
         throw new TypeError('Object or Select instance required as second argument (input) for Insert');

package/sql/operators/between.d.ts

@@ -1,4 +1,4 @@
-import type { Serializable } from '../../serializable.js';
+import type { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { CompOperator } from './comp-operator.js';
 declare class BetweenClass extends CompOperator {
@@ -6,10 +6,10 @@ declare class BetweenClass extends CompOperator {
     __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
 interface BetweenCtor {
-    new (left: string | Serializable, right: any[] | Serializable): Between;
-    new (left: string | Serializable, right1: any, right2: any): Between;
-    (left: string | Serializable, right: any[] | Serializable): Between;
-    (left: string | Serializable, right1: any, right2: any): Between;
+    new (left: string | SqlElement, right: any[] | SqlElement): Between;
+    new (left: string | SqlElement, right1: any, right2: any): Between;
+    (left: string | SqlElement, right: any[] | SqlElement): Between;
+    (left: string | SqlElement, right1: any, right2: any): Between;
     prototype: Between;
 }
 export declare const Between: BetweenCtor;

package/sql/operators/comp-operator.d.ts

@@ -1,21 +1,21 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { Operator } from './operator.js';
 declare class CompOperatorClass extends Operator {
-    _left: Serializable | string;
-    _right?: any | Serializable;
+    _left: SqlElement | string;
+    _right?: any | SqlElement;
     _symbol?: string;
     _isArray?: boolean;
     get _type(): SerializationType;
     _serialize(ctx: SerializeContext): string;
-    __serializeItem(ctx: SerializeContext, x: string | Serializable, left?: any): any;
+    __serializeItem(ctx: SerializeContext, x: string | SqlElement, left?: any): any;
     __serialize(ctx: SerializeContext, o: any): string;
     __defaultSerialize(ctx: SerializeContext, o: any): string;
 }
 interface CompOperatorCtor {
-    new (left: string | Serializable, right?: any): CompOperator;
-    (left: string | Serializable, right?: any): CompOperator;
+    new (left: string | SqlElement, right?: any): CompOperator;
+    (left: string | SqlElement, right?: any): CompOperator;
     prototype: CompOperator;
 }
 export declare const CompOperator: CompOperatorCtor;

package/sql/operators/comp-operator.js

@@ -1,5 +1,5 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Field, Param } from '../elements/index.js';
 import { Operator } from './operator.js';
 const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
@@ -26,7 +26,7 @@ class CompOperatorClass extends Operator {
     }
     __serializeItem(ctx, x, left) {
         const isRight = !!left;
-        if (ctx.strictParams && !(x instanceof Serializable) && isRight) {
+        if (ctx.strictParams && !(x instanceof SqlElement) && isRight) {
             ctx.strictParamGenId = ctx.strictParamGenId || 0;
             const name = 'P$_' + ++ctx.strictParamGenId;
             ctx.params = ctx.params || {};
@@ -37,7 +37,7 @@ class CompOperatorClass extends Operator {
                 isArray: left?.isArray || Array.isArray(x),
             });
         }
-        if (x instanceof Serializable) {
+        if (x instanceof SqlElement) {
             const expression = ctx.anyToSQL(x);
             const result = {
                 expression,

package/sql/operators/eq.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class EqClass extends CompOperator {
 }
 interface EqCtor {
-    new (left: string | Serializable, right: any): Eq;
-    (left: string | Serializable, right: any): Eq;
+    new (left: string | SqlElement, right: any): Eq;
+    (left: string | SqlElement, right: any): Eq;
     prototype: Eq;
 }
 export declare const Eq: EqCtor;

package/sql/operators/gt.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class GtClass extends CompOperator {
 }
 interface GtCtor {
-    new (left: string | Serializable, right?: any): Gt;
-    (left: string | Serializable, right?: any): Gt;
+    new (left: string | SqlElement, right?: any): Gt;
+    (left: string | SqlElement, right?: any): Gt;
     prototype: Gt;
 }
 export declare const Gt: GtCtor;

package/sql/operators/gte.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class GteClass extends CompOperator {
 }
 interface GteCtor {
-    new (left: string | Serializable, right?: any): Gte;
-    (left: string | Serializable, right?: any): Gte;
+    new (left: string | SqlElement, right?: any): Gte;
+    (left: string | SqlElement, right?: any): Gte;
     prototype: Gte;
 }
 export declare const Gte: GteCtor;

package/sql/operators/i-like.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Like } from './like.js';
 declare class ILikeClass extends Like {
 }
 interface ILikeCtor {
-    new (left: string | Serializable, right?: string | Serializable): ILike;
-    (left: string | Serializable, right?: string | Serializable): ILike;
+    new (left: string | SqlElement, right?: string | SqlElement): ILike;
+    (left: string | SqlElement, right?: string | SqlElement): ILike;
     prototype: ILike;
 }
 export declare const ILike: ILikeCtor;

package/sql/operators/in.d.ts

@@ -1,12 +1,12 @@
-import type { Serializable } from '../../serializable.js';
+import type { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { CompOperator } from './comp-operator.js';
 declare class InClass extends CompOperator {
     _serialize(ctx: SerializeContext): string;
 }
 interface InCtor {
-    new (left: string | Serializable, right: any[] | Serializable): In;
-    (left: string | Serializable, right: any[] | Serializable): In;
+    new (left: string | SqlElement, right: any[] | SqlElement): In;
+    (left: string | SqlElement, right: any[] | SqlElement): In;
     prototype: In;
 }
 export declare const In: InCtor;

package/sql/operators/is-not.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Is } from './is.js';
 declare class IsNotClass extends Is {
 }
 interface IsNotCtor {
-    new (left: string | Serializable, right?: any): IsNot;
-    (left: string | Serializable, right?: any): IsNot;
+    new (left: string | SqlElement, right?: any): IsNot;
+    (left: string | SqlElement, right?: any): IsNot;
     prototype: IsNot;
 }
 export declare const IsNot: IsNotCtor;

package/sql/operators/is.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class IsClass extends CompOperator {
 }
 interface IsCtor {
-    new (left: string | Serializable, right?: any): Is;
-    (left: string | Serializable, right?: any): Is;
+    new (left: string | SqlElement, right?: any): Is;
+    (left: string | SqlElement, right?: any): Is;
     prototype: Is;
 }
 export declare const Is: IsCtor;

package/sql/operators/like.d.ts

@@ -1,12 +1,12 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { CompOperator } from './comp-operator.js';
 declare class LikeClass extends CompOperator {
     __serialize(ctx: SerializeContext, o: any): string;
 }
 interface LikeCtor {
-    new (left: string | Serializable, right?: string | Serializable): Like;
-    (left: string | Serializable, right?: string | Serializable): Like;
+    new (left: string | SqlElement, right?: string | SqlElement): Like;
+    (left: string | SqlElement, right?: string | SqlElement): Like;
     prototype: Like;
 }
 export declare const Like: LikeCtor;

package/sql/operators/logical-operator.d.ts

@@ -1,8 +1,8 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { Operator } from './operator.js';
 export interface LogicalOperator extends Operator {
-    _items: Serializable[];
+    _items: SqlElement[];
     add(...expressions: (LogicalOperator | any)[]): this;
     _serialize(ctx: SerializeContext): string;
 }

package/sql/operators/lt.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class LtClass extends CompOperator {
 }
 interface LtCtor {
-    new (left: string | Serializable, right?: any): Lt;
-    (left: string | Serializable, right?: any): Lt;
+    new (left: string | SqlElement, right?: any): Lt;
+    (left: string | SqlElement, right?: any): Lt;
     prototype: Lt;
 }
 export declare const Lt: LtCtor;

package/sql/operators/lte.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class LteClass extends CompOperator {
 }
 interface LteCtor {
-    new (left: string | Serializable, right?: any): Lte;
-    (left: string | Serializable, right?: any): Lte;
+    new (left: string | SqlElement, right?: any): Lte;
+    (left: string | SqlElement, right?: any): Lte;
     prototype: Lte;
 }
 export declare const Lte: LteCtor;

package/sql/operators/ne.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { CompOperator } from './comp-operator.js';
 declare class NeClass extends CompOperator {
 }
 interface NeCtor {
-    new (left: string | Serializable, right?: any): Ne;
-    (left: string | Serializable, right?: any): Ne;
+    new (left: string | SqlElement, right?: any): Ne;
+    (left: string | SqlElement, right?: any): Ne;
     prototype: Ne;
 }
 export declare const Ne: NeCtor;

package/sql/operators/not-between.d.ts

@@ -1,12 +1,12 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Between } from './between.js';
 declare class NotBetweenClass extends Between {
 }
 interface NotBetweenCtor {
-    new (left: string | Serializable, right: any[] | Serializable): NotBetween;
-    new (left: string | Serializable, right1: any, right2: any): NotBetween;
-    (left: string | Serializable, right: any[] | Serializable): NotBetween;
-    (left: string | Serializable, right1: any, right2: any): NotBetween;
+    new (left: string | SqlElement, right: any[] | SqlElement): NotBetween;
+    new (left: string | SqlElement, right1: any, right2: any): NotBetween;
+    (left: string | SqlElement, right: any[] | SqlElement): NotBetween;
+    (left: string | SqlElement, right1: any, right2: any): NotBetween;
     prototype: NotBetween;
 }
 export declare const NotBetween: NotBetweenCtor;

package/sql/operators/not-i-like.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { ILike } from './i-like.js';
 declare class NotILikeClass extends ILike {
 }
 interface NotILikeCtor {
-    new (left: string | Serializable, right?: string | Serializable): NotILike;
-    (left: string | Serializable, right?: string | Serializable): NotILike;
+    new (left: string | SqlElement, right?: string | SqlElement): NotILike;
+    (left: string | SqlElement, right?: string | SqlElement): NotILike;
     prototype: NotILike;
 }
 export declare const NotILike: NotILikeCtor;

package/sql/operators/not-in.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { In } from './in.js';
 declare class NotInClass extends In {
 }
 interface NotInCtor {
-    new (left: string | Serializable, right: any[] | Serializable): NotIn;
-    (left: string | Serializable, right: any[] | Serializable): NotIn;
+    new (left: string | SqlElement, right: any[] | SqlElement): NotIn;
+    (left: string | SqlElement, right: any[] | SqlElement): NotIn;
     prototype: NotIn;
 }
 export declare const NotIn: NotInCtor;

package/sql/operators/not-like.d.ts

@@ -1,10 +1,10 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { Like } from './like.js';
 declare class NotLikeClass extends Like {
 }
 interface NotLikeCtor {
-    new (left: string | Serializable, right?: string | Serializable): NotLike;
-    (left: string | Serializable, right?: string | Serializable): NotLike;
+    new (left: string | SqlElement, right?: string | SqlElement): NotLike;
+    (left: string | SqlElement, right?: string | SqlElement): NotLike;
     prototype: NotLike;
 }
 export declare const NotLike: NotLikeCtor;

package/sql/operators/not.d.ts

@@ -1,15 +1,15 @@
 import { SerializationType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 import { SerializeContext } from '../../serialize-context.js';
 import { Operator } from '../operators/operator.js';
 declare class NotClass extends Operator {
-    _expression: Serializable;
+    _expression: SqlElement;
     get _type(): SerializationType;
     _serialize(ctx: SerializeContext): string;
 }
 interface NotCtor {
-    new (expression: Serializable): Not;
-    (expression: Serializable): Not;
+    new (expression: SqlElement): Not;
+    (expression: SqlElement): Not;
     prototype: Not;
 }
 export declare const Not: NotCtor;

package/sql/operators/operator.d.ts

@@ -1,6 +1,6 @@
 import { OperatorType } from '../../enums.js';
-import { Serializable } from '../../serializable.js';
-export interface Operator extends Serializable {
+import { SqlElement } from '../../serializable.js';
+export interface Operator extends SqlElement {
     _operatorType: OperatorType;
 }
 interface OperatorCtor {

package/sql/operators/operator.js

@@ -1,11 +1,11 @@
-import { Serializable } from '../../serializable.js';
+import { SqlElement } from '../../serializable.js';
 export const Operator = function () {
     if (!(this instanceof Operator))
         return new Operator();
     if (this.constructor === Operator) {
         throw new TypeError('Operator is abstract and cannot be instantiated');
     }
-    Serializable.call(this);
+    SqlElement.call(this);
 };
-Operator.prototype = Object.create(Serializable.prototype);
+Operator.prototype = Object.create(SqlElement.prototype);
 Operator.prototype.constructor = Operator;

package/sql/query.d.ts

@@ -1,9 +1,9 @@
 import { EventEmitter } from 'events';
-import { Serializable } from '../serializable.js';
+import { SqlElement } from '../serializable.js';
 import type { GenerateOptions, GenerateResult } from '../types.js';
 declare interface QueryClass extends EventEmitter {
 }
-declare class QueryClass extends Serializable {
+declare class QueryClass extends SqlElement {
     protected _comment: Query.Comment[];
     protected _params?: Record<string, any>;
     /**

package/sql/query.js

@@ -1,9 +1,9 @@
 import { EventEmitter } from 'events';
 import flattenText from 'putil-flattentext';
 import merge from 'putil-merge';
-import { Serializable } from '../serializable.js';
+import { SqlElement } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
-class QueryClass extends Serializable {
+class QueryClass extends SqlElement {
     /**
      * Generates Sql script
      */
@@ -59,7 +59,7 @@ export const Query = function () {
     if (this.constructor === Query) {
         throw new TypeError('Query is abstract and cannot be instantiated');
     }
-    Serializable.call(this);
+    SqlElement.call(this);
     EventEmitter.call(this);
     this._comment = [];
 };

package/sql/select.d.ts

@@ -1,5 +1,5 @@
 import { SerializationType } from '../enums.js';
-import { Serializable } from '../serializable.js';
+import { SqlElement } from '../serializable.js';
 import { SerializeContext } from '../serialize-context.js';
 import { GroupColumn } from './elements/group-column.js';
 import { Join } from './elements/join.js';
@@ -10,12 +10,12 @@ import { LogicalOperator } from './operators/logical-operator.js';
 import { Query } from './query.js';
 import type { Union } from './union.js';
 declare class SelectClass extends Query {
-    _tables?: Serializable[];
-    _columns?: Serializable[];
+    _tables?: SqlElement[];
+    _columns?: SqlElement[];
     _joins?: Join[];
     _where?: LogicalOperator;
-    _groupBy?: (GroupColumn | Serializable)[];
-    _orderBy?: (OrderColumn | Serializable)[];
+    _groupBy?: (GroupColumn | SqlElement)[];
+    _orderBy?: (OrderColumn | SqlElement)[];
     _limit?: number;
     _offset?: number;
     _alias?: string;
@@ -24,7 +24,7 @@ declare class SelectClass extends Query {
     /**
      * Adds columns to query.
      */
-    addColumn(...column: (string | string[] | Serializable)[]): this;
+    addColumn(...column: (string | string[] | SqlElement)[]): this;
     /**
      * Defines "from" part of  query.
      */
@@ -36,15 +36,15 @@ declare class SelectClass extends Query {
     /**
      * Defines "where" part of query
      */
-    where(...condition: (Serializable | Object)[]): this;
+    where(...condition: (SqlElement | Object)[]): this;
     /**
      * Defines "where" part of query
      */
-    groupBy(...field: (string | Serializable)[]): this;
+    groupBy(...field: (string | SqlElement)[]): this;
     /**
      * Defines "order by" part of query.
      */
-    orderBy(...field: (string | Serializable)[]): this;
+    orderBy(...field: (string | SqlElement)[]): this;
     /**
      * Sets alias for sub-select queries
      */
@@ -90,8 +90,8 @@ declare class SelectClass extends Query {
     protected __serializeOrderColumns(ctx: SerializeContext): string;
 }
 interface SelectCtor {
-    new (...column: (string | string[] | Serializable)[]): Select;
-    (...column: (string | string[] | Serializable)[]): Select;
+    new (...column: (string | string[] | SqlElement)[]): Select;
+    (...column: (string | string[] | SqlElement)[]): Select;
     prototype: Select;
 }
 export declare const Select: SelectCtor;

package/sql/update.js

@@ -1,6 +1,6 @@
 import { SerializationType } from '../enums.js';
 import { printArray } from '../helpers.js';
-import { Serializable } from '../serializable.js';
+import { SqlElement } from '../serializable.js';
 import { isRaw } from '../type-guards.js';
 import { TableName } from './elements/table-name.js';
 import { And } from './operators/and.js';
@@ -80,7 +80,7 @@ export const Update = function (tableName, input) {
     }
     if (!input ||
         !((typeof input === 'object' && !Array.isArray(input)) ||
-            (input instanceof Serializable &&
+            (input instanceof SqlElement &&
                 (input._type === SerializationType.SELECT_QUERY ||
                     input._type === SerializationType.RAW)))) {
         throw new TypeError('Object or Raw instance required as second argument (input) for Update');

package/type-guards.d.ts

@@ -1,6 +1,7 @@
-import type { Serializable } from './serializable.js';
+import type { SqlElement } from './serializable.js';
 import type { Case, CompOperator, Count, Delete, Field, GroupColumn, Insert, Join, LogicalOperator, OrderColumn, Param, Query, Raw, ReturningColumn, Select, TableName, Update } from './sql/index.js';
-export declare function isSerializable(value: any): value is Serializable;
+export declare function isSqlElement(value: any): value is SqlElement;
+export declare function isSerializable(value: any): value is SqlElement;
 export declare function isQuery(value: any): value is Query;
 export declare function isRaw(value: any): value is Raw;
 export declare function isSelect(value: any): value is Select;

package/type-guards.js

@@ -1,7 +1,11 @@
 import { SerializationType } from './enums.js';
-export function isSerializable(value) {
+export function isSqlElement(value) {
     return typeof value === 'object' && typeof value._serialize === 'function';
 }
+/* Backward compatibility */
+export function isSerializable(value) {
+    return isSqlElement(value);
+}
 export function isQuery(value) {
     return (isSerializable(value) &&
         typeof value.generate === 'function' &&