@mikro-orm/sql 7.0.10 → 7.0.11-dev.0

package/dialects/mssql/MsSqlNativeQueryBuilder.d.ts

@@ -1,16 +1,16 @@
 import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export declare class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
-  compile(): {
-    sql: string;
-    params: unknown[];
-  };
-  protected compileInsert(): void;
-  private appendOutputTable;
-  private compileUpsert;
-  protected compileSelect(): void;
-  protected addLockClause(): void;
-  protected compileTruncate(): void;
-  /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
-  protected getCteKeyword(_hasRecursive: boolean): string;
+    compile(): {
+        sql: string;
+        params: unknown[];
+    };
+    protected compileInsert(): void;
+    private appendOutputTable;
+    private compileUpsert;
+    protected compileSelect(): void;
+    protected addLockClause(): void;
+    protected compileTruncate(): void;
+    /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
+    protected getCteKeyword(_hasRecursive: boolean): string;
 }

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -3,211 +3,213 @@ import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 import { QueryType } from '../../query/enums.js';
 /** @internal */
 export class MsSqlNativeQueryBuilder extends 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(QueryFlag.IDENTITY_INSERT)) {
-      this.parts.push(`set identity_insert ${this.getTableName()} on;`);
-    }
-    const { prefix, suffix } = this.appendOutputTable();
-    if (prefix) {
-      this.parts.push(prefix);
-    }
-    if (this.options.comment) {
-      this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
-    }
-    this.compileCtes();
-    if (this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0])) {
-      this.compileUpsert();
-    } else {
-      switch (this.type) {
-        case QueryType.SELECT:
-        case QueryType.COUNT:
-          this.compileSelect();
-          break;
-        case QueryType.INSERT:
-          this.compileInsert();
-          break;
-        case QueryType.UPDATE:
-          this.compileUpdate();
-          break;
-        case QueryType.DELETE:
-          this.compileDelete();
-          break;
-        case QueryType.TRUNCATE:
-          this.compileTruncate();
-          break;
-      }
-      if (suffix) {
-        this.parts[this.parts.length - 1] += ';';
-        this.parts.push(suffix);
-      } else if ([QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE].includes(this.type)) {
-        this.parts[this.parts.length - 1] += '; select @@rowcount;';
-      }
-    }
-    if (this.options.flags?.has(QueryFlag.IDENTITY_INSERT)) {
-      this.parts.push(`set identity_insert ${this.getTableName()} off;`);
-    }
-    return this.combineParts();
-  }
-  compileInsert() {
-    if (!this.options.data) {
-      throw new Error('No data provided');
-    }
-    this.parts.push('insert');
-    this.addHintComment();
-    this.parts.push(`into ${this.getTableName()}`);
-    if (Object.keys(this.options.data).length === 0) {
-      this.addOutputClause('inserted');
-      this.parts.push('default values');
-      return;
-    }
-    const parts = this.processInsertData();
-    if (this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
-      this.parts[this.parts.length - 2] += ' into #out ';
-    }
-    this.parts.push(parts.join(', '));
-  }
-  appendOutputTable() {
-    if (!this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
-      return { prefix: '', suffix: '' };
-    }
-    const returningFields = this.options.returning;
-    const selections = returningFields.map(field => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
-    return {
-      prefix: `select top(0) ${selections} into #out from ${this.getTableName()} as t left join ${this.getTableName()} on 0 = 1;`,
-      suffix: `select ${selections} from #out as t; drop table #out`,
-    };
-  }
-  compileUpsert() {
-    const clause = this.options.onConflict;
-    const dataAsArray = 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 (isRaw(clause.fields)) {
-      this.parts.push(clause.fields.sql);
-      this.params.push(...clause.fields.params);
-    } else if (clause.fields.length > 0) {
-      const fields = clause.fields.map(field => {
-        const col = this.quote(field);
-        return `${this.getTableName()}.${col} = tsource.${col}`;
-      });
-      this.parts.push(`on ${fields.join(' and ')}`);
+    compile() {
+        if (!this.type) {
+            throw new Error('No query type provided');
+        }
+        this.parts.length = 0;
+        this.params.length = 0;
+        if (this.options.flags?.has(QueryFlag.IDENTITY_INSERT)) {
+            this.parts.push(`set identity_insert ${this.getTableName()} on;`);
+        }
+        const { prefix, suffix } = this.appendOutputTable();
+        if (prefix) {
+            this.parts.push(prefix);
+        }
+        if (this.options.comment) {
+            this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
+        }
+        this.compileCtes();
+        if (this.options.onConflict && !Utils.isEmpty(Utils.asArray(this.options.data)[0])) {
+            this.compileUpsert();
+        }
+        else {
+            switch (this.type) {
+                case QueryType.SELECT:
+                case QueryType.COUNT:
+                    this.compileSelect();
+                    break;
+                case QueryType.INSERT:
+                    this.compileInsert();
+                    break;
+                case QueryType.UPDATE:
+                    this.compileUpdate();
+                    break;
+                case QueryType.DELETE:
+                    this.compileDelete();
+                    break;
+                case QueryType.TRUNCATE:
+                    this.compileTruncate();
+                    break;
+            }
+            if (suffix) {
+                this.parts[this.parts.length - 1] += ';';
+                this.parts.push(suffix);
+            }
+            else if ([QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE].includes(this.type)) {
+                this.parts[this.parts.length - 1] += '; select @@rowcount;';
+            }
+        }
+        if (this.options.flags?.has(QueryFlag.IDENTITY_INSERT)) {
+            this.parts.push(`set identity_insert ${this.getTableName()} off;`);
+        }
+        return this.combineParts();
     }
-    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 = (clause.merge || keys)
-          .filter(field => !Array.isArray(clause.fields) || !clause.fields.includes(field))
-          .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)} = ?`;
-        });
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.addOutputClause('inserted');
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        if (this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+            this.parts[this.parts.length - 2] += ' into #out ';
+        }
         this.parts.push(parts.join(', '));
-      }
-    }
-    this.addOutputClause('inserted');
-    this.parts[this.parts.length - 1] += ';';
-  }
-  compileSelect() {
-    const wrapCountSubquery = this.needsCountSubquery();
-    if (wrapCountSubquery) {
-      this.parts.push(`select count(*) as ${this.quote('count')} from (`);
-    }
-    this.parts.push('select');
-    // skip top(?) inside the count subquery — it would limit the distinct rows before counting
-    if (this.options.limit != null && this.options.offset == null && !wrapCountSubquery) {
-      this.parts.push(`top (?)`);
-      this.params.push(this.options.limit);
-    }
-    this.addHintComment();
-    this.parts.push(`${this.getFields(wrapCountSubquery)} 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);
+    appendOutputTable() {
+        if (!this.options.flags?.has(QueryFlag.OUTPUT_TABLE)) {
+            return { prefix: '', suffix: '' };
+        }
+        const returningFields = this.options.returning;
+        const selections = returningFields.map(field => `[t].${this.platform.quoteIdentifier(field)}`).join(',');
+        return {
+            prefix: `select top(0) ${selections} into #out from ${this.getTableName()} as t left join ${this.getTableName()} on 0 = 1;`,
+            suffix: `select ${selections} from #out as t; drop table #out`,
+        };
+    }
+    compileUpsert() {
+        const clause = this.options.onConflict;
+        const dataAsArray = 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 (isRaw(clause.fields)) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            const fields = clause.fields.map(field => {
+                const col = this.quote(field);
+                return `${this.getTableName()}.${col} = tsource.${col}`;
+            });
+            this.parts.push(`on ${fields.join(' and ')}`);
+        }
+        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 = (clause.merge || keys)
+                    .filter(field => !Array.isArray(clause.fields) || !clause.fields.includes(field))
+                    .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] += ';';
     }
