@mikro-orm/sql 7.0.0-dev.98 → 7.0.0-rc.0

package/AbstractSqlPlatform.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
+import { type RawQueryFragment, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
 import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
 import { type SchemaHelper } from './schema/SchemaHelper.js';
 import type { IndexDef } from './typings.js';
@@ -24,9 +24,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     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;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | RawQueryFragment;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | RawQueryFragment;
     getJsonIndexDefinition(index: IndexDef): string[];
     supportsSchemas(): boolean;
     /** @inheritDoc */

package/AbstractSqlPlatform.js

@@ -1,4 +1,3 @@
-import SqlString from 'sqlstring';
 import { isRaw, JsonProperty, Platform, raw, Utils, } from '@mikro-orm/core';
 import { SqlEntityRepository } from './SqlEntityRepository.js';
 import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
@@ -60,9 +59,6 @@ export class AbstractSqlPlatform extends Platform {
         }
         return this.escape(value);
     }
-    escape(value) {
-        return SqlString.escape(value, true, this.timezone);
-    }
     getSearchJsonPropertySQL(path, type, aliased) {
         return this.getSearchJsonPropertyKey(path.split('->'), type, aliased);
     }

package/PivotCollectionPersister.d.ts

@@ -17,6 +17,11 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private enqueueUpsert;
     private createInsertStatement;
     private enqueueDelete;
+    /**
+     * Build the keys and data arrays for pivot table operations.
+     * Handles polymorphic M:N by prepending the discriminator column/value.
+     */
+    private buildPivotKeysAndData;
     private collectStatements;
     execute(): Promise<void>;
 }

package/PivotCollectionPersister.js

@@ -83,27 +83,45 @@ export class PivotCollectionPersister {
         }
     }
     createInsertStatement(prop, fks, pks) {
-        const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
-        const keys = prop.owner
-            ? [...prop.inverseJoinColumns, ...prop.joinColumns]
-            : [...prop.joinColumns, ...prop.inverseJoinColumns];
+        const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
         return new InsertStatement(keys, data, this.order++);
     }
     enqueueDelete(prop, deleteDiff, pks) {
         if (deleteDiff === true) {
-            const statement = new DeleteStatement(prop.joinColumns, pks);
+            const { data, keys } = this.buildPivotKeysAndData(prop, [], pks, true);
+            const statement = new DeleteStatement(keys, data);
             this.deletes.set(statement.getHash(), statement);
             return;
         }
         for (const fks of deleteDiff) {
-            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
-            const keys = prop.owner
-                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
-                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
             const statement = new DeleteStatement(keys, data);
             this.deletes.set(statement.getHash(), statement);
         }
     }
