@yandjin-mikro-orm/knex 6.1.4-rc-sti-changes-1

package/query/ObjectCriteriaNode.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectCriteriaNode = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CriteriaNode_1 = require("./CriteriaNode");
+const enums_1 = require("./enums");
+/**
+ * @internal
+ */
+class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
+    process(qb, options) {
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const ownerAlias = options?.alias || qb.alias;
+        const keys = Object.keys(this.payload);
+        let alias = options?.alias;
+        if (nestedAlias) {
+            alias = nestedAlias;
+        }
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            if (keys.some((k) => ["$some", "$none", "$every"].includes(k))) {
+                const $and = [];
+                const primaryKeys = this.metadata
+                    .find(this.entityName)
+                    .primaryKeys.map((pk) => {
+                    return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type)
+                        ? `${alias}.${pk}`
+                        : pk;
+                });
+                for (const key of keys) {
+                    if (!["$some", "$none", "$every"].includes(key)) {
+                        throw new Error("Mixing collection operators with other filters is not allowed.");
+                    }
+                    const payload = this.payload[key].unwrap();
+                    const sub = qb
+                        .clone(true)
+                        .from(this.parent.entityName)
+                        .innerJoin(this.key, qb.getNextAlias(this.prop.type))
+                        .select(this.prop.targetMeta.primaryKeys);
+                    if (key === "$every") {
+                        sub.where({ $not: { [this.key]: payload } });
+                    }
+                    else {
+                        sub.where({ [this.key]: payload });
+                    }
+                    const op = key === "$some" ? "$in" : "$nin";
+                    $and.push({
+                        [core_1.Utils.getPrimaryKeyHash(primaryKeys)]: {
+                            [op]: sub.getKnexQuery(),
+                        },
+                    });
+                }
+                return { $and };
+            }
+            alias = this.autoJoin(qb, ownerAlias);
+        }
+        return keys.reduce((o, field) => {
+            const childNode = this.payload[field];
+            const payload = childNode.process(qb, {
+                ...options,
+                alias: this.prop ? alias : ownerAlias,
+            });
+            const operator = core_1.Utils.isOperator(field);
+            const isRawField = core_1.RawQueryFragment.isKnownFragment(field);
+            // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
+            const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
+            // if key is missing, we are inside group operator and we need to prefix with alias
+            const primaryKey = this.key &&
+                this.metadata.find(this.entityName).primaryKeys.includes(field);
+            if (childNode.shouldInline(payload)) {
+                const childAlias = qb.getAliasForJoinPath(childNode.getPath(), options);
+                this.inlineChildPayload(o, payload, field, alias, childAlias);
+            }
+            else if (childNode.shouldRename(payload)) {
+                o[childNode.renameFieldToPK(qb)] = payload;
+            }
+            else if (isRawField) {
+                const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+                o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (primaryKey ||
+                virtual ||
+                operator ||
+                field.includes(".") ||
+                ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
+                o[field.replaceAll(core_1.ALIAS_REPLACEMENT, alias)] = payload;
+            }
+            else {
+                o[`${alias}.${field}`] = payload;
+            }
+            return o;
+        }, {});
+    }
+    unwrap() {
+        return Object.keys(this.payload).reduce((o, field) => {
+            o[field] = this.payload[field].unwrap();
+            return o;
+        }, {});
+    }
+    willAutoJoin(qb, alias) {
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath());
+        const ownerAlias = alias || qb.alias;
+        const keys = Object.keys(this.payload);
+        if (nestedAlias) {
+            alias = nestedAlias;
+        }
+        if (this.shouldAutoJoin(qb, nestedAlias)) {
+            return !keys.some((k) => ["$some", "$none", "$every"].includes(k));
+        }
+        return keys.some((field) => {
+            const childNode = this.payload[field];
+            return childNode.willAutoJoin(qb, this.prop ? alias : ownerAlias);
+        });
+    }
+    shouldInline(payload) {
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
+        const scalar = core_1.Utils.isPrimaryKey(payload) ||
+            payload instanceof RegExp ||
+            payload instanceof Date ||
+            customExpression;
+        const operator = core_1.Utils.isObject(payload) &&
+            Object.keys(payload).every((k) => core_1.Utils.isOperator(k, false));
+        return (!!this.prop &&
+            this.prop.kind !== core_1.ReferenceKind.SCALAR &&
+            !scalar &&
+            !operator);
+    }
+    inlineChildPayload(o, payload, field, alias, childAlias) {
+        const prop = this.metadata.find(this.entityName).properties[field];
+        for (const k of Object.keys(payload)) {
+            if (core_1.Utils.isOperator(k, false)) {
+                const tmp = payload[k];
+                delete payload[k];
+                o[this.aliased(field, alias)] = {
+                    [k]: tmp,
+                    ...(o[this.aliased(field, alias)] || {}),
+                };
+            }
+            else if (this.isPrefixed(k) || core_1.Utils.isOperator(k) || !childAlias) {
+                const idx = prop.referencedPKs.indexOf(k);
+                const key = idx !== -1 &&
+                    !childAlias &&
+                    ![core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)
+                    ? prop.joinColumns[idx]
+                    : k;
+                if (key in o) {
+                    const $and = o.$and ?? [];
+                    $and.push({ [key]: o[key] }, { [key]: payload[k] });
+                    delete o[key];
+                    o.$and = $and;
+                }
+                else if (core_1.Utils.isOperator(k) && Array.isArray(payload[k])) {
+                    o[key] = payload[k].map((child) => Object.keys(child).reduce((o, childKey) => {
+                        const key = this.isPrefixed(childKey) || core_1.Utils.isOperator(childKey)
+                            ? childKey
+                            : this.aliased(childKey, childAlias);
+                        o[key] = child[childKey];
+                        return o;
+                    }, {}));
+                }
+                else {
+                    o[key] = payload[k];
+                }
+            }
+            else if (core_1.RawQueryFragment.isKnownFragment(k)) {
+                o[k] = payload[k];
+            }
+            else {
+                o[`${childAlias}.${k}`] = payload[k];
+                o[this.aliased(k, childAlias)] = payload[k];
+            }
+        }
+    }
+    shouldAutoJoin(qb, nestedAlias) {
+        if (!this.prop || !this.parent) {
+            return false;
+        }
+        const keys = Object.keys(this.payload);
+        if (keys.every((k) => k.includes(".") && k.startsWith(`${qb.alias}.`))) {
+            return false;
+        }
+        const meta = this.metadata.find(this.entityName);
+        const embeddable = this.prop.kind === core_1.ReferenceKind.EMBEDDED;
+        const knownKey = [
+            core_1.ReferenceKind.SCALAR,
+            core_1.ReferenceKind.MANY_TO_ONE,
+            core_1.ReferenceKind.EMBEDDED,
+        ].includes(this.prop.kind) ||
+            (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && this.prop.owner);
+        const operatorKeys = knownKey && keys.every((key) => core_1.Utils.isOperator(key, false));
+        const primaryKeys = knownKey &&
+            keys.every((key) => {
+                if (!meta.primaryKeys.includes(key)) {
+                    return false;
+                }
+                if (!core_1.Utils.isPlainObject(this.payload[key].payload) ||
+                    ![core_1.ReferenceKind.ONE_TO_ONE, core_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[key].kind)) {
+                    return true;
+                }
+                return Object.keys(this.payload[key].payload).every((k) => meta.properties[key].targetMeta.primaryKeys.includes(k));
+            });
+        return !primaryKeys && !nestedAlias && !operatorKeys && !embeddable;
+    }
+    autoJoin(qb, alias) {
+        const nestedAlias = qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+        const customExpression = core_1.RawQueryFragment.isKnownFragment(this.key);
+        const scalar = core_1.Utils.isPrimaryKey(this.payload) ||
+            this.payload instanceof RegExp ||
+            this.payload instanceof Date ||
+            customExpression;
+        const operator = core_1.Utils.isPlainObject(this.payload) &&
+            Object.keys(this.payload).every((k) => core_1.Utils.isOperator(k, false));
+        const field = `${alias}.${this.prop.name}`;
+        const method = qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)
+            ? "joinAndSelect"
+            : "join";
+        if (this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY &&
+            (scalar || operator)) {
+            qb.join(field, nestedAlias, undefined, enums_1.JoinType.pivotJoin, this.getPath());
+        }
+        else {
+            const prev = qb._fields?.slice();
+            qb[method](field, nestedAlias, undefined, enums_1.JoinType.leftJoin, this.getPath());
+            if (!qb.hasFlag(core_1.QueryFlag.INFER_POPULATE)) {
+                qb._fields = prev;
+            }
+        }
+        return nestedAlias;
+    }
+    isPrefixed(field) {
+        return !!field.match(/\w+\./);
+    }
+}
+exports.ObjectCriteriaNode = ObjectCriteriaNode;

