@mikro-orm/knex 6.4.6-dev.8 → 7.0.0-dev.0

package/AbstractSqlDriver.js

@@ -122,10 +122,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (res instanceof query_1.QueryBuilder) {
             return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options, type);
         }
-        if (!(res instanceof Promise) && core_1.Utils.isObject(res)) {
-            const { sql, bindings } = res.toSQL();
-            const query = this.platform.formatQuery(sql, bindings);
-            return this.wrapVirtualExpressionInSubquery(meta, query, where, options, type);
+        if (res instanceof core_1.RawQueryFragment) {
+            const expr = this.platform.formatQuery(res.sql, res.params);
+            return this.wrapVirtualExpressionInSubquery(meta, expr, where, options, type);
         }
         /* istanbul ignore next */
         return res;
@@ -150,15 +149,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             qb.limit(options?.limit, options?.offset);
         }
-        const kqb = qb.getKnexQuery(false).clear('select');
+        const native = qb.getNativeQuery(false).clear('select');
         if (type === query_1.QueryType.COUNT) {
-            kqb.select(this.connection.getKnex().raw('count(*) as count'));
+            native.count();
         }
         else { // select
-            kqb.select('*');
+            native.select('*');
         }
-        kqb.fromRaw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`);
-        const res = await this.execute(kqb);
+        native.from((0, core_1.raw)(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
+        const query = native.compile();
+        const res = await this.execute(query.sql, query.params, 'all', options.ctx);
         if (type === query_1.QueryType.COUNT) {
             return res[0].count;
         }
@@ -371,7 +371,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (meta && this.platform.usesOutputStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
-                .filter(prop => !(prop.name in data[0]) || core_1.Utils.isRawSql(data[0][prop.name]));
+                .filter(prop => !(prop.name in data[0]) || (0, core_1.isRaw)(data[0][prop.name]));
             const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
             sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
@@ -436,7 +436,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     else {
                         const field = prop.fieldNames[0];
                         if (!duplicates.includes(field) || !usedDups.includes(field)) {
-                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(row[prop.name])) {
+                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !(0, core_1.isRaw)(row[prop.name])) {
                                 keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
                             }
                             else {
@@ -453,7 +453,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (meta && this.platform.usesReturningStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
-                .filter(prop => !(prop.name in data[0]) || core_1.Utils.isRawSql(data[0][prop.name]));
+                .filter(prop => !(prop.name in data[0]) || (0, core_1.isRaw)(data[0][prop.name]));
             const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
             /* istanbul ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
@@ -549,7 +549,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         for (const row of data) {
             for (const k of core_1.Utils.keys(row)) {
                 keys.add(k);
-                if (core_1.Utils.isRawSql(row[k])) {
+                if ((0, core_1.isRaw)(row[k])) {
                     returning.add(k);
                 }
             }
@@ -587,7 +587,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     if (key in data[idx]) {
                         const pks = core_1.Utils.getOrderedPrimaryKeys(cond, meta);
                         sql += ` when (${pkCond}) then `;
-                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(data[idx][key])) {
+                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !(0, core_1.isRaw)(data[idx][key])) {
                             sql += prop.customType.convertToDatabaseValueSQL('?', this.platform);
                         }
                         else {
@@ -706,24 +706,24 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     .withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
-                        const kqb = qb.delete({ [coll.property.mappedBy]: pks })
-                            .getKnexQuery()
-                            .whereNotIn(cols, insertDiff);
-                        await this.rethrow(this.execute(kqb));
+                        const query = qb.delete({ [coll.property.mappedBy]: pks })
+                            .andWhere({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
+                        await this.rethrow(query.execute());
                         continue;
                     }
-                    const kqb = qb.update({ [coll.property.mappedBy]: null })
+                    const query = qb.update({ [coll.property.mappedBy]: null })
                         .where({ [coll.property.mappedBy]: pks })
-                        .getKnexQuery()
-                        .andWhere(qb => qb.whereNotIn(cols, insertDiff));
-                    await this.rethrow(this.execute(kqb));
+                        .andWhere({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
+                    await this.rethrow(query.execute());
+                    continue;
+                }
+                /* istanbul ignore next */
+                {
+                    const query = qb.update({ [coll.property.mappedBy]: pks })
+                        .where({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $in: insertDiff } });
+                    await this.rethrow(query.execute());
                     continue;
                 }
-                const kqb = qb.update({ [coll.property.mappedBy]: pks })
-                    .getKnexQuery()
-                    .whereIn(cols, insertDiff);
-                await this.rethrow(this.execute(kqb));
-                continue;
             }
             /* istanbul ignore next */
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
@@ -851,8 +851,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return [];
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx, loggerContext) {
-        return this.rethrow(this.connection.execute(queryOrKnex, params, method, ctx, loggerContext));
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
+        return this.rethrow(this.connection.execute(query, params, method, ctx, loggerContext));
     }
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
@@ -927,11 +927,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return res;
     }
-    getFieldsForJoinedLoad(qb, meta, explicitFields, exclude, populate = [], options, parentTableAlias, parentJoinPath, count) {
+    getFieldsForJoinedLoad(qb, meta, options) {
         const fields = [];
+        const populate = options.populate ?? [];
         const joinedProps = this.joinedProps(meta, populate, options);
         const shouldHaveColumn = (prop, populate, fields) => {
-            if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
+            if (!this.platform.shouldHaveColumn(prop, populate, options.exclude)) {
                 return false;
             }
             if (!fields || fields.includes('*') || prop.primary) {
@@ -941,11 +942,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         };
         const populateWhereAll = options?._populateWhere === 'all' || core_1.Utils.isEmpty(options?._populateWhere);
         // root entity is already handled, skip that
-        if (parentJoinPath) {
+        if (options.parentJoinPath) {
             // alias all fields in the primary table
             meta.props
-                .filter(prop => shouldHaveColumn(prop, populate, explicitFields))
-                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias)));
+                .filter(prop => shouldHaveColumn(prop, populate, options.explicitFields))
+                .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias)));
         }
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
@@ -954,15 +955,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
                 continue;
             }
-            if (count && (!options?.populateFilter || !options.populateFilter[prop.name])) {
+            if (options.count && (!options?.populateFilter || !options.populateFilter[prop.name])) {
                 continue;
             }
             const meta2 = this.metadata.find(prop.type);
             const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
-            const field = parentTableAlias ? `${parentTableAlias}.${prop.name}` : prop.name;
-            let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
-            if (!parentJoinPath && populateWhereAll && !hint.filter && !path.startsWith('[populate]')) {
+            const field = `${options.parentTableAlias}.${prop.name}`;
+            let path = options.parentJoinPath ? `${options.parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
+            if (!options.parentJoinPath && populateWhereAll && !hint.filter && !path.startsWith('[populate]')) {
                 path = '[populate]' + path;
             }
             const joinType = pivotRefJoin
@@ -975,17 +976,31 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
             if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY && ref) {
-                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, prop.referencedColumnNames, undefined, hint.children, options, tableAlias, path, count));
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, {
+                    ...options,
+                    explicitFields: prop.referencedColumnNames,
+                    exclude: undefined,
+                    populate: hint.children,
+                    parentTableAlias: tableAlias,
+                    parentJoinPath: path,
+                }));
             }