-    if (!wrapCountSubquery) {
-      if (this.options.orderBy) {
-        this.parts.push(`order by ${this.options.orderBy}`);
-      }
-      if (this.options.offset != null) {
-        /* v8 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);
-        }
-      }
+    compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
+        this.parts.push('select');
+        // skip top(?) inside the count subquery — it would limit the distinct rows before counting
+        if (this.options.limit != null && this.options.offset == null && !wrapCountSubquery) {
+            this.parts.push(`top (?)`);
+            this.params.push(this.options.limit);
+        }
+        this.addHintComment();
+        this.parts.push(`${this.getFields(wrapCountSubquery)} 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 (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
+            }
+            if (this.options.offset != null) {
+                /* v8 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);
+                }
+            }
+        }
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
+        }
     }
-    if (wrapCountSubquery) {
-      const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
-      this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
+    addLockClause() {
+        if (!this.options.lockMode ||
+            ![LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_WRITE].includes(this.options.lockMode)) {
+            return;
+        }
+        const map = {
+            [LockMode.PESSIMISTIC_READ]: 'with (holdlock)',
+            [LockMode.PESSIMISTIC_WRITE]: 'with (updlock)',
+        };
+        if (this.options.lockMode !== LockMode.OPTIMISTIC) {
+            this.parts.push(map[this.options.lockMode]);
+        }
     }
-  }
-  addLockClause() {
-    if (
-      !this.options.lockMode ||
-      ![LockMode.PESSIMISTIC_READ, LockMode.PESSIMISTIC_WRITE].includes(this.options.lockMode)
-    ) {
-      return;
+    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);
     }
-    const map = {
-      [LockMode.PESSIMISTIC_READ]: 'with (holdlock)',
-      [LockMode.PESSIMISTIC_WRITE]: 'with (updlock)',
-    };
-    if (this.options.lockMode !== LockMode.OPTIMISTIC) {
-      this.parts.push(map[this.options.lockMode]);
+    /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
+    getCteKeyword(_hasRecursive) {
+        return 'with';
     }
-  }
-  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);
-  }
-  /** MSSQL has no RECURSIVE keyword — CTEs are implicitly recursive. */
-  getCteKeyword(_hasRecursive) {
-    return 'with';
-  }
 }

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -1,72 +1,53 @@
-import {
-  type SimpleColumnMeta,
-  type Type,
-  type TransformContext,
-  type MikroORM,
-  type IsolationLevel,
-} from '@mikro-orm/core';
+import { type SimpleColumnMeta, type Type, type TransformContext, type MikroORM, type IsolationLevel } from '@mikro-orm/core';
 import { MySqlSchemaHelper } from './MySqlSchemaHelper.js';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter.js';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
 import type { IndexDef } from '../../typings.js';
 import { MySqlNativeQueryBuilder } from './MySqlNativeQueryBuilder.js';
 export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
-  #private;
-  protected readonly schemaHelper: MySqlSchemaHelper;
-  protected readonly exceptionConverter: MySqlExceptionConverter;
-  protected readonly ORDER_BY_NULLS_TRANSLATE: {
-    readonly 'asc nulls first': 'is not null';
-    readonly 'asc nulls last': 'is null';
-    readonly 'desc nulls first': 'is not null';
-    readonly 'desc nulls last': 'is null';
-  };
-  supportsMultiColumnCountDistinct(): boolean;
-  /** @internal */
-  createNativeQueryBuilder(): MySqlNativeQueryBuilder;
-  getDefaultCharset(): string;
-  init(orm: MikroORM): void;
-  getBeginTransactionSQL(options?: { isolationLevel?: IsolationLevel; readOnly?: boolean }): string[];
-  convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-  getJsonIndexDefinition(index: IndexDef): string[];
-  getBooleanTypeDeclarationSQL(): string;
-  normalizeColumnType(
-    type: string,
-    options: {
-      length?: number;
-      precision?: number;
-      scale?: number;
-    },
-  ): string;
-  getDefaultMappedType(type: string): Type<unknown>;
-  isNumericColumn(mappedType: Type<unknown>): boolean;
-  supportsUnsigned(): boolean;
-  /**
-   * Returns the default name of index for the given columns
-   * cannot go past 64 character length for identifiers in MySQL
-   */
-  getIndexName(
-    tableName: string,
-    columns: string[],
-    type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence',
-  ): string;
-  getDefaultPrimaryName(tableName: string, columns: string[]): string;
-  supportsCreatingFullTextIndex(): boolean;
-  getFullTextWhereClause(): string;
-  getFullTextIndexExpression(
-    indexName: string,
-    schemaName: string | undefined,
-    tableName: string,
-    columns: SimpleColumnMeta[],
-  ): string;
-  getOrderByExpression(column: string, direction: string, collation?: string): string[];
-  getJsonArrayFromSQL(
-    column: string,
-    alias: string,
-    properties: {
-      name: string;
-      type: string;
-    }[],
-  ): string;
-  getJsonArrayExistsSQL(from: string, where: string): string;
-  getDefaultClientUrl(): string;
+    #private;
+    protected readonly schemaHelper: MySqlSchemaHelper;
+    protected readonly exceptionConverter: MySqlExceptionConverter;
+    protected readonly ORDER_BY_NULLS_TRANSLATE: {
+        readonly "asc nulls first": "is not null";
+        readonly "asc nulls last": "is null";
+        readonly "desc nulls first": "is not null";
+        readonly "desc nulls last": "is null";
+    };
+    supportsMultiColumnCountDistinct(): boolean;
+    /** @internal */
+    createNativeQueryBuilder(): MySqlNativeQueryBuilder;
+    getDefaultCharset(): string;
+    init(orm: MikroORM): void;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    getBooleanTypeDeclarationSQL(): string;
+    normalizeColumnType(type: string, options: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
+    getDefaultMappedType(type: string): Type<unknown>;
+    isNumericColumn(mappedType: Type<unknown>): boolean;
+    supportsUnsigned(): boolean;
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextWhereClause(): string;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    getOrderByExpression(column: string, direction: string, collation?: string): string[];
+    getJsonArrayFromSQL(column: string, alias: string, properties: {
+        name: string;
+        type: string;
+    }[]): string;
+    getJsonArrayExistsSQL(from: string, where: string): string;
+    getDefaultClientUrl(): string;
 }