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

package/dialects/mysql/MySqlSchemaHelper.js

@@ -0,0 +1,269 @@
+import { EnumType, StringType, TextType } from '@mikro-orm/core';
+import { SchemaHelper } from '../../schema/SchemaHelper.js';
+export class MySqlSchemaHelper extends SchemaHelper {
+    _cache = {};
+    static DEFAULT_VALUES = {
+        'now()': ['now()', 'current_timestamp'],
+        'current_timestamp(?)': ['current_timestamp(?)'],
+        '0': ['0', 'false'],
+    };
+    getSchemaBeginning(charset, disableForeignKeys) {
+        if (disableForeignKeys) {
+            return `set names ${charset};\n${this.disableForeignKeysSQL()}\n\n`;
+        }
+        return `set names ${charset};\n\n`;
+    }
+    disableForeignKeysSQL() {
+        return 'set foreign_key_checks = 0;';
+    }
+    enableForeignKeysSQL() {
+        return 'set foreign_key_checks = 1;';
+    }
+    finalizeTable(table, charset, collate) {
+        let sql = ` default character set ${charset}`;
+        if (collate) {
+            sql += ` collate ${collate}`;
+        }
+        sql += ' engine = InnoDB';
+        if (table.comment) {
+            sql += ` comment = ${this.platform.quoteValue(table.comment)}`;
+        }
+        return sql;
+    }
+    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()`;
+    }
+    async loadInformationSchema(schema, connection, tables) {
+        if (tables.length === 0) {
+            return;
+        }
+        const columns = await this.getAllColumns(connection, tables);
+        const indexes = await this.getAllIndexes(connection, tables);
+        const checks = await this.getAllChecks(connection, tables);
+        const fks = await this.getAllForeignKeys(connection, tables);
+        const enums = await this.getAllEnumDefinitions(connection, tables);
+        for (const t of tables) {
+            const key = this.getTableKey(t);
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
+            table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
+        }
+    }
+    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 */
+        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`;
+        const allIndexes = await connection.execute(sql);
+        const ret = {};
+        for (const index of allIndexes) {
+            const key = this.getTableKey(index);
+            const indexDef = {
+                columnNames: [index.column_name],
+                keyName: index.index_name,
+                unique: !index.non_unique,
+                primary: index.index_name === 'PRIMARY',
+                constraint: !index.non_unique,
+            };
+            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);
+            }
+            ret[key] ??= [];
+            ret[key].push(indexDef);
+        }
+        for (const key of Object.keys(ret)) {
+            ret[key] = await this.mapIndexes(ret[key]);
+        }
+        return ret;
+    }
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        /* v8 ignore next */
+        if (index.expression && !partialExpression) {
+            return index.expression;
+        }
+        tableName = this.quote(tableName);
+        const keyName = this.quote(index.keyName);
+        const sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})`;
+        }
+        // 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(', ')})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+    }
+    async getAllColumns(connection, tables) {
+        const sql = `select table_name as table_name,
+      nullif(table_schema, schema()) as schema_name,
+      column_name as column_name,
+      column_default as column_default,
+      nullif(column_comment, '') as column_comment,
+      is_nullable as is_nullable,
+      data_type as data_type,
+      column_type as column_type,
+      column_key as column_key,
+      extra as extra,
+      generation_expression as generation_expression,
+      numeric_precision as numeric_precision,
+      numeric_scale as numeric_scale,
+      ifnull(datetime_precision, character_maximum_length) length
+      from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
+      order by ordinal_position`;
+        const allColumns = await connection.execute(sql);
+        const str = (val) => val != null ? '' + val : val;
+        const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
+        const ret = {};
+        for (const col of allColumns) {
+            const mappedType = this.platform.getMappedType(col.column_type);
+            const defaultValue = str(this.normalizeDefaultValue((mappedType.compareAsType() === 'boolean' && ['0', '1'].includes(col.column_default))
+                ? ['false', 'true'][+col.column_default]
+                : col.column_default, col.length));
+            const key = this.getTableKey(col);
+            const generated = col.generation_expression ? `(${col.generation_expression.replaceAll(`\\'`, `'`)}) ${col.extra.match(/stored generated/i) ? 'stored' : 'virtual'}` : undefined;
+            ret[key] ??= [];
+            ret[key].push({
+                name: col.column_name,
+                type: this.platform.isNumericColumn(mappedType) ? col.column_type.replace(/ unsigned$/, '').replace(/\(\d+\)$/, '') : col.column_type,
+                mappedType,
+                unsigned: col.column_type.endsWith(' unsigned'),
+                length: col.length,
+                default: this.wrap(defaultValue, mappedType),
+                nullable: col.is_nullable === 'YES',
+                primary: col.column_key === 'PRI',
+                unique: col.column_key === 'UNI',
+                autoincrement: col.extra === 'auto_increment',
+                precision: col.numeric_precision,
+                scale: col.numeric_scale,
+                comment: col.column_comment,
+                extra: extra(col.extra),
+                generated,
+            });
+        }
+        return ret;
+    }
+    async getAllChecks(connection, tables) {
+        /* v8 ignore next */
+        if (!(await this.supportsCheckConstraints(connection))) {
+            return {};
+        }
+        const sql = this.getChecksSQL(tables);
+        const allChecks = await connection.execute(sql);
+        const ret = {};
+        for (const check of allChecks) {
+            const key = this.getTableKey(check);
+            ret[key] ??= [];
+            ret[key].push({
+                name: check.name,
+                columnName: check.column_name,
+                definition: `check ${check.expression}`,
+                expression: check.expression.replace(/^\((.*)\)$/, '$1'),
+            });
+        }
+        return ret;
+    }
+    async getAllForeignKeys(connection, tables) {
+        const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
+        from information_schema.key_column_usage k
+        inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = k.table_name
+        where k.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
+        and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null
+        order by constraint_name, k.ordinal_position`;
+        const allFks = await connection.execute(sql);
+        const ret = {};
+        for (const fk of allFks) {
+            const key = this.getTableKey(fk);
+            ret[key] ??= [];
+            ret[key].push(fk);
+        }
+        Object.keys(ret).forEach(key => {
+            const parts = key.split('.');
+            /* v8 ignore next */
+            const schemaName = parts.length > 1 ? parts[0] : undefined;
+            ret[key] = this.mapForeignKeys(ret[key], key, schemaName);
+        });
+        return ret;
+    }
+    getPreAlterTable(tableDiff, safe) {
+        // Dropping primary keys requires to unset autoincrement attribute on the particular column first.
+        const pk = Object.values(tableDiff.removedIndexes).find(idx => idx.primary);
+        if (!pk || safe) {
+            return [];
+        }
+        return pk.columnNames
+            .filter(col => tableDiff.fromTable.hasColumn(col))
+            .map(col => tableDiff.fromTable.getColumn(col))
+            .filter(col => col.autoincrement)
+            .map(col => `alter table \`${tableDiff.name}\` modify \`${col.name}\` ${this.getColumnDeclarationSQL({ ...col, autoincrement: false })}`);
+    }
+    getRenameColumnSQL(tableName, oldColumnName, to) {
+        tableName = this.quote(tableName);
+        oldColumnName = this.quote(oldColumnName);
+        const columnName = this.quote(to.name);
+        return `alter table ${tableName} change ${oldColumnName} ${columnName} ${this.getColumnDeclarationSQL(to)}`;
+    }
+    getRenameIndexSQL(tableName, index, oldIndexName) {
+        tableName = this.quote(tableName);
+        oldIndexName = this.quote(oldIndexName);
+        const keyName = this.quote(index.keyName);
+        return [`alter table ${tableName} rename index ${oldIndexName} to ${keyName}`];
+    }
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
+        tableName = this.quote(tableName);
+        const columnName = this.quote(to.name);
+        return `alter table ${tableName} modify ${columnName} ${this.getColumnDeclarationSQL(to)}`;
+    }
+    alterTableColumn(column, table, changedProperties) {
+        const col = this.createTableColumn(column, table, changedProperties);
+        return [`alter table ${table.getQuotedName()} modify ${col}`];
+    }
+    getColumnDeclarationSQL(col) {
+        let ret = col.type;
+        ret += col.unsigned ? ' unsigned' : '';
+        ret += col.autoincrement ? ' auto_increment' : '';
+        ret += ' ';
+        ret += col.nullable ? 'null' : 'not null';
+        ret += col.default ? ' default ' + col.default : '';
+        ret += col.comment ? ` comment ${this.platform.quoteValue(col.comment)}` : '';
+        return ret;
+    }
+    async getAllEnumDefinitions(connection, tables) {
+        const sql = `select column_name as column_name, column_type as column_type, table_name as table_name
+      from information_schema.columns
+      where data_type = 'enum' and table_name in (${tables.map(t => `'${t.table_name}'`).join(', ')}) and table_schema = database()`;
+        const enums = await connection.execute(sql);
+        return enums.reduce((o, item) => {
+            o[item.table_name] ??= {};
+            o[item.table_name][item.column_name] = item.column_type.match(/enum\((.*)\)/)[1].split(',').map((item) => item.match(/'(.*)'/)[1]);
+            return o;
+        }, {});
+    }
+    async supportsCheckConstraints(connection) {
+        if (this._cache.supportsCheckConstraints != null) {
+            return this._cache.supportsCheckConstraints;
+        }
+        const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
+        const res = await connection.execute(sql);
+        return this._cache.supportsCheckConstraints = res.length > 0;
+    }
+    getChecksSQL(tables) {
+        return `select cc.constraint_schema as table_schema, tc.table_name as table_name, cc.constraint_name as name, cc.check_clause as expression
+      from information_schema.check_constraints cc
+      join information_schema.table_constraints tc
+        on tc.constraint_schema = cc.constraint_schema
+        and tc.constraint_name = cc.constraint_name
+        and constraint_type = 'CHECK'
+      where tc.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))}) and tc.constraint_schema = database()
+      order by tc.constraint_name`;
+    }
+    normalizeDefaultValue(defaultValue, length) {
+        return super.normalizeDefaultValue(defaultValue, length, MySqlSchemaHelper.DEFAULT_VALUES);
+    }
+    wrap(val, type) {
+        const stringType = type instanceof StringType || type instanceof TextType || type instanceof EnumType;
+        return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
+    }
+}

