@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.98

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -0,0 +1,200 @@
+import { LockMode, QueryFlag, RawQueryFragment, Utils } from '@mikro-orm/core';
+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} */`));
+        }
+        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 (clause.fields instanceof 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 => {
+                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] += ';';
+    }
+    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) {
+            /* 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);
+            }
+        }
+    }
+    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]);
+        }
+    }
+    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);
+    }
+}

package/dialects/mssql/index.d.ts

@@ -0,0 +1 @@
+export * from './MsSqlNativeQueryBuilder.js';

package/dialects/mssql/index.js

@@ -0,0 +1 @@
+export * from './MsSqlNativeQueryBuilder.js';

package/dialects/mysql/MySqlExceptionConverter.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
+export declare class MySqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @see http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @see http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/dialects/mysql/MySqlExceptionConverter.js

@@ -0,0 +1,80 @@
+import { DeadlockException, LockWaitTimeoutException, TableExistsException, TableNotFoundException, ForeignKeyConstraintViolationException, UniqueConstraintViolationException, InvalidFieldNameException, NonUniqueFieldNameException, SyntaxErrorException, ConnectionException, NotNullConstraintViolationException, ExceptionConverter, CheckConstraintViolationException, } from '@mikro-orm/core';
+export class MySqlExceptionConverter extends ExceptionConverter {
+    /**
+     * @see http://dev.mysql.com/doc/refman/5.7/en/error-messages-client.html
+     * @see http://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractMySQLDriver.php
+     */
+    convertException(exception) {
+        /* v8 ignore next */
+        switch (exception.errno) {
+            case 1213:
+                return new DeadlockException(exception);
+            case 1205:
+                return new LockWaitTimeoutException(exception);
+            case 1050:
+                return new TableExistsException(exception);
+            case 1051:
+            case 1146:
+                return new TableNotFoundException(exception);
+            case 1216:
+            case 1217:
+            case 1451:
+            case 1452:
+            case 1701:
+                return new ForeignKeyConstraintViolationException(exception);
+            case 3819:
+            case 4025:
+                return new CheckConstraintViolationException(exception);
+            case 1062:
+            case 1557:
+            case 1569:
+            case 1586:
+                return new UniqueConstraintViolationException(exception);
+            case 1054:
+            case 1166:
+            case 1611:
+                return new InvalidFieldNameException(exception);
+            case 1052:
+            case 1060:
+            case 1110:
+                return new NonUniqueFieldNameException(exception);
+            case 1064:
+            case 1149:
+            case 1287:
+            case 1341:
+            case 1342:
+            case 1343:
+            case 1344:
+            case 1382:
+            case 1479:
+            case 1541:
+            case 1554:
+            case 1626:
+                return new SyntaxErrorException(exception);
+            case 1044:
+            case 1045:
+            case 1046:
+            case 1049:
+            case 1095:
+            case 1142:
+            case 1143:
+            case 1227:
+            case 1370:
+            case 1429:
+            case 2002:
+            case 2005:
+                return new ConnectionException(exception);
+            case 1048:
+            case 1121:
+            case 1138:
+            case 1171:
+            case 1252:
+            case 1263:
+            case 1364:
+            case 1566:
+                return new NotNullConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}

package/dialects/mysql/MySqlNativeQueryBuilder.d.ts

@@ -0,0 +1,7 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export declare class MySqlNativeQueryBuilder extends NativeQueryBuilder {
+    protected compileInsert(): void;
+    protected addLockClause(): void;
+    protected addOnConflictClause(): void;
+}

package/dialects/mysql/MySqlNativeQueryBuilder.js

@@ -0,0 +1,77 @@
+import { LockMode, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export class MySqlNativeQueryBuilder extends NativeQueryBuilder {
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        if (this.options.onConflict?.ignore) {
+            this.parts.push('ignore');
+        }
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        this.parts.push(parts.join(', '));
+    }
+    addLockClause() {
+        if (!this.options.lockMode) {
+            return;
+        }
+        const map = {
+            [LockMode.PESSIMISTIC_READ]: 'lock in share mode',
+            [LockMode.PESSIMISTIC_WRITE]: 'for update',
+            [LockMode.PESSIMISTIC_PARTIAL_WRITE]: 'for update skip locked',
+            [LockMode.PESSIMISTIC_WRITE_OR_FAIL]: 'for update nowait',
+            [LockMode.PESSIMISTIC_PARTIAL_READ]: 'lock in share mode skip locked',
+            [LockMode.PESSIMISTIC_READ_OR_FAIL]: 'lock in share mode nowait',
+        };
+        if (this.options.lockMode !== LockMode.OPTIMISTIC) {
+            this.parts.push(map[this.options.lockMode]);
+        }
+    }
+    addOnConflictClause() {
+        const clause = this.options.onConflict;
+        if (!clause || clause.ignore) {
+            return;
+        }
+        if (clause.merge) {
+            this.parts.push('on duplicate key update');
+            if (Utils.isObject(clause.merge)) {
+                const fields = Object.keys(clause.merge).map(field => {
+                    this.params.push(clause.merge[field]);
+                    return `${this.quote(field)} = ?`;
+                });
+                this.parts.push(fields.join(', '));
+            }
+            else if (clause.merge.length === 0) {
+                const dataAsArray = Utils.asArray(this.options.data);
+                const keys = Object.keys(dataAsArray[0]);
+                this.parts.push(keys.map(key => `${this.quote(key)} = values(${this.quote(key)})`).join(', '));
+            }
+            else {
+                const fields = clause.merge.map(key => `${this.quote(key)} = values(${this.quote(key)})`);
+                this.parts.push(fields.join(', '));
+            }
+            if (clause.where) {
+                this.parts.push(`where ${clause.where.sql}`);
+                this.params.push(...clause.where.params);
+            }
+            return;
+        }
+        this.parts.push('on conflict');
+        if (clause.fields instanceof 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));
+            this.parts.push(`(${fields.join(', ')})`);
+        }
+    }
+}

package/dialects/mysql/MySqlPlatform.d.ts

@@ -0,0 +1,45 @@
+import { type SimpleColumnMeta, type Type, type TransformContext, 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 {
+    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";
+    };
+    /** @internal */
+    createNativeQueryBuilder(): MySqlNativeQueryBuilder;
+    getDefaultCharset(): string;
+    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): string[];
+    getDefaultClientUrl(): string;
+}

package/dialects/mysql/MySqlPlatform.js

@@ -0,0 +1,116 @@
+import { Utils, QueryOrder, DecimalType, DoubleType, } from '@mikro-orm/core';
+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 {
+    schemaHelper = new MySqlSchemaHelper(this);
+    exceptionConverter = new MySqlExceptionConverter();
+    ORDER_BY_NULLS_TRANSLATE = {
+        [QueryOrder.asc_nulls_first]: 'is not null',
+        [QueryOrder.asc_nulls_last]: 'is null',
+        [QueryOrder.desc_nulls_first]: 'is not null',
+        [QueryOrder.desc_nulls_last]: 'is null',
+    };
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new MySqlNativeQueryBuilder(this);
+    }
+    getDefaultCharset() {
+        return 'utf8mb4';
+    }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel || options?.readOnly) {
+            const parts = [];
+            if (options.isolationLevel) {
+                parts.push(`isolation level ${options.isolationLevel}`);
+            }
+            if (options.readOnly) {
+                parts.push('read only');
+            }
+            const sql = `set transaction ${parts.join(', ')}`;
+            return [sql, 'begin'];
+        }
+        return ['begin'];
+    }
+    convertJsonToDatabaseValue(value, context) {
+        if (context?.mode === 'query') {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames
+            .map(column => {
+            if (!column.includes('.')) {
+                return column;
+            }
+            const [root, ...path] = column.split('.');
+            return `(json_value(${this.quoteIdentifier(root)}, '$.${path.join('.')}' returning ${index.options?.returning ?? 'char(255)'}))`;
+        });
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'tinyint(1)';
+    }
+    normalizeColumnType(type, options) {
+        const simpleType = this.extractSimpleType(type);
+        if (['decimal', 'numeric'].includes(simpleType)) {
+            return this.getDecimalTypeDeclarationSQL(options);
+        }
+        return type;
+    }
+    getDefaultMappedType(type) {
+        if (type === 'tinyint(1)') {
+            return super.getDefaultMappedType('boolean');
+        }
+        return super.getDefaultMappedType(type);
+    }
+    isNumericColumn(mappedType) {
+        return super.isNumericColumn(mappedType) || [DecimalType, DoubleType].some(t => mappedType instanceof t);
+    }
+    supportsUnsigned() {
+        return true;
+    }
+    /**
+     * Returns the default name of index for the given columns
+     * cannot go past 64 character length for identifiers in MySQL
+     */
+    getIndexName(tableName, columns, type) {
+        if (type === 'primary') {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        const indexName = super.getIndexName(tableName, columns, type);
+        if (indexName.length > 64) {
+            return `${indexName.substring(0, 56 - type.length)}_${Utils.hash(indexName, 5)}_${type}`;
+        }
+        return indexName;
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return 'PRIMARY'; // https://dev.mysql.com/doc/refman/8.0/en/create-table.html#create-table-indexes-keys
+    }
+    supportsCreatingFullTextIndex() {
+        return true;
+    }
+    getFullTextWhereClause() {
+        return `match(:column:) against (:query in boolean mode)`;
+    }
+    getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
+        /* v8 ignore next */
+        const quotedTableName = this.quoteIdentifier(schemaName ? `${schemaName}.${tableName}` : tableName);
+        const quotedColumnNames = columns.map(c => this.quoteIdentifier(c.name));
+        const quotedIndexName = this.quoteIdentifier(indexName);
+        return `alter table ${quotedTableName} add fulltext index ${quotedIndexName}(${quotedColumnNames.join(',')})`;
+    }
+    getOrderByExpression(column, direction) {
+        const ret = [];
+        const dir = direction.toLowerCase();
+        if (dir in this.ORDER_BY_NULLS_TRANSLATE) {
+            ret.push(`${column} ${this.ORDER_BY_NULLS_TRANSLATE[dir]}`);
+        }
+        ret.push(`${column} ${dir.replace(/(\s|nulls|first|last)*/gi, '')}`);
+        return ret;
+    }
+    getDefaultClientUrl() {
+        return 'mysql://root@127.0.0.1:3306';
+    }
+}

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -0,0 +1,36 @@
+import { type Dictionary, type Type } from '@mikro-orm/core';
+import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey } from '../../typings.js';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
+import type { DatabaseTable } from '../../schema/DatabaseTable.js';
+export declare class MySqlSchemaHelper extends SchemaHelper {
+    private readonly _cache;
+    static readonly DEFAULT_VALUES: {
+        'now()': string[];
+        'current_timestamp(?)': string[];
+        '0': string[];
+    };
+    getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
+    getListTablesSQL(): string;
+    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;
+    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>>>;
+    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
+    private getColumnDeclarationSQL;
+    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
+    private supportsCheckConstraints;
+    protected getChecksSQL(tables: Table[]): string;
+    normalizeDefaultValue(defaultValue: string, length: number): string | number;
+    protected wrap(val: string | null | undefined, type: Type<unknown>): string | null | undefined;
+}