-            const childExplicitFields = explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
-            explicitFields?.forEach(f => {
+            const childExplicitFields = options.explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
+            options.explicitFields?.forEach(f => {
                 if (typeof f === 'string' && f.startsWith(`${prop.name}.`)) {
                     childExplicitFields.push(f.substring(prop.name.length + 1));
                 }
             });
-            const childExclude = exclude ? core_1.Utils.extractChildElements(exclude, prop.name) : exclude;
+            const childExclude = options.exclude ? core_1.Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
             if (!ref && !prop.mapToPk) {
-                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path, count));
+                fields.push(...this.getFieldsForJoinedLoad(qb, meta2, {
+                    ...options,
+                    explicitFields: childExplicitFields.length === 0 ? undefined : childExplicitFields,
+                    exclude: childExclude,
+                    populate: hint.children,
+                    parentTableAlias: tableAlias,
+                    parentJoinPath: path,
+                }));
             }
             else if (hint.filter || prop.mapToPk) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
@@ -997,8 +1012,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      * @internal
      */
     mapPropToFieldNames(qb, prop, tableAlias) {
-        const aliased = this.platform.quoteIdentifier(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]);
-        if (tableAlias && prop.customTypes?.some(type => type?.convertToJSValueSQL)) {
+        const aliased = this.platform.quoteIdentifier(`${tableAlias}__${prop.fieldNames[0]}`);
+        if (prop.customTypes?.some(type => type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
                 if (!prop.customTypes[idx]?.convertToJSValueSQL) {
                     return col;
@@ -1008,20 +1023,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 return (0, core_1.raw)(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
             });
         }
-        if (tableAlias && prop.customType?.convertToJSValueSQL) {
+        if (prop.customType?.convertToJSValueSQL) {
             const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${prop.fieldNames[0]}`);
             return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
-            const alias = this.platform.quoteIdentifier(tableAlias ?? qb.alias);
+            const alias = this.platform.quoteIdentifier(tableAlias);
             return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
         }
-        if (tableAlias) {
-            return prop.fieldNames.map(fieldName => {
-                return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
-            });
-        }
-        return prop.fieldNames;
+        return prop.fieldNames.map(fieldName => {
+            return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
+        });
     }
     /** @internal */
     createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
@@ -1308,7 +1320,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         // add joined relations after the root entity fields
         if (joinedProps.length > 0) {
-            ret.push(...this.getFieldsForJoinedLoad(qb, meta, options.fields, options.exclude, populate, options, alias, undefined, count));
+            ret.push(...this.getFieldsForJoinedLoad(qb, meta, {
+                explicitFields: options.fields,
+                exclude: options.exclude,
+                populate,
+                parentTableAlias: alias,
+                count,
+                ...options,
+            }));
         }
         return core_1.Utils.unique(ret);
     }

package/AbstractSqlPlatform.d.ts

@@ -1,6 +1,8 @@
-import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM } from '@mikro-orm/core';
-import { SqlSchemaGenerator, type SchemaHelper } from './schema';
+import { type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
+import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator';
+import { type SchemaHelper } from './schema/SchemaHelper';
 import type { IndexDef } from './typings';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder';
 export declare abstract class AbstractSqlPlatform extends Platform {
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
@@ -10,12 +12,22 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     /** @inheritDoc */
     lookupExtensions(orm: MikroORM): void;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SqlSchemaGenerator;
+    /** @internal */
+    createNativeQueryBuilder(): NativeQueryBuilder;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    getCommitTransactionSQL(): string;
+    getRollbackTransactionSQL(): string;
+    getSavepointSQL(savepointName: string): string;
+    getRollbackToSavepointSQL(savepointName: string): string;
+    getReleaseSavepointSQL(savepointName: string): string;
     quoteValue(value: any): string;
     escape(value: any): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
     getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
     getJsonIndexDefinition(index: IndexDef): string[];
-    isRaw(value: any): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */
     generateCustomOrder(escapedColumn: string, values: unknown[]): string;

package/AbstractSqlPlatform.js

@@ -4,7 +4,8 @@ exports.AbstractSqlPlatform = void 0;
 const sqlstring_1 = require("sqlstring");
 const core_1 = require("@mikro-orm/core");
 const SqlEntityRepository_1 = require("./SqlEntityRepository");
-const schema_1 = require("./schema");
+const SqlSchemaGenerator_1 = require("./schema/SqlSchemaGenerator");
+const NativeQueryBuilder_1 = require("./query/NativeQueryBuilder");
 class AbstractSqlPlatform extends core_1.Platform {
     schemaHelper;
     usesPivotTable() {
@@ -21,18 +22,41 @@ class AbstractSqlPlatform extends core_1.Platform {
     }
     /** @inheritDoc */
     lookupExtensions(orm) {
-        schema_1.SqlSchemaGenerator.register(orm);
+        SqlSchemaGenerator_1.SqlSchemaGenerator.register(orm);
     }
     /* istanbul ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
-        return new schema_1.SqlSchemaGenerator(em ?? driver);
+        return new SqlSchemaGenerator_1.SqlSchemaGenerator(em ?? driver);
     }
-    quoteValue(value) {
-        if (core_1.Utils.isRawSql(value)) {
-            return this.formatQuery(value.sql, value.params ?? []);
+    /* istanbul ignore next */
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new NativeQueryBuilder_1.NativeQueryBuilder(this);
+    }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel) {
+            return [`set transaction isolation level ${options.isolationLevel}`, 'begin'];
         }
-        if (this.isRaw(value)) {
-            return value;
+        return ['begin'];
+    }
+    getCommitTransactionSQL() {
+        return 'commit';
+    }
+    getRollbackTransactionSQL() {
+        return 'rollback';
+    }
+    getSavepointSQL(savepointName) {
+        return `savepoint ${savepointName}`;
+    }
+    getRollbackToSavepointSQL(savepointName) {
+        return `rollback to savepoint ${savepointName}`;
+    }
+    getReleaseSavepointSQL(savepointName) {
+        return `release savepoint ${savepointName}`;
+    }
+    quoteValue(value) {
+        if ((0, core_1.isRaw)(value)) {
+            return this.formatQuery(value.sql, value.params);
         }
         if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
             return this.escape(JSON.stringify(value));
@@ -63,9 +87,6 @@ class AbstractSqlPlatform extends core_1.Platform {
             return `(json_extract(${root}, '$.${path.join('.')}'))`;
         });
     }
-    isRaw(value) {
-        return super.isRaw(value) || (typeof value === 'object' && value !== null && value.client && ['Ref', 'Raw'].includes(value.constructor.name));
-    }
     supportsSchemas() {
         return false;
     }

package/README.md

@@ -183,7 +183,6 @@ yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-yarn add @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 
@@ -196,7 +195,6 @@ npm i -s @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 npm i -s @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 npm i -s @mikro-orm/core @mikro-orm/mssql         # for mssql
 npm i -s @mikro-orm/core @mikro-orm/sqlite        # for sqlite
-npm i -s @mikro-orm/core @mikro-orm/better-sqlite # for better-sqlite
 npm i -s @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
 

package/SqlEntityManager.d.ts

@@ -1,7 +1,6 @@
-import type { Knex } from 'knex';
-import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions } from '@mikro-orm/core';
+import { EntityManager, type AnyEntity, type ConnectionType, type EntityData, type EntityName, type EntityRepository, type GetRepository, type QueryResult, type FilterQuery, type LoggingOptions, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlDriver } from './AbstractSqlDriver';
-import type { QueryBuilder } from './query';
+import type { NativeQueryBuilder, QueryBuilder } from './query';
 import type { SqlEntityRepository } from './SqlEntityRepository';
 /**
  * @inheritDoc
@@ -16,10 +15,10 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
      */
     qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never>;
     /**
-     * Returns configured knex instance.
+     * Returns configured Kysely instance.
      */
-    getKnex(type?: ConnectionType): Knex<any, any[]>;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
+    getKysely(type?: ConnectionType): import("kysely").Kysely<any>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', loggerContext?: LoggingOptions): Promise<T>;
     getRepository<T extends object, U extends EntityRepository<T> = SqlEntityRepository<T>>(entityName: EntityName<T>): GetRepository<T, U>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: string, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }

package/SqlEntityManager.js

@@ -20,13 +20,13 @@ class SqlEntityManager extends core_1.EntityManager {
         return this.createQueryBuilder(entityName, alias, type, loggerContext);
     }
     /**
-     * Returns configured knex instance.
+     * Returns configured Kysely instance.
      */
-    getKnex(type) {
-        return this.getConnection(type).getKnex();
+    getKysely(type) {
+        return this.getConnection(type).getClient();
     }
-    async execute(queryOrKnex, params = [], method = 'all', loggerContext) {
-        return this.getDriver().execute(queryOrKnex, params, method, this.getContext(false).getTransactionContext(), loggerContext);
+    async execute(query, params = [], method = 'all', loggerContext) {
+        return this.getDriver().execute(query, params, method, this.getContext(false).getTransactionContext(), loggerContext);
     }
     getRepository(entityName) {
         return super.getRepository(entityName);

package/SqlEntityRepository.d.ts

@@ -1,5 +1,4 @@
-import type { Knex } from 'knex';
-import { EntityRepository, type ConnectionType, type EntityName } from '@mikro-orm/core';
+import { EntityRepository, type EntityName } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
 export declare class SqlEntityRepository<Entity extends object> extends EntityRepository<Entity> {
@@ -13,10 +12,6 @@ export declare class SqlEntityRepository<Entity extends object> extends EntityRe
      * Shortcut for `createQueryBuilder()`
      */
     qb<RootAlias extends string = never>(alias?: RootAlias): QueryBuilder<Entity, RootAlias>;
-    /**
-     * Returns configured knex instance.
-     */
-    getKnex(type?: ConnectionType): Knex;
     /**
      * @inheritDoc
      */

package/SqlEntityRepository.js

@@ -20,12 +20,6 @@ class SqlEntityRepository extends core_1.EntityRepository {
     qb(alias) {
         return this.createQueryBuilder(alias);
     }
-    /**
-     * Returns configured knex instance.
-     */
-    getKnex(type) {
-        return this.getEntityManager().getKnex(type);
-    }
     /**
      * @inheritDoc
      */

package/dialects/mssql/MsSqlNativeQueryBuilder.d.ts

@@ -0,0 +1,12 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder';
+/** @internal */
+export declare class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
+    compile(): {
+        sql: string;
+        params: unknown[];
+    };
+    private compileUpsert;
+    protected compileSelect(): void;
+    protected addLockClause(): void;
+    protected compileTruncate(): void;
+}

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsSqlNativeQueryBuilder = void 0;
+const core_1 = require("@mikro-orm/core");
+const NativeQueryBuilder_1 = require("../../query/NativeQueryBuilder");
+const enums_1 = require("../../query/enums");
+/** @internal */
+class MsSqlNativeQueryBuilder extends NativeQueryBuilder_1.NativeQueryBuilder {
+    compile() {
+        if (!this.type) {
+            throw new Error('No query type provided');
+        }
+        this.parts.length = 0;
+        this.params.length = 0;
+        if (this.options.flags?.has(core_1.QueryFlag.IDENTITY_INSERT)) {
+            this.parts.push(`set identity_insert ${this.getTableName()} on;`);
+        }
+        if (this.options.comment) {
+            this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
+        }
+        if (this.options.onConflict && !core_1.Utils.isEmpty(core_1.Utils.asArray(this.options.data)[0])) {
+            this.compileUpsert();
+        }
+        else {
+            switch (this.type) {
+                case enums_1.QueryType.SELECT:
+                case enums_1.QueryType.COUNT:
+                    this.compileSelect();
+                    break;
+                case enums_1.QueryType.INSERT:
+                    this.compileInsert();
+                    break;
+                case enums_1.QueryType.UPDATE:
+                    this.compileUpdate();
+                    break;
+                case enums_1.QueryType.DELETE:
+                    this.compileDelete();
+                    break;
+                case enums_1.QueryType.TRUNCATE:
+                    this.compileTruncate();
+                    break;
+            }
+            if ([enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE].includes(this.type)) {
+                this.parts[this.parts.length - 1] += '; select @@rowcount;';
+            }
+        }
+        if (this.options.flags?.has(core_1.QueryFlag.IDENTITY_INSERT)) {
+            this.parts.push(`set identity_insert ${this.getTableName()} off;`);
+        }
+        return this.combineParts();
+    }
+    compileUpsert() {
+        const clause = this.options.onConflict;
+        const dataAsArray = core_1.Utils.asArray(this.options.data);
+        const keys = Object.keys(dataAsArray[0]);
+        const values = keys.map(() => '?');
+        const parts = [];
+        for (const data of dataAsArray) {
+            for (const key of keys) {
+                this.params.push(data[key]);
+            }
+            parts.push(`(${values.join(', ')})`);
+        }
+        this.parts.push(`merge into ${this.getTableName()}`);
+        this.parts.push(`using (values ${parts.join(', ')}) as tsource(${keys.map(key => this.quote(key)).join(', ')})`);
+        if (clause.fields instanceof core_1.RawQueryFragment) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            // const fields = clause.fields.map(field => this.quote(field));
+            const conflictColumn = this.quote(clause.fields[0]);
+            this.parts.push(`on ${this.getTableName()}.${conflictColumn} = tsource.${conflictColumn}`);
+        }
+        const sourceColumns = keys.map(field => `tsource.${this.quote(field)}`).join(', ');
+        const destinationColumns = keys.map(field => this.quote(field)).join(', ');
+        this.parts.push(`when not matched then insert (${destinationColumns}) values (${sourceColumns})`);
+        if (!clause.ignore) {
+            this.parts.push('when matched');
+            if (clause.where) {
+                this.parts.push(`and ${clause.where.sql}`);
+                this.params.push(...clause.where.params);
+            }
+            this.parts.push('then update set');
+            if (!clause.merge || Array.isArray(clause.merge)) {
+                const parts = keys.map((column) => `${this.quote(column)} = tsource.${this.quote(column)}`);
+                this.parts.push(parts.join(', '));
+            }
+            else if (typeof clause.merge === 'object') {
+                const parts = Object.entries(clause.merge).map(([key, value]) => {
+                    this.params.push(value);
+                    return `${this.getTableName()}.${this.quote(key)} = ?`;
+                });
+                this.parts.push(parts.join(', '));
+            }
+        }
+        this.addOutputClause('inserted');
+        this.parts[this.parts.length - 1] += ';';
+    }
+    compileSelect() {
+        this.parts.push('select');
+        if (this.options.limit != null && this.options.offset == null) {
+            this.parts.push(`top (?)`);
+            this.params.push(this.options.limit);
+        }
+        this.addHintComment();
+        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.addLockClause();
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+        if (this.options.groupBy) {
+            const fields = this.options.groupBy.map(field => this.quote(field));
+            this.parts.push(`group by ${fields.join(', ')}`);
+        }
+        if (this.options.having) {
+            this.parts.push(`having ${this.options.having.sql}`);
+            this.params.push(...this.options.having.params);
+        }
+        if (this.options.orderBy) {
+            this.parts.push(`order by ${this.options.orderBy}`);
+        }
+        if (this.options.offset != null) {
+            /* istanbul ignore next */
+            if (!this.options.orderBy) {
+                throw new Error('Order by clause is required for pagination');
+            }
+            this.parts.push(`offset ? rows`);
+            this.params.push(this.options.offset);
+            if (this.options.limit != null) {
+                this.parts.push(`fetch next ? rows only`);
+                this.params.push(this.options.limit);
+            }
+        }
+    }
+    addLockClause() {
+        if (!this.options.lockMode || ![core_1.LockMode.PESSIMISTIC_READ, core_1.LockMode.PESSIMISTIC_WRITE].includes(this.options.lockMode)) {
+            return;
+        }
+        const map = {
+            [core_1.LockMode.PESSIMISTIC_READ]: 'with (holdlock)',
+            [core_1.LockMode.PESSIMISTIC_WRITE]: 'with (updlock)',
+        };
+        if (this.options.lockMode !== core_1.LockMode.OPTIMISTIC) {
+            this.parts.push(map[this.options.lockMode]);
+        }
+    }
+    compileTruncate() {
+        const tableName = this.getTableName();
+        const sql = `delete from ${tableName}; declare @count int = case @@rowcount when 0 then 1 else 0 end; dbcc checkident ('${tableName.replace(/[[\]]/g, '')}', reseed, @count)`;
+        this.parts.push(sql);
+    }
+}
+exports.MsSqlNativeQueryBuilder = MsSqlNativeQueryBuilder;

package/dialects/mssql/index.d.ts

@@ -1 +1 @@
-export * from './MsSqlKnexDialect';
+export * from './MsSqlNativeQueryBuilder';

package/dialects/mssql/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./MsSqlKnexDialect"), exports);
+__exportStar(require("./MsSqlNativeQueryBuilder"), exports);