@mikro-orm/sql 7.0.0-dev.216 → 7.0.0-dev.218

package/query/QueryBuilder.js

@@ -98,12 +98,20 @@ export class QueryBuilder {
     }
     select(fields, distinct = false) {
         this.ensureNotFinalized();
-        this._fields = Utils.asArray(fields);
+        this._fields = Utils.asArray(fields).flatMap(f => {
+            if (typeof f !== 'string') {
+                return f;
+            }
+            return this.resolveNestedPath(f);
+        });
         if (distinct) {
             this.flags.add(QueryFlag.DISTINCT);
         }
         return this.init(QueryType.SELECT);
     }
+    /**
+     * Adds fields to an existing SELECT query.
+     */
     addSelect(fields) {
         this.ensureNotFinalized();
         if (this._type && this._type !== QueryType.SELECT) {
@@ -115,24 +123,81 @@ export class QueryBuilder {
         this.ensureNotFinalized();
         return this.setFlag(QueryFlag.DISTINCT);
     }
-    /** postgres only */
     distinctOn(fields) {
         this.ensureNotFinalized();
         this._distinctOn = Utils.asArray(fields);
         return this;
     }
+    /**
+     * Creates an INSERT query with the given data.
+     *
+     * @example
+     * ```ts
+     * await em.createQueryBuilder(User)
+     *   .insert({ name: 'John', email: 'john@example.com' })
+     *   .execute();
+     *
+     * // Bulk insert
+     * await em.createQueryBuilder(User)
+     *   .insert([{ name: 'John' }, { name: 'Jane' }])
+     *   .execute();
+     * ```
+     */
     insert(data) {
         return this.init(QueryType.INSERT, data);
     }
+    /**
+     * Creates an UPDATE query with the given data.
+     * Use `where()` to specify which rows to update.
+     *
+     * @example
+     * ```ts
+     * await em.createQueryBuilder(User)
+     *   .update({ name: 'John Doe' })
+     *   .where({ id: 1 })
+     *   .execute();
+     * ```
+     */
     update(data) {
         return this.init(QueryType.UPDATE, data);
     }
+    /**
+     * Creates a DELETE query.
+     * Use `where()` to specify which rows to delete.
+     *
+     * @example
+     * ```ts
+     * await em.createQueryBuilder(User)
+     *   .delete()
+     *   .where({ id: 1 })
+     *   .execute();
+     *
+     * // Or pass the condition directly
+     * await em.createQueryBuilder(User)
+     *   .delete({ isActive: false })
+     *   .execute();
+     * ```
+     */
     delete(cond) {
         return this.init(QueryType.DELETE, undefined, cond);
     }
+    /**
+     * Creates a TRUNCATE query to remove all rows from the table.
+     */
     truncate() {
         return this.init(QueryType.TRUNCATE);
     }
+    /**
+     * Creates a COUNT query to count matching rows.
+     *
+     * @example
+     * ```ts
+     * const count = await em.createQueryBuilder(User)
+     *   .count()
+     *   .where({ isActive: true })
+     *   .execute('get');
+     * ```
+     */
     count(field, distinct = false) {
         if (field) {
             this._fields = Utils.asArray(field);
@@ -156,16 +221,27 @@ export class QueryBuilder {
         this.join(field, alias, cond, JoinType.innerJoin, undefined, schema);
         return this;
     }
-    innerJoinLateral(field, alias, cond, schema) {
-        this.join(field, alias, cond, JoinType.innerJoinLateral, undefined, schema);
-        return this;
+    innerJoinLateral(field, alias, cond = {}, schema) {
+        return this.join(field, alias, cond, JoinType.innerJoinLateral, undefined, schema);
     }
     leftJoin(field, alias, cond = {}, schema) {
         return this.join(field, alias, cond, JoinType.leftJoin, undefined, schema);
     }
-    leftJoinLateral(field, alias, cond, schema) {
+    leftJoinLateral(field, alias, cond = {}, schema) {
         return this.join(field, alias, cond, JoinType.leftJoinLateral, undefined, schema);
     }
+    /**
+     * Adds a JOIN clause and automatically selects the joined entity's fields.
+     * This is useful for eager loading related entities.
+     *
+     * @example
+     * ```ts
+     * const qb = em.createQueryBuilder(Book, 'b');
+     * qb.select('*')
+     *   .joinAndSelect('b.author', 'a')
+     *   .where({ 'a.name': 'John' });
+     * ```
+     */
     joinAndSelect(field, alias, cond = {}, type = JoinType.innerJoin, path, fields, schema) {
         if (!this._type) {
             this.select('*');
@@ -197,13 +273,15 @@ export class QueryBuilder {
         return this.joinAndSelect(field, alias, cond, JoinType.leftJoin, undefined, fields, schema);
     }
     leftJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, JoinType.leftJoinLateral, undefined, fields, schema);
+        this.joinAndSelect(field, alias, cond, JoinType.leftJoinLateral, undefined, fields, schema);
+        return this;
     }
     innerJoinAndSelect(field, alias, cond = {}, fields, schema) {
         return this.joinAndSelect(field, alias, cond, JoinType.innerJoin, undefined, fields, schema);
     }
     innerJoinLateralAndSelect(field, alias, cond = {}, fields, schema) {
-        return this.joinAndSelect(field, alias, cond, JoinType.innerJoinLateral, undefined, fields, schema);
+        this.joinAndSelect(field, alias, cond, JoinType.innerJoinLateral, undefined, fields, schema);
+        return this;
     }
     getFieldsForJoinedLoad(prop, alias, explicitFields) {
         const fields = [];
@@ -278,7 +356,13 @@ export class QueryBuilder {
             filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             let cond = await em.applyFilters(join.prop.targetMeta.class, join.cond, filterOptions, 'read');
             const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, join.prop.targetMeta.class, cond);
-            cond = criteriaNode.process(this, { matchPopulateJoins: true, filter: true, alias: join.alias, ignoreBranching: true, parentPath: join.path });
+            cond = criteriaNode.process(this, {
+                matchPopulateJoins: true,
+                filter: true,
+                alias: join.alias,
+                ignoreBranching: true,
+                parentPath: join.path,
+            });
             if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
@@ -308,17 +392,18 @@ export class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
+        let processedCond;
         if (isRaw(cond)) {
             const sql = this.platform.formatQuery(cond.sql, cond.params);
-            cond = { [raw(`(${sql})`)]: Utils.asArray(params) };
+            processedCond = { [raw(`(${sql})`)]: Utils.asArray(params) };
             operator ??= '$and';
         }
         else if (typeof cond === 'string') {
-            cond = { [raw(`(${cond})`, Utils.asArray(params))]: [] };
+            processedCond = { [raw(`(${cond})`, Utils.asArray(params))]: [] };
             operator ??= '$and';
         }
         else {
-            cond = QueryHelper.processWhere({
+            processedCond = QueryHelper.processWhere({
                 where: cond,
                 entityName: this.mainAlias.entityName,
                 metadata: this.metadata,
@@ -330,7 +415,7 @@ export class QueryBuilder {
         }
         const op = operator || params;
         const topLevel = !op || !(Utils.hasObjectKeys(this._cond) || RawQueryFragment.hasObjectFragments(this._cond));
-        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
+        const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processedCond);
         const ignoreBranching = this.__populateWhere === 'infer';
         if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
             // use sub-query to support joining
@@ -382,27 +467,44 @@ export class QueryBuilder {
                 convertCustomTypes: false,
                 type: 'orderBy',
             });
-            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
-            // this._orderBy.push(CriteriaNodeFactory.createNode<Entity>(this.metadata, Utils.className(this.mainAlias.entityName), processed).process(this, { matchPopulateJoins: true, type: 'orderBy' }));
+            this._orderBy.push(CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this, {
+                matchPopulateJoins: true,
+                type: 'orderBy',
+            }));
         });
         return this;
     }
     groupBy(fields) {
         this.ensureNotFinalized();
-        this._groupBy = Utils.asArray(fields);
+        this._groupBy = Utils.asArray(fields).flatMap(f => {
+            if (typeof f !== 'string') {
+                return f;
+            }
+            return this.resolveNestedPath(f);
+        });
         return this;
     }
+    /**
+     * Adds a HAVING clause to the query, typically used with GROUP BY.
+     *
+     * @example
+     * ```ts
+     * qb.select([raw('count(*) as count'), 'status'])
+     *   .groupBy('status')
+     *   .having({ count: { $gt: 5 } });
+     * ```
+     */
     having(cond = {}, params, operator) {
         this.ensureNotFinalized();
         if (typeof cond === 'string') {
             cond = { [raw(`(${cond})`, params)]: [] };
         }
-        cond = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
+        const processed = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond, undefined, undefined, false).process(this);
         if (!this._having || !operator) {
-            this._having = cond;
+            this._having = processed;
         }
         else {
-            const cond1 = [this._having, cond];
+            const cond1 = [this._having, processed];
             this._having = { [operator]: cond1 };
         }
         return this;
@@ -459,6 +561,15 @@ export class QueryBuilder {
         this._populateFilter = populateFilter;
         return this;
     }
+    /**
+     * Sets a LIMIT clause to restrict the number of results.
+     *
+     * @example
+     * ```ts
+     * qb.select('*').limit(10);        // First 10 results
+     * qb.select('*').limit(10, 20);    // 10 results starting from offset 20
+     * ```
+     */
     limit(limit, offset = 0) {
         this.ensureNotFinalized();
         this._limit = limit;
@@ -467,6 +578,14 @@ export class QueryBuilder {
         }
         return this;
     }
+    /**
+     * Sets an OFFSET clause to skip a number of results.
+     *
+     * @example
+     * ```ts
+     * qb.select('*').limit(10).offset(20);  // Results 21-30
+     * ```
+     */
     offset(offset) {
         this.ensureNotFinalized();
         this._offset = offset;
@@ -837,16 +956,13 @@ export class QueryBuilder {
         const [res] = await this.getResultList(1);
         return res || null;
     }
-    /**
-     * Executes count query (without offset and limit), returning total count of results
-     */
     async getCount(field, distinct) {
         let res;
         if (this.type === QueryType.COUNT) {
             res = await this.execute('get', false);
         }
         else {
-            const qb = this._type === undefined ? this : this.clone();
+            const qb = (this._type === undefined ? this : this.clone());
             qb.processPopulateHint(); // needs to happen sooner so `qb.hasToManyJoins()` reports correctly
             qb.count(field, distinct ?? qb.hasToManyJoins()).limit(undefined).offset(undefined).orderBy([]);
             res = await qb.execute('get', false);
@@ -857,10 +973,7 @@ export class QueryBuilder {
      * Executes the query, returning both array of results and total count query (without offset and limit).
      */
     async getResultAndCount() {
-        return [
-            await this.clone().getResultList(),
-            await this.clone().getCount(),
-        ];
+        return [await this.clone().getResultList(), await this.clone().getCount()];
     }
     as(aliasOrTargetEntity, alias) {
         const qb = this.getNativeQuery();
@@ -1066,7 +1179,9 @@ export class QueryBuilder {
             ret.push(getFieldName(field));
         });
         const requiresSQLConversion = this.mainAlias.meta.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false);
-        if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
+        if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) &&
+            (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) &&
+            requiresSQLConversion.length > 0) {
             for (const p of requiresSQLConversion) {
                 ret.push(this.helper.mapper(p.name, this.type));
             }
@@ -1078,6 +1193,84 @@ export class QueryBuilder {
         }
         return Utils.unique(ret);
     }
+    /**
+     * Resolves nested paths like `a.books.title` to their actual field references.
+     * Auto-joins relations as needed and returns `{alias}.{field}`.
+     * For embeddeds: navigates into flattened embeddeds to return the correct field name.
+     */
+    resolveNestedPath(field) {
+        if (typeof field !== 'string' || !field.includes('.')) {
+            return field;
+        }
+        const parts = field.split('.');
+        // Simple alias.property case - let prepareFields handle it
+        if (parts.length === 2 && this._aliases[parts[0]]) {
+            return field;
+        }
+        // Start with root alias
+        let currentAlias = parts[0];
+        let currentMeta = this._aliases[currentAlias] ? this.metadata.get(this._aliases[currentAlias].entityName) : this.mainAlias.meta;
+        // If first part is not an alias, it's a property of the main entity
+        if (!this._aliases[currentAlias]) {
+            currentAlias = this.mainAlias.aliasName;
+            parts.unshift(currentAlias);
+        }
+        // Walk through the path parts (skip the alias)
+        for (let i = 1; i < parts.length; i++) {
+            const propName = parts[i];
+            const prop = currentMeta.properties[propName];
+            if (!prop) {
+                return field; // Unknown property, return as-is for raw SQL support
+            }
+            const isLastPart = i === parts.length - 1;
+            // Handle embedded properties - navigate into flattened embeddeds
+            if (prop.kind === ReferenceKind.EMBEDDED) {
+                if (prop.object) {
+                    return `${currentAlias}.${propName}`;
+                }
+                // Navigate through remaining path to find the leaf property
+                const remainingPath = parts.slice(i + 1);
+                let embeddedProp = prop;
+                for (const part of remainingPath) {
+                    embeddedProp = embeddedProp?.embeddedProps?.[part];
+                    if (embeddedProp?.object && embeddedProp.fieldNames?.[0]) {
+                        return `${currentAlias}.${embeddedProp.fieldNames[0]}`;
+                    }
+                }
+                return `${currentAlias}.${embeddedProp?.fieldNames?.[0] ?? propName}`;
+            }
+            // Handle relations - auto-join if not the last part
+            if (prop.kind === ReferenceKind.MANY_TO_ONE ||
+                prop.kind === ReferenceKind.ONE_TO_ONE ||
+                prop.kind === ReferenceKind.ONE_TO_MANY ||
+                prop.kind === ReferenceKind.MANY_TO_MANY) {
+                if (isLastPart) {
+                    return `${currentAlias}.${propName}`;
+                }
+                // Find existing join or create new one
+                const joinPath = parts.slice(0, i + 1).join('.');
+                const existingJoinKey = Object.keys(this._joins).find(k => {
+                    const join = this._joins[k];
+                    // Check by path or by key prefix (key format is `alias.field#joinAlias`)
+                    return join.path === joinPath || k.startsWith(`${currentAlias}.${propName}#`);
+                });
+                let joinAlias;
+                if (existingJoinKey) {
+                    joinAlias = this._joins[existingJoinKey].alias;
+                }
+                else {
+                    joinAlias = this.getNextAlias(prop.targetMeta?.className ?? propName);
+                    this.join(`${currentAlias}.${propName}`, joinAlias, {}, JoinType.leftJoin);
+                }
+                currentAlias = joinAlias;
+                currentMeta = prop.targetMeta;
+                continue;
+            }
+            // Scalar property - return it (if not last part, it's an invalid path but let SQL handle it)
+            return `${currentAlias}.${propName}`;
+        }
+        return field;
+    }
     init(type, data, cond) {
         this.ensureNotFinalized();
         this._type = type;
@@ -1344,7 +1537,10 @@ export class QueryBuilder {
     wrapPaginateSubQuery(meta) {
         const schema = this.getSchema(this.mainAlias);
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query', schema);
-        const subQuery = this.clone(['_orderBy', '_fields', 'lockMode', 'lockTableAliases']).select(pks).groupBy(pks).limit(this._limit);
+        const subQuery = this.clone(['_orderBy', '_fields', 'lockMode', 'lockTableAliases'])
+            .select(pks)
+            .groupBy(pks)
+            .limit(this._limit);
         // revert the on conditions added via populateWhere, we want to apply those only once
         for (const join of Object.values(subQuery._joins)) {
             if (join.cond_) {

package/query/QueryBuilderHelper.d.ts

@@ -1,6 +1,6 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlatQueryOrderMap, type FormulaTable, LockMode, type QBFilterQuery, type QBQueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FlatQueryOrderMap, type FormulaTable, LockMode, type QueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
-import type { Field, JoinOptions } from '../typings.js';
+import type { InternalField, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -45,10 +45,10 @@ export declare class QueryBuilderHelper {
     private processObjectSubCondition;
     private getValueReplacement;
     private getOperatorReplacement;
-    validateQueryOrder<T>(orderBy: QBQueryOrderMap<T>): void;
+    validateQueryOrder<T>(orderBy: QueryOrderMap<T>): void;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
-    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
+    finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: InternalField<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;
     updateVersionProperty(qb: NativeQueryBuilder, data: Dictionary): void;
@@ -58,7 +58,7 @@ export declare class QueryBuilderHelper {
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
     isTableNameAliasRequired(type: QueryType): boolean;
-    processOnConflictCondition(cond: QBFilterQuery, schema?: string): QBFilterQuery;
+    processOnConflictCondition(cond: FilterQuery<any>, schema?: string): FilterQuery<any>;
     createFormulaTable(alias: string, meta: EntityMetadata, schema?: string): FormulaTable;
 }
 export interface Alias<T> {
@@ -70,6 +70,6 @@ export interface Alias<T> {
 export interface OnConflictClause<T> {
     fields: string[] | Raw;
     ignore?: boolean;
-    merge?: EntityData<T> | Field<T>[];
-    where?: QBFilterQuery<T>;
+    merge?: EntityData<T> | InternalField<T>[];
+    where?: FilterQuery<T>;
 }

package/query/QueryBuilderHelper.js

@@ -68,10 +68,6 @@ export class QueryBuilderHelper {
         const prop = this.getProperty(f, a);
         const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
         const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
-        // embeddable nested path instead of a regular property with table alias, reset alias
-        if (prop?.name === a && prop.embeddedProps[f]) {
-            return aliasPrefix + prop.fieldNames[fkIdx];
-        }
         if (a === prop?.embedded?.[0]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
         }
@@ -621,14 +617,15 @@ export class QueryBuilderHelper {
         if (type === QueryType.UPDATE) {
             const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
-                qb.returning(returningProps.flatMap(prop => {
+                const fields = returningProps.flatMap((prop) => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                         const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
                         return [raw(sql)];
                     }
                     return prop.fieldNames;
-                }));
+                });
+                qb.returning(fields);
             }
         }
     }
@@ -753,10 +750,6 @@ export class QueryBuilderHelper {
         if (alias) {
             const prop = meta.properties[alias];
             if (prop?.kind === ReferenceKind.EMBEDDED) {
-                // we want to select the full object property so hydration works as expected
-                if (prop.object) {
-                    return prop;
-                }
                 const parts = field.split('.');
                 const nest = (p) => parts.length > 0 ? nest(p.embeddedProps[parts.shift()]) : p;
                 return nest(prop);

package/query/raw.d.ts

@@ -1,6 +1,13 @@
 import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
-import type { SelectQueryBuilder } from 'kysely';
-import { QueryBuilder } from './QueryBuilder.js';
+import type { SelectQueryBuilder as KyselySelectQueryBuilder } from 'kysely';
+/** @internal Type for QueryBuilder instances passed to raw() - uses toRaw to distinguish from Kysely QueryBuilder */
+type QueryBuilderLike = {
+    toQuery(): {
+        sql: string;
+        params: readonly unknown[];
+    };
+    toRaw(): RawQueryFragment;
+};
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -56,4 +63,5 @@ import { QueryBuilder } from './QueryBuilder.js';
  * export class Author { ... }
  * ```
  */
-export declare function raw<T extends object = any, R = any>(sql: SelectQueryBuilder<any, any, any> | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: QueryBuilderLike | KyselySelectQueryBuilder<any, any, any> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export {};

package/query/raw.js

@@ -1,5 +1,4 @@
 import { raw as raw_, Utils } from '@mikro-orm/core';
-import { QueryBuilder } from './QueryBuilder.js';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -60,7 +59,7 @@ export function raw(sql, params) {
         const query = sql.compile();
         return raw_(query.sql, query.parameters);
     }
-    if (sql instanceof QueryBuilder) {
+    if (Utils.isObject(sql) && 'toQuery' in sql) {
         const query = sql.toQuery();
         return raw_(query.sql, query.params);
     }