drizzle-orm 0.9.0 → 0.9.4

package/builders/lowLvlBuilders/delets/delete.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteAggregator_1 = require("../../aggregators/deleteAggregator");
+const deleteFrom_1 = require("./deleteFrom");
+class Delete {
+}
+exports.default = Delete;
+Delete.from = (table) => {
+    const aggregator = new deleteAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
+    return new deleteFrom_1.default(aggregator);
+};

package/builders/lowLvlBuilders/delets/deleteFilter.d.ts

@@ -0,0 +1,8 @@
+import DeleteAggregator from '../../aggregators/deleteAggregator';
+import Expr from '../../requestBuilders/where/where';
+export default class DeleteFilter<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: DeleteAggregator);
+    apply: (filters: Expr) => DeleteFilter<SERVICE, DB>;
+    build: () => string;
+}

package/builders/lowLvlBuilders/delets/deleteFilter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DeleteFilter {
+    constructor(aggregator) {
+        this.apply = (filters) => {
+            this._aggregator.filters(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = DeleteFilter;

package/builders/lowLvlBuilders/delets/deleteFrom.d.ts

@@ -0,0 +1,9 @@
+import DeleteAggregator from '../../aggregators/deleteAggregator';
+import Expr from '../../requestBuilders/where/where';
+import DeleteFilter from './deleteFilter';
+export default class DeleteFrom {
+    private _aggregator;
+    constructor(aggregator: DeleteAggregator);
+    build: () => string;
+    filteredBy: (filters: Expr) => DeleteFilter<unknown, unknown>;
+}

package/builders/lowLvlBuilders/delets/deleteFrom.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteFilter_1 = require("./deleteFilter");
+class DeleteFrom {
+    constructor(aggregator) {
+        this.build = () => this._aggregator.buildQuery();
+        this.filteredBy = (filters) => new deleteFilter_1.default(this._aggregator).apply(filters);
+        this._aggregator = aggregator;
+    }
+}
+exports.default = DeleteFrom;

package/builders/lowLvlBuilders/inserts/insert.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import InsertInto from './insertInto';
+export default class Insert {
+    static into: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => InsertInto;
+}

package/builders/lowLvlBuilders/inserts/insert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const insertAggregator_1 = require("../../aggregators/insertAggregator");
+const insertInto_1 = require("./insertInto");
+class Insert {
+}
+exports.default = Insert;
+Insert.into = (table) => {
+    const aggregator = new insertAggregator_1.default(table);
+    // aggregator.appendFrom(table.tableName());
+    return new insertInto_1.default(aggregator);
+};

package/builders/lowLvlBuilders/inserts/insertInto.d.ts

@@ -0,0 +1,10 @@
+import InsertAggregator from '../../aggregators/insertAggregator';
+import ValuesInsert from './valuesInsert';
+export default class InsertInto {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    values: (values: {
+        [name: string]: any;
+    }[]) => ValuesInsert;
+    build: () => string;
+}

package/builders/lowLvlBuilders/inserts/insertInto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const valuesInsert_1 = require("./valuesInsert");
+class InsertInto {
+    constructor(aggregator) {
+        // @TODO refactor!!
+        this.values = (values) => new valuesInsert_1.default(this._aggregator)
+            .apply(values);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = InsertInto;

package/builders/lowLvlBuilders/inserts/onConflictInsert.d.ts

@@ -0,0 +1,9 @@
+import { Indexing } from '../../../tables/inferTypes';
+import InsertAggregator from '../../aggregators/insertAggregator';
+import UpdateExpr from '../../requestBuilders/updates/updates';
+export default class OnConflictInsert {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    apply: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
+    build: () => string;
+}

package/builders/lowLvlBuilders/inserts/onConflictInsert.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OnConflictInsert {
+    constructor(aggregator) {
+        this.apply = (updates, column) => {
+            this._aggregator.appendOnConflict(column, updates);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = OnConflictInsert;

package/builders/lowLvlBuilders/inserts/valuesInsert.d.ts

@@ -0,0 +1,13 @@
+import { Indexing } from '../../../tables/inferTypes';
+import InsertAggregator from '../../aggregators/insertAggregator';
+import UpdateExpr from '../../requestBuilders/updates/updates';
+import OnConflictInsert from './onConflictInsert';
+export default class ValuesInsert {
+    private _aggregator;
+    constructor(aggregator: InsertAggregator);
+    apply: (values: {
+        [name: string]: any;
+    }[]) => ValuesInsert;
+    onConflict: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
+    build: () => string;
+}

package/builders/lowLvlBuilders/inserts/valuesInsert.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const onConflictInsert_1 = require("./onConflictInsert");
+class ValuesInsert {
+    constructor(aggregator) {
+        this.apply = (values) => {
+            this._aggregator.appendColumns();
+            this._aggregator.appendValues(values);
+            return this;
+        };
+        this.onConflict = (updates, column) => new onConflictInsert_1.default(this._aggregator).apply(updates, column);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = ValuesInsert;

package/builders/lowLvlBuilders/selects/select.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import SelectFrom from './selectFrom';
+export default class Select {
+    static from: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => SelectFrom;
+}

package/builders/lowLvlBuilders/selects/select.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const selectAggregator_1 = require("../../aggregators/selectAggregator");
+const selectFrom_1 = require("./selectFrom");
+class Select {
+}
+exports.default = Select;
+Select.from = (table) => {
+    const aggregator = new selectAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
+    return new selectFrom_1.default(aggregator);
+};

package/builders/lowLvlBuilders/selects/selectFrom.d.ts

@@ -0,0 +1,19 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Join from '../../joinBuilders/join';
+import Expr from '../../requestBuilders/where/where';
+import SelectJoined from './selectJoined';
+import WhereSelect from './whereSelect';
+export default class SelectFrom {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    joined: (joins: Array<Join<any> | undefined>) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectFrom;
+    offset: (offset?: number | undefined) => SelectFrom;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectFrom;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined) => SelectFrom;
+    filteredBy: (filters: Expr) => WhereSelect;
+    build: () => string;
+}

package/builders/lowLvlBuilders/selects/selectFrom.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const selectJoined_1 = require("./selectJoined");
+const whereSelect_1 = require("./whereSelect");
+class SelectFrom {
+    constructor(aggregator) {
+        this.joined = (joins) => new selectJoined_1.default(this._aggregator).apply(joins);
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._aggregator.distinct(column);
+            }
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = SelectFrom;

package/builders/lowLvlBuilders/selects/selectJoined.d.ts

@@ -0,0 +1,17 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Join from '../../joinBuilders/join';
+import Expr from '../../requestBuilders/where/where';
+import WhereSelect from './whereSelect';
+export default class SelectJoined {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    apply: (joins: Array<Join<any> | undefined>) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectJoined;
+    offset: (offset?: number | undefined) => SelectJoined;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectJoined;
+    filteredBy: (filters: Expr) => WhereSelect;
+    build: () => string;
+}

package/builders/lowLvlBuilders/selects/selectJoined.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSelect_1 = require("./whereSelect");
+class SelectJoined {
+    constructor(aggregator) {
+        this.apply = (joins) => {
+            this._aggregator.join(joins);
+            return this;
+        };
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = SelectJoined;

package/builders/lowLvlBuilders/selects/whereSelect.d.ts

@@ -0,0 +1,14 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import SelectAggregator from '../../aggregators/selectAggregator';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+export default class WhereSelect {
+    private _aggregator;
+    constructor(aggregator: SelectAggregator);
+    limit: (limit?: number | undefined) => WhereSelect;
+    offset: (offset?: number | undefined) => WhereSelect;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => WhereSelect;
+    apply: (filters: Expr) => WhereSelect;
+    build: () => string;
+}

package/builders/lowLvlBuilders/selects/whereSelect.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WhereSelect {
+    constructor(aggregator) {
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.apply = (filters) => {
+            this._aggregator.filters(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSelect;

package/builders/lowLvlBuilders/updates/update.d.ts

@@ -0,0 +1,5 @@
+import { AbstractTable } from '../../../tables';
+import UpdateIn from './updateIn';
+export default class Update {
+    static in: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => UpdateIn;
+}

package/builders/lowLvlBuilders/updates/update.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updateAggregator_1 = require("../../aggregators/updateAggregator");
+const updateIn_1 = require("./updateIn");
+class Update {
+}
+exports.default = Update;
+Update.in = (table) => {
+    const aggregator = new updateAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
+    return new updateIn_1.default(aggregator);
+};

package/builders/lowLvlBuilders/updates/updateIn.d.ts

@@ -0,0 +1,10 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import UpdateExpr from '../../requestBuilders/updates/updates';
+import WhereSet from './whereSet';
+export default class UpdateIn {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    columns: () => UpdateIn;
+    set: (updates: UpdateExpr) => WhereSet<unknown, unknown>;
+    build: () => string;
+}

package/builders/lowLvlBuilders/updates/updateIn.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSet_1 = require("./whereSet");
+class UpdateIn {
+    constructor(aggregator) {
+        this.columns = () => new UpdateIn(this._aggregator);
+        this.set = (updates) => new whereSet_1.default(this._aggregator).apply(updates);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = UpdateIn;

package/builders/lowLvlBuilders/updates/whereSelect.d.ts

@@ -0,0 +1,8 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import Expr from '../../requestBuilders/where/where';
+export default class WhereSelect<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    apply: (filters: Expr) => WhereSelect<SERVICE, DB>;
+    build: () => string;
+}

package/builders/lowLvlBuilders/updates/whereSelect.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WhereSelect {
+    constructor(aggregator) {
+        this.apply = (filters) => {
+            this._aggregator.where(filters);
+            return this;
+        };
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSelect;

package/builders/lowLvlBuilders/updates/whereSet.d.ts

@@ -0,0 +1,11 @@
+import UpdateAggregator from '../../aggregators/updateAggregator';
+import UpdateExpr from '../../requestBuilders/updates/updates';
+import Expr from '../../requestBuilders/where/where';
+import WhereSelect from './whereSelect';
+export default class WhereSet<SERVICE, DB> {
+    private _aggregator;
+    constructor(aggregator: UpdateAggregator);
+    apply: (updates: UpdateExpr) => WhereSet<SERVICE, DB>;
+    filteredBy: (filters: Expr) => WhereSelect<unknown, unknown>;
+    build: () => string;
+}

package/builders/lowLvlBuilders/updates/whereSet.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const whereSelect_1 = require("./whereSelect");
+class WhereSet {
+    constructor(aggregator) {
+        this.apply = (updates) => {
+            this._aggregator.set(updates);
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.default = WhereSet;

package/builders/requestBuilders/updates/combine.d.ts

@@ -0,0 +1,6 @@
+import UpdateExpr from './updates';
+export default class Combine extends UpdateExpr {
+    private _setters;
+    constructor(setters: Array<UpdateExpr>);
+    toQuery: () => string;
+}

package/builders/requestBuilders/updates/combine.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updates_1 = require("./updates");
+class Combine extends updates_1.default {
+    constructor(setters) {
+        super();
+        this.toQuery = () => {
+            const response = [];
+            for (let index = 0; index < this._setters.length; index += 1) {
+                const setter = this._setters[index];
+                response.push(setter.toQuery());
+                if (index !== this._setters.length - 1) {
+                    response.push(', ');
+                }
+            }
+            return response.join('');
+        };
+        this._setters = setters;
+    }
+}
+exports.default = Combine;

package/builders/requestBuilders/updates/setObjects.d.ts

@@ -0,0 +1,9 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import UpdateExpr from './updates';
+export default class SetObject<T extends AbstractColumn<ColumnType<any>, boolean, boolean>> extends UpdateExpr {
+    private _column;
+    private _value;
+    constructor(column: T, value: any);
+    toQuery: () => string;
+}

package/builders/requestBuilders/updates/setObjects.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const updates_1 = require("./updates");
+class SetObject extends updates_1.default {
+    constructor(column, value) {
+        super();
+        this.toQuery = () => `"${this._column.getColumnName()}"=${this._value === null || this._value === undefined ? 'null' : this._column.getColumnType().insertStrategy(this._value)}`;
+        this._column = column;
+        this._value = value;
+    }
+}
+exports.default = SetObject;

package/builders/requestBuilders/updates/static.d.ts

@@ -0,0 +1,6 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ExtractCodeType } from '../../../tables/inferTypes';
+import UpdateExpr from './updates';
+export declare const set: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(column: T, value: ExtractCodeType<T>) => UpdateExpr;
+export declare const combine: (updates: Array<UpdateExpr>) => UpdateExpr;

package/builders/requestBuilders/updates/static.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combine = exports.set = void 0;
+const combine_1 = require("./combine");
+const setObjects_1 = require("./setObjects");
+const set = (column, value) => new setObjects_1.default(column, value);
+exports.set = set;
+const combine = (updates) => new combine_1.default(updates);
+exports.combine = combine;

package/{src/builders/requestBuilders/updates/updates.ts → builders/requestBuilders/updates/updates.d.ts}

@@ -1,3 +1,3 @@
 export default abstract class UpdateExpr {
-  abstract toQuery(): string;
+    abstract toQuery(): string;
 }

package/builders/requestBuilders/updates/updates.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class UpdateExpr {
+}
+exports.default = UpdateExpr;

package/builders/requestBuilders/where/and.d.ts

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class And extends Expr {
+    private expressions;
+    constructor(expressions: Expr[]);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/and.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class And extends where_1.default {
+    constructor(expressions) {
+        super();
+        this.toQuery = () => {
+            const result = ['('];
+            for (let i = 0; i < this.expressions.length; i += 1) {
+                const expression = this.expressions[i];
+                result.push(expression.toQuery());
+                if (i < this.expressions.length - 1) {
+                    result.push(' and ');
+                }
+            }
+            result.push(')');
+            return result.join('');
+        };
+        this.expressions = expressions;
+    }
+}
+exports.default = And;

package/builders/requestBuilders/where/const.d.ts

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class Const extends Expr {
+    private value;
+    constructor(value: any);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/const.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../../utils/ecranate");
+const where_1 = require("./where");
+class Const extends where_1.default {
+    constructor(value) {
+        super();
+        this.toQuery = () => {
+            if (ecranate_1.shouldEcranate(this.value)) {
+                return `'${this.value.toString()}'`;
+            }
+            return this.value.toString();
+        };
+        this.value = value;
+    }
+}
+exports.default = Const;

package/builders/requestBuilders/where/constArray.d.ts

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class ConstArray extends Expr {
+    private values;
+    constructor(values: Array<any>);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/constArray.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../../utils/ecranate");
+const where_1 = require("./where");
+class ConstArray extends where_1.default {
+    constructor(values) {
+        super();
+        this.toQuery = () => {
+            const finalArray = [];
+            for (let i = 0; i < this.values.length; i += 1) {
+                const value = this.values[i];
+                if (ecranate_1.shouldEcranate(value)) {
+                    finalArray.push(`'${value.toString()}'`);
+                }
+                else {
+                    finalArray.push(value.toString());
+                }
+                if (i < this.values.length - 1) {
+                    finalArray.push(',');
+                }
+            }
+            return finalArray.join('');
+        };
+        this.values = values;
+    }
+}
+exports.default = ConstArray;

package/builders/requestBuilders/where/eqWhere.d.ts

@@ -0,0 +1,7 @@
+import Expr from './where';
+export default class EqWhere extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/eqWhere.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class EqWhere extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()}=${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = EqWhere;

package/builders/requestBuilders/where/greater.d.ts

@@ -0,0 +1,10 @@
+import Expr from './where';
+export default class Greater extends Expr {
+    private left;
+    private right;
+    constructor({ left, right }: {
+        left: Expr;
+        right: Expr;
+    });
+    toQuery: () => string;
+}