@sqb/builder 4.0.1-beta.7 → 4.0.2

package/dist/sql-objects/JoinStatement.js

@@ -11,7 +11,7 @@ class JoinStatement extends Serializable_1.Serializable {
         super();
         this._conditions = new OpAnd_1.OpAnd();
         // noinspection SuspiciousTypeOfGuard
-        if (!(typeguards_1.isSelectQuery(table) || typeguards_1.isRawStatement(table) || typeguards_1.isTableName(table) ||
+        if (!((0, typeguards_1.isSelectQuery)(table) || (0, typeguards_1.isRawStatement)(table) || (0, typeguards_1.isTableName)(table) ||
             typeof table === 'string'))
             throw new TypeError('Table name, select query or raw object required for Join');
         this._joinType = joinType;
@@ -30,7 +30,7 @@ class JoinStatement extends Serializable_1.Serializable {
             table: this._table._serialize(ctx),
             conditions: this.__serializeConditions(ctx, this)
         };
-        return Serializable_1.serializeFallback(ctx, this._type, o, () => {
+        return ctx.serialize(this._type, o, () => {
             let out;
             switch (this._joinType) {
                 case enums_1.JoinType.LEFT:
@@ -56,7 +56,7 @@ class JoinStatement extends Serializable_1.Serializable {
                     break;
             }
             const lf = o.table.length > 40;
-            if (typeguards_1.isSelectQuery(this._table)) {
+            if ((0, typeguards_1.isSelectQuery)(this._table)) {
                 const alias = this._table._alias;
                 if (!alias)
                     throw new Error('Alias required for sub-select in Join');
@@ -73,7 +73,7 @@ class JoinStatement extends Serializable_1.Serializable {
     __serializeConditions(ctx, join) {
         if (join._conditions._items.length) {
             const s = join._conditions._serialize(ctx);
-            return Serializable_1.serializeFallback(ctx, enums_1.SerializationType.JOIN_CONDITIONS, s, () => s ? 'on ' + s : '');
+            return ctx.serialize(enums_1.SerializationType.JOIN_CONDITIONS, s, () => s ? 'on ' + s : '');
         }
         return '';
     }

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

@@ -1,7 +1,7 @@
 import { SerializationType } from '../enums';
-import { Column } from './Column';
-import { SerializeContext } from '../types';
-export declare class OrderColumn extends Column {
+import { BaseField } from './BaseField';
+import { SerializeContext } from '../SerializeContext';
+export declare class OrderColumn extends BaseField {
     _descending?: boolean;
     constructor(value: string);
     get _type(): SerializationType;

package/dist/sql-objects/OrderColumn.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderColumn = void 0;
-const Serializable_1 = require("../Serializable");
 const enums_1 = require("../enums");
-const Column_1 = require("./Column");
+const BaseField_1 = require("./BaseField");
 const ORDER_COLUMN_PATTERN = /^([-+])?((?:[a-zA-Z][\w$]*\.){0,2})([a-zA-Z][\w$]*|\*) *(asc|dsc|desc|ascending|descending)?$/i;
-class OrderColumn extends Column_1.Column {
+class OrderColumn extends BaseField_1.BaseField {
     constructor(value) {
         super();
         const m = value.match(ORDER_COLUMN_PATTERN);
@@ -30,9 +29,9 @@ class OrderColumn extends Column_1.Column {
             table: this._table,
             field: this._field,
             descending: !!this._descending,
-            isReservedWord: !!(this._field && Serializable_1.isReservedWord(ctx, this._field))
+            isReservedWord: !!(this._field && ctx.isReservedWord(this._field))
         };
-        return Serializable_1.serializeFallback(ctx, this._type, o, () => {
+        return ctx.serialize(this._type, o, () => {
             return (o.schema ? o.schema + '.' : '') +
                 (o.table ? o.table + '.' : '') +
                 (o.isReservedWord ? '"' + o.field + '"' : o.field) +

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

@@ -1,6 +1,6 @@
 import { Serializable } from '../Serializable';
 import { DataType, SerializationType } from '../enums';
-import { SerializeContext } from '../types';
+import { SerializeContext } from '../SerializeContext';
 export declare class ParamExpression extends Serializable {
     _name: string;
     _dataType?: DataType;

package/dist/sql-objects/ParamExpression.js

@@ -26,15 +26,27 @@ class ParamExpression extends Serializable_1.Serializable {
             dataType: this._dataType,
             isArray: this._isArray,
         };
-        return Serializable_1.serializeFallback(ctx, this._type, o, () => this.__defaultSerialize(ctx, o));
+        return ctx.serialize(this._type, o, () => this.__defaultSerialize(ctx, o));
     }
     __defaultSerialize(ctx, o) {
-        let prmValue = ctx.params && ctx.params[o.name];
-        if (o.isArray && !Array.isArray(prmValue))
+        let prmValue = (ctx.params && ctx.params[o.name]) ?? null;
+        if (prmValue != null && o.isArray && !Array.isArray(prmValue))
             prmValue = [prmValue];
-        ctx.queryParams = ctx.queryParams || {};
-        if (prmValue !== undefined)
-            ctx.queryParams[o.name] = 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

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

package/dist/sql-objects/RawStatement.js

@@ -12,7 +12,7 @@ class RawStatement extends Serializable_1.Serializable {
         return enums_1.SerializationType.RAW;
     }
     _serialize(ctx) {
-        return Serializable_1.serializeFallback(ctx, this._type, this._text, () => this._text);
+        return ctx.serialize(this._type, this._text, () => this._text);
     }
 }
 exports.RawStatement = RawStatement;

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

@@ -1,7 +1,7 @@
 import { SerializationType } from '../enums';
-import { Column } from './Column';
-import { SerializeContext } from '../types';
-export declare class ReturningColumn extends Column {
+import { BaseField } from './BaseField';
+import { SerializeContext } from '../SerializeContext';
+export declare class ReturningColumn extends BaseField {
     _alias: string;
     constructor(field: string);
     get _type(): SerializationType;

package/dist/sql-objects/ReturningColumn.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturningColumn = void 0;
-const Serializable_1 = require("../Serializable");
 const enums_1 = require("../enums");
-const Column_1 = require("./Column");
+const BaseField_1 = require("./BaseField");
 const RETURNING_COLUMN_PATTERN = /^([a-zA-Z]\w*) *(?:as)? *(\w+)?$/;
-class ReturningColumn extends Column_1.Column {
+class ReturningColumn extends BaseField_1.BaseField {
     constructor(field) {
         super();
         const m = field.match(RETURNING_COLUMN_PATTERN);
@@ -24,9 +23,9 @@ class ReturningColumn extends Column_1.Column {
         };
         ctx.returningFields = ctx.returningFields || [];
         ctx.returningFields.push(o);
-        return Serializable_1.serializeFallback(ctx, this._type, o, () => {
-            return Serializable_1.escapeReserved(ctx, o.field) +
-                (o.alias ? ' as ' + Serializable_1.escapeReserved(ctx, o.alias) : '');
+        return ctx.serialize(this._type, o, () => {
+            return ctx.escapeReserved(o.field) +
+                (o.alias ? ' as ' + ctx.escapeReserved(o.alias) : '');
         });
     }
 }

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

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

package/dist/sql-objects/TableName.js

@@ -20,7 +20,7 @@ class TableName extends Serializable_1.Serializable {
         return enums_1.SerializationType.TABLE_NAME;
     }
     _serialize(ctx) {
-        return Serializable_1.serializeFallback(ctx, this._type, {
+        return ctx.serialize(this._type, {
             schema: this.schema,
             table: this.table,
             alias: this.alias

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

@@ -1,14 +1,16 @@
 import { Operator } from '../Operator';
 import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../types';
 import { SerializationType } from '../../enums';
+import { SerializeContext } from '../../SerializeContext';
 export declare abstract class CompOperator extends Operator {
-    _expression: Serializable | string;
-    _value?: any | Serializable;
+    _left: Serializable | string;
+    _right?: any | Serializable;
     _symbol?: string;
-    protected constructor(expression: string | Serializable, value?: any);
+    _isArray?: boolean;
+    protected constructor(left: string | Serializable, right?: any);
     get _type(): SerializationType;
     _serialize(ctx: SerializeContext): string;
+    protected __serializeItem(ctx: SerializeContext, x: any, isRight?: boolean): any;
     protected __serialize(ctx: SerializeContext, o: any): string;
     protected __defaultSerialize(ctx: SerializeContext, o: any): string;
 }

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

@@ -5,48 +5,83 @@ const Operator_1 = require("../Operator");
 const Serializable_1 = require("../../Serializable");
 const enums_1 = require("../../enums");
 const typeguards_1 = require("../../typeguards");
-const sqlobject_initializers_1 = require("../sqlobject.initializers");
+const sqlobject_initializers_1 = require("../../sqlobject.initializers");
+const ParamExpression_1 = require("../ParamExpression");
+const FieldExpression_1 = require("../FieldExpression");
+const EXPRESSION_PATTERN = /^([\w\\.$]+)(\[])?/;
 class CompOperator extends Operator_1.Operator {
-    constructor(expression, value) {
+    constructor(left, right) {
         super();
-        this._expression = expression;
-        this._value = value;
+        if (typeof left === 'string') {
+            const m = left.match(EXPRESSION_PATTERN);
+            if (!m)
+                throw new TypeError(`"${left}" is not a valid expression definition`);
+            this._left = m[1];
+            this._isArray = !!m[2];
+        }
+        else
+            this._left = left;
+        this._right = right;
     }
     get _type() {
         return enums_1.SerializationType.COMPARISON_EXPRESSION;
     }
     _serialize(ctx) {
-        const left = this._expression instanceof Serializable_1.Serializable ?
-            this._expression._serialize(ctx) : this._expression;
-        let right = this._value;
-        if (ctx.strictParams && !typeguards_1.isSerializable(this._value) &&
-            typeof this._expression === 'string') {
-            ctx.strictParamGenId = ctx.strictParamGenId || 0;
-            const name = 'strictParam$' + ++ctx.strictParamGenId;
-            right = sqlobject_initializers_1.Param(name);
-            ctx.params = ctx.params || {};
-            ctx.params[name] = this._value;
-        }
+        const left = this.__serializeItem(ctx, this._left);
+        if (this._isArray)
+            left.isArray = true;
+        const right = this.__serializeItem(ctx, this._right, true);
         const o = {
             operatorType: this._operatorType,
-            left: typeguards_1.isSelectQuery(this._expression) ?
-                '(' + left + ')' : left,
             symbol: this._symbol,
+            left,
             right
         };
         return this.__serialize(ctx, o);
     }
+    __serializeItem(ctx, x, isRight) {
+        if (ctx.strictParams && !(x instanceof Serializable_1.Serializable) &&
+            (typeof x !== 'string' || isRight)) {
+            ctx.strictParamGenId = ctx.strictParamGenId || 0;
+            const name = 'strictParam$' + ++ctx.strictParamGenId;
+            ctx.params = ctx.params || {};
+            ctx.params[name] = x;
+            x = (0, sqlobject_initializers_1.Param)(name);
+        }
+        if (x instanceof Serializable_1.Serializable) {
+            const expression = x._serialize(ctx);
+            const result = {
+                expression: (0, typeguards_1.isSelectQuery)(x) ? '(' + expression + ')' : expression
+            };
+            if (x instanceof FieldExpression_1.FieldExpression) {
+                result.dataType = result._dataType;
+                result.isArray = x._isArray;
+            }
+            if (x instanceof ParamExpression_1.ParamExpression) {
+                let value = ctx.params ? ctx.params[x._name] : undefined;
+                if (x._isArray && value != null)
+                    value = [value];
+                result.value = value;
+                result.isArray = x._isArray || Array.isArray(value);
+                result.isParam = true;
+            }
+            return result;
+        }
+        else {
+            const result = {
+                expression: (isRight || typeof x !== 'string') ?
+                    ctx.anyToSQL(x) : x
+            };
+            if (isRight || typeof x !== 'string')
+                result.isArray = Array.isArray(x);
+            return result;
+        }
+    }
     __serialize(ctx, o) {
-        let value = Serializable_1.serializeObject(ctx, o.right);
-        if (typeguards_1.isSelectQuery(o.right))
-            value = '(' + value + ')';
-        o.right = value;
-        return Serializable_1.serializeFallback(ctx, this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
     }
     __defaultSerialize(ctx, o) {
-        return (Array.isArray(o.expression) ?
-            '(' + o.left.join(',') + ')' : o.left) +
-            ' ' + o.symbol + ' ' + o.right;
+        return o.left.expression + ' ' + o.symbol + ' ' + o.right.expression;
     }
 }
 exports.CompOperator = CompOperator;

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

@@ -1,7 +1,7 @@
 import { Operator } from '../Operator';
 import { SerializationType } from '../../enums';
 import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../types';
+import { SerializeContext } from '../../SerializeContext';
 export declare const WrapOps: {};
 export declare abstract class LogicalOperator extends Operator {
     _items: Serializable[];

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

@@ -7,9 +7,11 @@ exports.LogicalOperator = exports.WrapOps = void 0;
 const Operator_1 = require("../Operator");
 const putil_isplainobject_1 = __importDefault(require("putil-isplainobject"));
 const enums_1 = require("../../enums");
-const Serializable_1 = require("../../Serializable");
 const typeguards_1 = require("../../typeguards");
+const helpers_1 = require("../../helpers");
 exports.WrapOps = {};
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const COMPARE_LEFT_PATTERN = /^([\w\\.$]+(?:\[])?) *(.*)$/;
 class LogicalOperator extends Operator_1.Operator {
     constructor(...expressions) {
         super();
@@ -26,13 +28,13 @@ class LogicalOperator extends Operator_1.Operator {
         for (const item of expressions) {
             if (!item)
                 continue;
-            if (typeguards_1.isLogicalOperator(item)) {
+            if ((0, typeguards_1.isLogicalOperator)(item)) {
                 this._items.push(item);
             }
-            else if (typeguards_1.isRawStatement(item) || typeguards_1.isCompOperator(item)) {
+            else if ((0, typeguards_1.isRawStatement)(item) || (0, typeguards_1.isCompOperator)(item)) {
                 this._items.push(item);
             }
-            else if (putil_isplainobject_1.default(item)) {
+            else if ((0, putil_isplainobject_1.default)(item)) {
                 this.add(...this._wrapObject(item));
             }
             else
@@ -46,10 +48,10 @@ class LogicalOperator extends Operator_1.Operator {
             const s = t._serialize(ctx);
             /* istanbul ignore else */
             if (s)
-                arr.push(typeguards_1.isLogicalOperator(t) ? '(' + s + ')' : s);
+                arr.push((0, typeguards_1.isLogicalOperator)(t) ? '(' + s + ')' : s);
         }
-        return Serializable_1.serializeFallback(ctx, enums_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
-            const s = Serializable_1.printArray(arr, ' ' + String(this._operatorType));
+        return ctx.serialize(enums_1.SerializationType.LOGICAL_EXPRESSION, arr, () => {
+            const s = (0, helpers_1.printArray)(arr, ' ' + String(this._operatorType));
             return (s.indexOf('\n') > 0) ? s.replace('\n', '\n\t') + '\b' : s;
         });
     }
@@ -68,9 +70,9 @@ class LogicalOperator extends Operator_1.Operator {
             if (['exists', '!exists'].includes(n))
                 result.push(exports.WrapOps[n](obj[n]));
             else {
-                const m = n.match(/^([\w\\.$]+) *(.*)$/);
+                const m = n.match(COMPARE_LEFT_PATTERN);
                 if (!m)
-                    throw new TypeError(`"${n}" is not a valid definition`);
+                    throw new TypeError(`"${n}" is not a valid expression definition`);
                 op = exports.WrapOps[m[2] || 'eq'];
                 if (!op)
                     throw new Error(`Unknown operator "${m[2]}"`);

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

@@ -1,11 +1,11 @@
 import { CompOperator } from './CompOperator';
 import { Serializable } from '../../Serializable';
 import { OperatorType } from '../../enums';
-import { SerializeContext } from '../../types';
+import { SerializeContext } from '../../SerializeContext';
 export declare class OpBetween extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;
     constructor(left: string | Serializable, right: any[]);
-    protected __serialize(ctx: SerializeContext, o: any): string;
+    _serialize(ctx: SerializeContext): string;
     __defaultSerialize(ctx: any, o: any): string;
 }

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpBetween = void 0;
 const CompOperator_1 = require("./CompOperator");
-const Serializable_1 = require("../../Serializable");
 const enums_1 = require("../../enums");
 class OpBetween extends CompOperator_1.CompOperator {
     constructor(left, right) {
@@ -12,12 +11,25 @@ class OpBetween extends CompOperator_1.CompOperator {
         if (right && right[1] == null)
             right[1] = right[0];
     }
-    __serialize(ctx, o) {
-        o.right = o.right.map(x => Serializable_1.serializeObject(ctx, x));
-        return Serializable_1.serializeFallback(ctx, this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+    _serialize(ctx) {
+        if (!(this._right && this._right.length > 0))
+            return '';
+        const left = this.__serializeItem(ctx, this._left);
+        const right = [
+            this.__serializeItem(ctx, this._right[0], true),
+            this.__serializeItem(ctx, this._right[1], true)
+        ];
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left,
+            right
+        };
+        return this.__serialize(ctx, o);
     }
     __defaultSerialize(ctx, o) {
-        return o.left + ' ' + o.symbol + ' ' + o.right[0] + ' and ' + o.right[1];
+        return o.left.expression + ' ' + o.symbol + ' ' +
+            o.right[0].expression + ' and ' + o.right[1].expression;
     }
 }
 exports.OpBetween = OpBetween;

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

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

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

@@ -9,11 +9,22 @@ class OpExists extends CompOperator_1.CompOperator {
         super(query);
         this._operatorType = enums_1.OperatorType.exists;
         this._symbol = 'exists';
-        if (!(typeof query === 'object' && typeguards_1.isSelectQuery(query)))
+        if (!(typeof query === 'object' && (0, typeguards_1.isSelectQuery)(query)))
             throw new TypeError('You must provide a SelectQuery in `exists()`');
     }
+    _serialize(ctx) {
+        const left = this.__serializeItem(ctx, this._left);
+        if (this._isArray)
+            left.isArray = true;
+        const o = {
+            operatorType: this._operatorType,
+            symbol: this._symbol,
+            left
+        };
+        return this.__serialize(ctx, o);
+    }
     __defaultSerialize(ctx, o) {
-        return o.left ? o.symbol + ' ' + o.left : '';
+        return o.left.expression ? o.symbol + ' ' + o.left.expression : '';
     }
 }
 exports.OpExists = OpExists;

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

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

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

@@ -6,14 +6,14 @@ const enums_1 = require("../../enums");
 const typeguards_1 = require("../../typeguards");
 class OpIn extends CompOperator_1.CompOperator {
     constructor(left, right) {
-        super(left, Array.isArray(right) || typeguards_1.isSerializable(right) ? right : [right]);
+        super(left, Array.isArray(right) || (0, typeguards_1.isSerializable)(right) ? right : [right]);
         this._operatorType = enums_1.OperatorType.in;
         this._symbol = 'in';
     }
-    __serialize(ctx, o) {
-        if (Array.isArray(o.right) && !o.right.length)
+    _serialize(ctx) {
+        if (Array.isArray(this._right) && !this._right.length)
             return '';
-        return super.__serialize(ctx, o);
+        return super._serialize(ctx);
     }
 }
 exports.OpIn = OpIn;

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

@@ -1,7 +1,7 @@
 import { CompOperator } from './CompOperator';
 import { OperatorType } from '../../enums';
 import { Serializable } from '../../Serializable';
-import { SerializeContext } from '../../types';
+import { SerializeContext } from '../../SerializeContext';
 export declare class OpLike extends CompOperator {
     _operatorType: OperatorType;
     _symbol: string;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpLike = void 0;
 const CompOperator_1 = require("./CompOperator");
 const enums_1 = require("../../enums");
-const Serializable_1 = require("../../Serializable");
 const typeguards_1 = require("../../typeguards");
 class OpLike extends CompOperator_1.CompOperator {
     constructor(left, right) {
@@ -12,12 +11,12 @@ class OpLike extends CompOperator_1.CompOperator {
         this._symbol = 'like';
     }
     __serialize(ctx, o) {
-        if (o.right && typeof o.right !== 'string' && !typeguards_1.isSerializable(o.right))
-            o.right = Serializable_1.serializeObject(ctx, o.right);
+        if (o.right && typeof o.right !== 'string' && !(0, typeguards_1.isSerializable)(o.right))
+            o.right = ctx.anyToSQL(o.right);
         if (!o.right)
             return '';
-        o.right = Serializable_1.serializeObject(ctx, o.right);
-        return Serializable_1.serializeFallback(ctx, this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
+        o.right = ctx.anyToSQL(o.right);
+        return ctx.serialize(this._type, o, (_ctx, _o) => this.__defaultSerialize(_ctx, _o));
     }
 }
 exports.OpLike = OpLike;

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

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

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

@@ -4,8 +4,8 @@ exports.OpNotBetween = void 0;
 const enums_1 = require("../../enums");
 const OpBetween_1 = require("./OpBetween");
 class OpNotBetween extends OpBetween_1.OpBetween {
-    constructor(left, right) {
-        super(left, right);
+    constructor() {
+        super(...arguments);
         this._operatorType = enums_1.OperatorType.notBetween;
         this._symbol = 'not between';
     }

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

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

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

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