package/dialects/mysql/index.d.ts

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

package/dialects/mysql/index.js

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

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.d.ts

@@ -0,0 +1,5 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export declare class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder {
+    protected compileTruncate(): void;
+}

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.js

@@ -0,0 +1,8 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder {
+    compileTruncate() {
+        super.compileTruncate();
+        this.parts.push('restart identity cascade');
+    }
+}

package/dialects/postgresql/PostgreSqlTableCompiler.d.ts

@@ -0,0 +1 @@
+export {};

package/dialects/postgresql/PostgreSqlTableCompiler.js

@@ -0,0 +1 @@
+export {};

package/dialects/postgresql/index.d.ts

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

package/dialects/postgresql/index.js

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

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -0,0 +1,6 @@
+import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+export declare abstract class BaseSqliteConnection extends AbstractSqlConnection {
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
+}

package/dialects/sqlite/BaseSqliteConnection.js

@@ -0,0 +1,8 @@
+import { CompiledQuery } from 'kysely';
+import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+export class BaseSqliteConnection extends AbstractSqlConnection {
+    async connect(options) {
+        await super.connect(options);
+        await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+    }
+}

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -0,0 +1,70 @@
+import { type EntityProperty, type IsolationLevel } from '@mikro-orm/core';
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
+import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
+import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
+import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
+export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: SqliteSchemaHelper;
+    protected readonly exceptionConverter: SqliteExceptionConverter;
+    /** @internal */
+    createNativeQueryBuilder(): SqliteNativeQueryBuilder;
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    usesEnumCheckConstraints(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    normalizeColumnType(type: string, options: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value: unknown): string | number | Date;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    supportsDeferredUniqueConstraints(): boolean;
+    getFullTextWhereClause(): string;
+    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    quoteValue(value: any): string;
+}

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -0,0 +1,104 @@
+import { AbstractSqlPlatform } from '../../AbstractSqlPlatform.js';
+import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
+import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
+import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
+export class BaseSqlitePlatform extends AbstractSqlPlatform {
+    schemaHelper = new SqliteSchemaHelper(this);
+    exceptionConverter = new SqliteExceptionConverter();
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new SqliteNativeQueryBuilder(this);
+    }
+    usesDefaultKeyword() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    usesEnumCheckConstraints() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return super.getCurrentTimestampSQL(0);
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return 'datetime';
+    }
+    getBeginTransactionSQL(options) {
+        return ['begin'];
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every(item => typeof item === 'string')) {
+            return 'text';
+        }
+        /* v8 ignore next */
+        return this.getTinyIntTypeDeclarationSQL(column);
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getSmallIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        return 'integer';
+    }
+    getFloatDeclarationSQL() {
+        return 'real';
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'integer';
+    }
+    getCharTypeDeclarationSQL(column) {
+        return 'text';
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return 'text';
+    }
+    normalizeColumnType(type, options) {
+        const simpleType = this.extractSimpleType(type);
+        if (['varchar', 'text'].includes(simpleType)) {
+            return this.getVarcharTypeDeclarationSQL(options);
+        }
+        return simpleType;
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value) {
+        if (value instanceof Date) {
+            return +value;
+        }
+        return value;
+    }
+    getIndexName(tableName, columns, type) {
+        if (type === 'primary') {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        return super.getIndexName(tableName, columns, type);
+    }
+    supportsDeferredUniqueConstraints() {
+        return false;
+    }
+    getFullTextWhereClause() {
+        return `:column: match :query`;
+    }
+    quoteVersionValue(value, prop) {
+        if (prop.runtimeType === 'Date') {
+            return this.escape(value).replace(/^'|\.\d{3}'$/g, '');
+        }
+        return value;
+    }
+    quoteValue(value) {
+        if (value instanceof Date) {
+            return '' + +value;
+        }
+        return super.quoteValue(value);
+    }
+}