+    /**
+     * Build the keys and data arrays for pivot table operations.
+     * Handles polymorphic M:N by prepending the discriminator column/value.
+     */
+    buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
+        let data;
+        let keys;
+        if (deleteAll) {
+            data = pks;
+            keys = prop.joinColumns;
+        }
+        else {
+            data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+        }
+        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+            data = [prop.discriminatorValue, ...data];
+            keys = [prop.discriminatorColumn, ...keys];
+        }
+        return { data, keys };
+    }
     collectStatements(statements) {
         const items = [];
         for (const statement of statements.values()) {
@@ -120,7 +138,7 @@ export class PivotCollectionPersister {
                 for (const item of chunk) {
                     cond.$or.push(item.getCondition());
                 }
-                await this.driver.nativeDelete(this.meta.className, cond, {
+                await this.driver.nativeDelete(this.meta.class, cond, {
                     ctx: this.ctx,
                     schema: this.schema,
                     loggerContext: this.loggerContext,
@@ -131,7 +149,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.inserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                await this.driver.nativeInsertMany(this.meta.class, chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,
@@ -144,7 +162,7 @@ export class PivotCollectionPersister {
             const filtered = this.collectStatements(this.upserts);
             for (let i = 0; i < filtered.length; i += this.batchSize) {
                 const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeUpdateMany(this.meta.className, [], chunk, {
+                await this.driver.nativeUpdateMany(this.meta.class, [], chunk, {
                     ctx: this.ctx,
                     schema: this.schema,
                     convertCustomTypes: false,

package/SqlEntityManager.d.ts

@@ -20,14 +20,14 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never>;
+    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never, never, "*">;
     /**
      * Returns configured Kysely instance.
      */
     getKysely<TDB = undefined, TOptions extends GetKyselyOptions = GetKyselyOptions>(options?: TOptions): Kysely<TDB extends undefined ? InferKyselyDB<EntitiesFromManager<this>, TOptions> : TDB>;
     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>;
+    protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
 }
 type EntitiesFromManager<TEntityManager extends EntityManager<any>> = NonNullable<TEntityManager['~entities']> extends any[] ? (Extract<NonNullable<TEntityManager['~entities']>[number], EntitySchemaWithMeta>) : never;
 export {};

package/dialects/mysql/{MySqlPlatform.d.ts → BaseMySqlPlatform.d.ts}

@@ -1,10 +1,10 @@
-import { type SimpleColumnMeta, type Type, type TransformContext, 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 MySqlPlatform extends AbstractSqlPlatform {
+export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: MySqlSchemaHelper;
     protected readonly exceptionConverter: MySqlExceptionConverter;
     protected readonly ORDER_BY_NULLS_TRANSLATE: {
@@ -16,6 +16,7 @@ export declare class MySqlPlatform extends AbstractSqlPlatform {
     /** @internal */
     createNativeQueryBuilder(): MySqlNativeQueryBuilder;
     getDefaultCharset(): string;
+    init(orm: MikroORM): void;
     getBeginTransactionSQL(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;

package/dialects/mysql/{MySqlPlatform.js → BaseMySqlPlatform.js}

@@ -3,7 +3,7 @@ import { MySqlSchemaHelper } from './MySqlSchemaHelper.js';
 import { MySqlExceptionConverter } from './MySqlExceptionConverter.js';
 import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
 import { MySqlNativeQueryBuilder } from './MySqlNativeQueryBuilder.js';
-export class MySqlPlatform extends AbstractSqlPlatform {
+export class BaseMySqlPlatform extends AbstractSqlPlatform {
     schemaHelper = new MySqlSchemaHelper(this);
     exceptionConverter = new MySqlExceptionConverter();
     ORDER_BY_NULLS_TRANSLATE = {
@@ -19,6 +19,10 @@ export class MySqlPlatform extends AbstractSqlPlatform {
     getDefaultCharset() {
         return 'utf8mb4';
     }
+    init(orm) {
+        super.init(orm);
+        orm.config.get('schemaGenerator').disableForeignKeysForClear ??= true;
+    }
     getBeginTransactionSQL(options) {
         if (options?.isolationLevel || options?.readOnly) {
             const parts = [];

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -16,9 +16,20 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    /**
+     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
+     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     */
+    protected getIndexColumns(index: IndexDef): string;
+    /**
+     * Append MySQL-specific index suffixes like INVISIBLE.
+     */
+    protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -33,6 +33,28 @@ export class MySqlSchemaHelper extends SchemaHelper {
     getListTablesSQL() {
         return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
+    getListViewsSQL() {
+        return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
+    }
+    async loadViews(schema, connection, schemaName) {
+        const views = await connection.execute(this.getListViewsSQL());
+        for (const view of views) {
+            // MySQL information_schema.views.view_definition requires SHOW VIEW privilege
+            // and may return NULL. Use SHOW CREATE VIEW as fallback.
+            let definition = view.view_definition?.trim();
+            if (!definition) {
+                const createView = await connection.execute(`show create view \`${view.view_name}\``);
+                if (createView[0]?.['Create View']) {
+                    // Extract SELECT statement from CREATE VIEW ... AS SELECT ...
+                    const match = createView[0]['Create View'].match(/\bAS\s+(.+)$/is);
+                    definition = match?.[1]?.trim();
+                }
+            }
+            if (definition) {
+                schema.addView(view.view_name, view.schema_name ?? undefined, definition);
+            }
+        }
+    }
     async loadInformationSchema(schema, connection, tables) {
         if (tables.length === 0) {
             return;
@@ -50,7 +72,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
     }
     async getAllIndexes(connection, tables) {
-        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name /*!80013 , expression as expression */
+        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, index_type as index_type, sub_part as sub_part, collation as sort_order /*!80013 , expression as expression, is_visible as is_visible */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
@@ -65,6 +87,26 @@ export class MySqlSchemaHelper extends SchemaHelper {
                 primary: index.index_name === 'PRIMARY',
                 constraint: !index.non_unique,
             };
+            // Capture column options (prefix length, sort order)
+            if (index.sub_part != null || index.sort_order === 'D') {
+                indexDef.columns = [{
+                        name: index.column_name,
+                        ...(index.sub_part != null && { length: index.sub_part }),
+                        ...(index.sort_order === 'D' && { sort: 'DESC' }),
+                    }];
+            }
+            // Capture index type for fulltext and spatial indexes
+            if (index.index_type === 'FULLTEXT') {
+                indexDef.type = 'fulltext';
+            }
+            else if (index.index_type === 'SPATIAL') {
+                /* v8 ignore next */
+                indexDef.type = 'spatial';
+            }
+            // Capture invisible flag (MySQL 8.0.13+)
+            if (index.is_visible === 'NO') {
+                indexDef.invisible = true;
+            }
             if (!index.column_name || index.expression?.match(/ where /i)) {
                 indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
@@ -84,17 +126,66 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
-        const sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
+        let sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
         if (index.expression && partialExpression) {
-            return `${sql}(${index.expression})`;
+            sql += `(${index.expression})`;
+            return this.appendMySqlIndexSuffix(sql, index);
         }
         // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
         if (index.columnNames.some(column => column.includes('.'))) {
             const columns = this.platform.getJsonIndexDefinition(index);
-            const sql = `alter table ${tableName} add ${index.unique ? 'unique ' : ''}index ${keyName} `;
-            return `${sql}(${columns.join(', ')})`;
+            sql = `alter table ${tableName} add ${index.unique ? 'unique ' : ''}index ${keyName} `;
+            sql += `(${columns.join(', ')})`;
+            return this.appendMySqlIndexSuffix(sql, index);
+        }
+        // Build column list with advanced options
+        const columns = this.getIndexColumns(index);
+        sql += `(${columns})`;
+        return this.appendMySqlIndexSuffix(sql, index);
+    }
+    /**
+     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
+     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     */
+    getIndexColumns(index) {
+        if (index.columns?.length) {
+            return index.columns.map(col => {
+                const quotedName = this.quote(col.name);
+                // MySQL supports collation via expression: (column_name COLLATE collation_name)
+                // When collation is specified, wrap in parentheses as an expression
+                if (col.collation) {
+                    let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
+                    expr = `(${expr} collate ${col.collation})`;
+                    // Sort order comes after the expression
+                    if (col.sort) {
+                        expr += ` ${col.sort}`;
+                    }
+                    return expr;
+                }
+                // Standard column definition without collation
+                let colDef = quotedName;
+                // MySQL supports prefix length
+                if (col.length) {
+                    colDef += `(${col.length})`;
+                }
+                // MySQL supports sort order
+                if (col.sort) {
+                    colDef += ` ${col.sort}`;
+                }
+                return colDef;
+            }).join(', ');
         }
-        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+        return index.columnNames.map(c => this.quote(c)).join(', ');
+    }
+    /**
+     * Append MySQL-specific index suffixes like INVISIBLE.
+     */
+    appendMySqlIndexSuffix(sql, index) {
+        // MySQL 8.0+ supports INVISIBLE indexes
+        if (index.invisible) {
+            sql += ' invisible';
+        }
+        return sql;
     }
     async getAllColumns(connection, tables) {
         const sql = `select table_name as table_name,

package/dialects/mysql/index.d.ts

@@ -1,4 +1,3 @@
-export * from './MySqlExceptionConverter.js';
 export * from './MySqlSchemaHelper.js';
-export * from './MySqlPlatform.js';
+export * from './BaseMySqlPlatform.js';
 export * from './MySqlNativeQueryBuilder.js';

package/dialects/mysql/index.js

@@ -1,4 +1,3 @@
-export * from './MySqlExceptionConverter.js';
 export * from './MySqlSchemaHelper.js';
-export * from './MySqlPlatform.js';
+export * from './BaseMySqlPlatform.js';
 export * from './MySqlNativeQueryBuilder.js';

package/dialects/postgresql/BasePostgreSqlPlatform.d.ts

@@ -0,0 +1,106 @@
+import { type EntityProperty, type IsolationLevel, RawQueryFragment, type SimpleColumnMeta, Type } from '@mikro-orm/core';
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
+import type { IndexDef } from '../../typings.js';
+import { PostgreSqlNativeQueryBuilder } from './PostgreSqlNativeQueryBuilder.js';
+import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
+import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
+export declare class BasePostgreSqlPlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: PostgreSqlSchemaHelper;
+    protected readonly exceptionConverter: PostgreSqlExceptionConverter;
+    createNativeQueryBuilder(): PostgreSqlNativeQueryBuilder;
+    usesReturningStatement(): boolean;
+    usesCascadeStatement(): boolean;
+    supportsNativeEnums(): boolean;
+    usesEnumCheckConstraints(): boolean;
+    supportsMaterializedViews(): boolean;
+    supportsCustomPrimaryKeyNames(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getDefaultDateTimeLength(): number;
+    getTimeTypeDeclarationSQL(): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        autoincrement?: boolean;
+        generated?: string;
+    }): string;
+    getBigIntTypeDeclarationSQL(column: {
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getUuidTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getFullTextWhereClause(prop: EntityProperty): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    normalizeColumnType(type: string, options: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+        autoincrement?: boolean;
+    }): string;
+    getMappedType(type: string): Type<unknown>;
+    getRegExpOperator(val?: unknown, flags?: string): string;
+    getRegExpValue(val: RegExp): {
+        $re: string;
+        $flags?: string;
+    };
+    isBigIntProperty(prop: EntityProperty): boolean;
+    getArrayDeclarationSQL(): string;
+    getFloatDeclarationSQL(): string;
+    getDoubleDeclarationSQL(): string;
+    getEnumTypeDeclarationSQL(column: {
+        fieldNames: string[];
+        items?: unknown[];
+        nativeEnumName?: string;
+    }): string;
+    supportsMultipleStatements(): boolean;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    marshallArray(values: string[]): string;
+    unmarshallArray(value: string): string[];
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getIntervalTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getBlobDeclarationSQL(): string;
+    getJsonDeclarationSQL(): string;
+    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string | RawQueryFragment;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    quoteIdentifier(id: string | {
+        toString: () => string;
+    }, quote?: string): string;
+    private pad;
+    /** @internal */
+    formatDate(date: Date): string;
+    indexForeignKeys(): boolean;
+    getDefaultMappedType(type: string): Type<unknown>;
+    supportsSchemas(): boolean;
+    getDefaultSchemaName(): string | undefined;
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 63 character length for identifiers in MySQL
+     */
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    /**
+     * @inheritDoc
+     */
+    castColumn(prop?: {
+        columnTypes?: string[];
+    }): string;
+    getDefaultClientUrl(): string;
+}