package/query/QueryBuilder.d.ts

@@ -0,0 +1,291 @@
+/// <reference types="node" />
+import { inspect } from "util";
+import type { Knex } from "knex";
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryResult, type RequiredEntityData } from "@yandjin-mikro-orm/core";
+import { JoinType, QueryType } from "./enums";
+import type { AbstractSqlDriver } from "../AbstractSqlDriver";
+import { type Alias, QueryBuilderHelper } from "./QueryBuilderHelper";
+import type { SqlEntityManager } from "../SqlEntityManager";
+import type { Field, ICriteriaNodeProcessOptions, JoinOptions } from "../typings";
+import type { AbstractSqlPlatform } from "../AbstractSqlPlatform";
+export interface ExecuteOptions {
+    mapResults?: boolean;
+    mergeResults?: boolean;
+}
+/**
+ * SQL query builder with fluent interface.
+ *
+ * ```ts
+ * const qb = orm.em.createQueryBuilder(Publisher);
+ * qb.select('*')
+ *   .where({
+ *     name: 'test 123',
+ *     type: PublisherType.GLOBAL,
+ *   })
+ *   .orderBy({
+ *     name: QueryOrder.DESC,
+ *     type: QueryOrder.ASC,
+ *   })
+ *   .limit(2, 1);
+ *
+ * const publisher = await qb.getSingleResult();
+ * ```
+ */
+export declare class QueryBuilder<T extends object = AnyEntity> {
+    #private;
+    private readonly metadata;
+    private readonly driver;
+    private readonly context?;
+    private connectionType?;
+    private readonly em?;
+    private readonly loggerContext?;
+    get mainAlias(): Alias<T>;
+    get alias(): string;
+    get helper(): QueryBuilderHelper;
+    /** @internal */
+    type?: QueryType;
+    /** @internal */
+    _fields?: Field<T>[];
+    /** @internal */
+    _populate: PopulateOptions<T>[];
+    /** @internal */
+    _populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
+    /** @internal */
+    __populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
+    /** @internal */
+    _populateMap: Dictionary<string>;
+    /** @internal */
+    readonly rawFragments: Set<string>;
+    private aliasCounter;
+    private flags;
+    private finalized;
+    private _joins;
+    private _explicitAlias;
+    private _schema?;
+    private _cond;
+    private _data;
+    private _orderBy;
+    private _groupBy;
+    private _having;
+    private _returning?;
+    private _onConflict?;
+    private _limit?;
+    private _offset?;
+    private _distinctOn?;
+    private _joinedProps;
+    private _cache?;
+    private _indexHint?;
+    private _comments;
+    private _hintComments;
+    private flushMode?;
+    private lockMode?;
+    private lockTables?;
+    private subQueries;
+    private _mainAlias?;
+    private _aliases;
+    private _helper?;
+    private readonly platform;
+    private readonly knex;
+    /**
+     * @internal
+     */
+    constructor(entityName: EntityName<T> | QueryBuilder<T>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: LoggingOptions | undefined);
+    select(fields: Field<T> | Field<T>[], distinct?: boolean): SelectQueryBuilder<T>;
+    addSelect(fields: Field<T> | Field<T>[]): SelectQueryBuilder<T>;
+    distinct(): SelectQueryBuilder<T>;
+    /** postgres only */
+    distinctOn(fields: string | string[]): SelectQueryBuilder<T>;
+    insert(data: RequiredEntityData<T> | RequiredEntityData<T>[]): InsertQueryBuilder<T>;
+    update(data: EntityData<T>): UpdateQueryBuilder<T>;
+    delete(cond?: QBFilterQuery): DeleteQueryBuilder<T>;
+    truncate(): TruncateQueryBuilder<T>;
+    count(field?: string | string[], distinct?: boolean): CountQueryBuilder<T>;
+    join(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, schema?: string): this;
+    innerJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    innerJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoin(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    leftJoinLateral(field: string | Knex.QueryBuilder | QueryBuilder<any>, alias: string, cond?: QBFilterQuery, schema?: string): this;
+    joinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    leftJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    innerJoinLateralAndSelect(field: string | [field: string, qb: Knex.QueryBuilder | QueryBuilder<any>], alias: string, cond?: QBFilterQuery, fields?: string[], schema?: string): SelectQueryBuilder<T>;
+    protected getFieldsForJoinedLoad(prop: EntityProperty<T>, alias: string, explicitFields?: string[]): Field<T>[];
+    withSubQuery(subQuery: Knex.QueryBuilder, alias: string): this;
+    where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
+    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
+    andWhere(cond: QBFilterQuery<T>): this;
+    andWhere(cond: string, params?: any[]): this;
+    orWhere(cond: QBFilterQuery<T>): this;
+    orWhere(cond: string, params?: any[]): this;
+    orderBy(orderBy: QBQueryOrderMap<T> | QBQueryOrderMap<T>[]): SelectQueryBuilder<T>;
+    groupBy(fields: (string | keyof T) | readonly (string | keyof T)[]): SelectQueryBuilder<T>;
+    having(cond?: QBFilterQuery | string, params?: any[]): SelectQueryBuilder<T>;
+    onConflict(fields?: Field<T> | Field<T>[]): InsertQueryBuilder<T>;
+    ignore(): this;
+    merge(data?: EntityData<T> | Field<T>[]): this;
+    returning(fields?: Field<T> | Field<T>[]): this;
+    /**
+     * @internal
+     */
+    populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`): this;
+    limit(limit?: number, offset?: number): SelectQueryBuilder<T>;
+    offset(offset?: number): SelectQueryBuilder<T>;
+    withSchema(schema?: string): this;
+    setLockMode(mode?: LockMode, tables?: string[]): this;
+    setFlushMode(flushMode?: FlushMode): this;
+    setFlag(flag: QueryFlag): this;
+    unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
+    cache(config?: boolean | number | [string, number]): this;
+    /**
+     * Adds index hint to the FROM clause.
+     */
+    indexHint(sql: string): this;
+    /**
+     * Prepend comment to the sql query using the syntax `/* ... *&#8205;/`. Some characters are forbidden such as `/*, *&#8205;/` and `?`.
+     */
+    comment(comment: string | string[]): this;
+    /**
+     * Add hints to the query using comment-like syntax `/*+ ... *&#8205;/`. MySQL and Oracle use this syntax for optimizer hints.
+     * Also various DB proxies and routers use this syntax to pass hints to alter their behavior. In other dialects the hints
+     * are ignored as simple comments.
+     */
+    hintComment(comment: string | string[]): this;
+    /**
+     * Specifies FROM which entity's table select/update/delete will be executed, removing all previously set FROM-s.
+     * Allows setting a main string alias of the selection data.
+     */
+    from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): SelectQueryBuilder<T>;
+    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): SelectQueryBuilder<T>;
+    getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    /**
+     * @internal
+     */
+    clearRawFragmentsCache(): void;
+    /**
+     * Returns the query with parameters as wildcards.
+     */
+    getQuery(): string;
+    toQuery(): {
+        sql: string;
+        _sql: Knex.Sql;
+        params: readonly unknown[];
+    };
+    /**
+     * Returns the list of all parameters for this query.
+     */
+    getParams(): readonly Knex.Value[];
+    /**
+     * Returns raw interpolated query string with all the parameters inlined.
+     */
+    getFormattedQuery(): string;
+    /**
+     * @internal
+     */
+    getAliasForJoinPath(path?: string | JoinOptions, options?: ICriteriaNodeProcessOptions): string | undefined;
+    /**
+     * @internal
+     */
+    getJoinForPath(path: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
+    /**
+     * @internal
+     */
+    getNextAlias(entityName?: string): string;
+    /**
+     * @internal
+     */
+    getAliasMap(): Dictionary<string>;
+    /**
+     * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
+     * Use `method` to specify what kind of result you want to get (array/single/meta).
+     */
+    execute<U = any>(method?: "all" | "get" | "run", options?: ExecuteOptions | boolean): Promise<U>;
+    /**
+     * Alias for `qb.getResultList()`
+     */
+    getResult(): Promise<T[]>;
+    /**
+     * Executes the query, returning array of results
+     */
+    getResultList(limit?: number): Promise<T[]>;
+    /**
+     * Executes the query, returning the first result or null
+     */
+    getSingleResult(): Promise<T | null>;
+    /**
+     * Executes count query (without offset and limit), returning total count of results
+     */
+    getCount(field?: string | string[], distinct?: boolean): Promise<number>;
+    /**
+     * Executes the query, returning both array of results and total count query (without offset and limit).
+     */
+    getResultAndCount(): Promise<[T[], number]>;
+    /**
+     * Provides promise-like interface so we can await the QB instance.
+     */
+    then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[] | number | QueryResult<T>>;
+    /**
+     * Returns knex instance with sub-query aliased with given alias.
+     * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
+     */
+    as(alias: string): Knex.QueryBuilder;
+    clone(reset?: boolean | string[]): QueryBuilder<T>;
+    getKnex(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    private fromVirtual;
+    private joinReference;
+    private prepareFields;
+    private init;
+    private getQueryBase;
+    private applyDiscriminatorCondition;
+    private finalize;
+    private processPopulateWhere;
+    private hasToManyJoins;
+    private wrapPaginateSubQuery;
+    private wrapModifySubQuery;
+    private getSchema;
+    private createAlias;
+    private createMainAlias;
+    private fromSubQuery;
+    private fromEntityName;
+    private createQueryBuilderHelper;
+    private ensureFromClause;
+    private ensureNotFinalized;
+    /** @ignore */
+    [inspect.custom](depth: number): string;
+}
+export interface RunQueryBuilder<T extends object> extends Omit<QueryBuilder<T>, "getResult" | "getSingleResult" | "getResultList" | "where"> {
+    where(cond: QBFilterQuery<T> | string, params?: keyof typeof GroupOperator | any[], operator?: keyof typeof GroupOperator): this;
+    execute<U = QueryResult<T>>(method?: "all" | "get" | "run", mapResults?: boolean): Promise<U>;
+    then<TResult1 = QueryResult<T>, TResult2 = never>(onfulfilled?: ((value: QueryResult<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<QueryResult<T>>;
+}
+export interface SelectQueryBuilder<T extends object> extends QueryBuilder<T> {
+    execute<U = T[]>(method?: "all" | "get" | "run", mapResults?: boolean): Promise<U>;
+    execute<U = T[]>(method: "all", mapResults?: boolean): Promise<U>;
+    execute<U = T>(method: "get", mapResults?: boolean): Promise<U>;
+    execute<U = QueryResult<T>>(method: "run", mapResults?: boolean): Promise<U>;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<T[]>;
+}
+export interface CountQueryBuilder<T extends object> extends QueryBuilder<T> {
+    execute<U = {
+        count: number;
+    }[]>(method?: "all" | "get" | "run", mapResults?: boolean): Promise<U>;
+    execute<U = {
+        count: number;
+    }[]>(method: "all", mapResults?: boolean): Promise<U>;
+    execute<U = {
+        count: number;
+    }>(method: "get", mapResults?: boolean): Promise<U>;
+    execute<U = QueryResult<{
+        count: number;
+    }>>(method: "run", mapResults?: boolean): Promise<U>;
+    then<TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<number>;
+}
+export interface InsertQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface UpdateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface DeleteQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}
+export interface TruncateQueryBuilder<T extends object> extends RunQueryBuilder<T> {
+}