package/dialects/sqlite/SqliteExceptionConverter.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
+export declare class SqliteExceptionConverter extends ExceptionConverter {
+    /**
+     * @inheritDoc
+     * @see http://www.sqlite.org/c3ref/c_abort.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/dialects/sqlite/SqliteExceptionConverter.js

@@ -0,0 +1,54 @@
+import { ConnectionException, ExceptionConverter, InvalidFieldNameException, LockWaitTimeoutException, NonUniqueFieldNameException, CheckConstraintViolationException, NotNullConstraintViolationException, ReadOnlyException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, ForeignKeyConstraintViolationException, } from '@mikro-orm/core';
+export class SqliteExceptionConverter extends ExceptionConverter {
+    /**
+     * @inheritDoc
+     * @see http://www.sqlite.org/c3ref/c_abort.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception) {
+        /* v8 ignore next */
+        if (exception.message.includes('database is locked')) {
+            return new LockWaitTimeoutException(exception);
+        }
+        if (exception.message.includes('must be unique') ||
+            exception.message.includes('is not unique') ||
+            exception.message.includes('are not unique') ||
+            exception.message.includes('UNIQUE constraint failed')) {
+            return new UniqueConstraintViolationException(exception);
+        }
+        if (exception.message.includes('may not be NULL') || exception.message.includes('NOT NULL constraint failed')) {
+            return new NotNullConstraintViolationException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('CHECK constraint failed')) {
+            return new CheckConstraintViolationException(exception);
+        }
+        if (exception.message.includes('no such table:')) {
+            return new TableNotFoundException(exception);
+        }
+        if (exception.message.includes('already exists')) {
+            return new TableExistsException(exception);
+        }
+        if (exception.message.includes('no such column:')) {
+            return new InvalidFieldNameException(exception);
+        }
+        if (exception.message.includes('ambiguous column name')) {
+            return new NonUniqueFieldNameException(exception);
+        }
+        if (exception.message.includes('syntax error')) {
+            return new SyntaxErrorException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('attempt to write a readonly database')) {
+            return new ReadOnlyException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('unable to open database file')) {
+            return new ConnectionException(exception);
+        }
+        if (exception.message.includes('FOREIGN KEY constraint failed')) {
+            return new ForeignKeyConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}

package/dialects/sqlite/SqliteNativeQueryBuilder.d.ts

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

package/dialects/sqlite/SqliteNativeQueryBuilder.js

@@ -0,0 +1,11 @@
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export class SqliteNativeQueryBuilder extends NativeQueryBuilder {
+    compileTruncate() {
+        const sql = `delete from ${this.getTableName()}`;
+        this.parts.push(sql);
+    }
+    addLockClause() {
+        return; // not supported
+    }
+}

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -0,0 +1,38 @@
+import { type Connection } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
+import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import type { Column, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { DatabaseTable } from '../../schema/DatabaseTable.js';
+import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
+export declare class SqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getListTablesSQL(): string;
+    getDropDatabaseSQL(name: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    createTable(table: DatabaseTable, alter?: boolean): string[];
+    createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
+    dropForeignKey(tableName: string, constraintName: string): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    private parseTableDefinition;
+    private getColumns;
+    private getEnumDefinitions;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    private getIndexes;
+    private getChecks;
+    private getColumnDefinitions;
+    private getForeignKeys;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    alterTable(diff: TableDifference, safe?: boolean): string[];
+    private getAlterTempTableSQL;
+}