@mikro-orm/sql 7.0.10-dev.8 → 7.0.10

package/schema/SqlSchemaGenerator.js

@@ -1,515 +1,545 @@
-import { CommitOrderCalculator, TableNotFoundException, Utils, } from '@mikro-orm/core';
+import { CommitOrderCalculator, TableNotFoundException, Utils } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
 /** Generates and manages SQL database schemas based on entity metadata. Supports create, update, and drop operations. */
 export class SqlSchemaGenerator extends AbstractSchemaGenerator {
-    helper = this.platform.getSchemaHelper();
-    options = this.config.get('schemaGenerator');
-    lastEnsuredDatabase;
-    static register(orm) {
-        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
-    }
-    async create(options) {
-        await this.ensureDatabase();
-        const sql = await this.getCreateSchemaSQL(options);
-        await this.execute(sql);
-    }
-    /**
-     * Returns true if the database was created.
-     */
-    async ensureDatabase(options) {
-        await this.connection.ensureConnection();
-        const dbName = this.config.get('dbName');
-        if (this.lastEnsuredDatabase === dbName && !options?.forceCheck) {
-            return true;
-        }
-        const exists = await this.helper.databaseExists(this.connection, dbName);
-        this.lastEnsuredDatabase = dbName;
-        if (!exists) {
-            const managementDbName = this.helper.getManagementDbName();
-            if (managementDbName) {
-                this.config.set('dbName', managementDbName);
-                await this.driver.reconnect({ skipOnConnect: true });
-                await this.createDatabase(dbName, { skipOnConnect: true });
-            }
-            if (options?.create) {
-                await this.create(options);
-            }
-            return true;
-        }
-        /* v8 ignore next */
-        if (options?.clear) {
-            await this.clear({ ...options, clearIdentityMap: false });
-        }
-        return false;
-    }
-    getTargetSchema(schema) {
-        const metadata = this.getOrderedMetadata(schema);
-        const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
-        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
-    }
-    getOrderedMetadata(schema) {
-        const metadata = super.getOrderedMetadata(schema);
-        // Filter out skipped tables
-        return metadata.filter(meta => {
-            const tableName = meta.tableName;
-            const tableSchema = meta.schema ?? schema ?? this.config.get('schema');
-            return !this.isTableSkipped(tableName, tableSchema);
-        });
-    }
-    async getCreateSchemaSQL(options = {}) {
-        const toSchema = this.getTargetSchema(options.schema);
-        const ret = [];
-        for (const namespace of toSchema.getNamespaces()) {
-            if (namespace === this.platform.getDefaultSchemaName()) {
-                continue;
-            }
-            const sql = this.helper.getCreateNamespaceSQL(namespace);
-            this.append(ret, sql);
-        }
-        if (this.platform.supportsNativeEnums()) {
-            const created = [];
-            for (const [enumName, enumOptions] of Object.entries(toSchema.getNativeEnums())) {
-                /* v8 ignore next */
-                if (created.includes(enumName)) {
-                    continue;
-                }
-                created.push(enumName);
-                const sql = this.helper.getCreateNativeEnumSQL(enumOptions.name, enumOptions.items, this.getSchemaName(enumOptions, options));
-                this.append(ret, sql);
-            }
-        }
-        for (const table of toSchema.getTables()) {
-            this.append(ret, this.helper.createTable(table), true);
-        }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const table of toSchema.getTables()) {
-                const fks = Object.values(table.getForeignKeys()).map(fk => this.helper.createForeignKey(table, fk));
-                this.append(ret, fks, true);
-            }
-        }
-        const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
-        for (const view of sortedViews) {
-            this.appendViewCreation(ret, view);
-        }
-        return this.wrapSchema(ret, options);
+  helper = this.platform.getSchemaHelper();
+  options = this.config.get('schemaGenerator');
+  lastEnsuredDatabase;
+  static register(orm) {
+    orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
+  }
+  async create(options) {
+    await this.ensureDatabase();
+    const sql = await this.getCreateSchemaSQL(options);
+    await this.execute(sql);
+  }
+  /**
+   * Returns true if the database was created.
+   */
+  async ensureDatabase(options) {
+    await this.connection.ensureConnection();
+    const dbName = this.config.get('dbName');
+    if (this.lastEnsuredDatabase === dbName && !options?.forceCheck) {
+      return true;
     }
-    async drop(options = {}) {
-        if (options.dropDb) {
-            const name = this.config.get('dbName');
-            return this.dropDatabase(name);
-        }
-        const sql = await this.getDropSchemaSQL(options);
-        await this.execute(sql);
+    const exists = await this.helper.databaseExists(this.connection, dbName);
+    this.lastEnsuredDatabase = dbName;
+    if (!exists) {
+      const managementDbName = this.helper.getManagementDbName();
+      if (managementDbName) {
+        this.config.set('dbName', managementDbName);
+        await this.driver.reconnect({ skipOnConnect: true });
+        await this.createDatabase(dbName, { skipOnConnect: true });
+      }
+      if (options?.create) {
+        await this.create(options);
+      }
+      return true;
     }
-    async createNamespace(name) {
-        const sql = this.helper.getCreateNamespaceSQL(name);
-        await this.execute(sql);
+    /* v8 ignore next */
+    if (options?.clear) {
+      await this.clear({ ...options, clearIdentityMap: false });
     }
-    async dropNamespace(name) {
-        const sql = this.helper.getDropNamespaceSQL(name);
-        await this.execute(sql);
+    return false;
+  }
+  getTargetSchema(schema) {
+    const metadata = this.getOrderedMetadata(schema);
+    const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+    return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
+  }
+  getOrderedMetadata(schema) {
+    const metadata = super.getOrderedMetadata(schema);
+    // Filter out skipped tables
+    return metadata.filter(meta => {
+      const tableName = meta.tableName;
+      const tableSchema = meta.schema ?? schema ?? this.config.get('schema');
+      return !this.isTableSkipped(tableName, tableSchema);
+    });
+  }
+  async getCreateSchemaSQL(options = {}) {
+    const toSchema = this.getTargetSchema(options.schema);
+    const ret = [];
+    for (const namespace of toSchema.getNamespaces()) {
+      if (namespace === this.platform.getDefaultSchemaName()) {
+        continue;
+      }
+      const sql = this.helper.getCreateNamespaceSQL(namespace);
+      this.append(ret, sql);
     }
-    async clear(options) {
-        // truncate by default, so no value is considered as true
+    if (this.platform.supportsNativeEnums()) {
+      const created = [];
+      for (const [enumName, enumOptions] of Object.entries(toSchema.getNativeEnums())) {
         /* v8 ignore next */
-        if (options?.truncate === false) {
-            return super.clear(options);
-        }
-        if (this.options.disableForeignKeysForClear) {
-            await this.execute(this.helper.disableForeignKeysSQL());
-        }
-        const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
-        for (const meta of this.getOrderedMetadata(schema).reverse()) {
-            try {
-                await this.driver
-                    .createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
-                    .withSchema(schema)
-                    .truncate()
-                    .execute();
-            }
-            catch (e) {
-                if (this.platform.getExceptionConverter().convertException(e) instanceof TableNotFoundException) {
-                    continue;
-                }
-                throw e;
-            }
-        }
-        if (this.options.disableForeignKeysForClear) {
-            await this.execute(this.helper.enableForeignKeysSQL());
-        }
-        if (options?.clearIdentityMap ?? true) {
-            this.clearIdentityMap();
-        }
+        if (created.includes(enumName)) {
+          continue;
+        }
+        created.push(enumName);
+        const sql = this.helper.getCreateNativeEnumSQL(
+          enumOptions.name,
+          enumOptions.items,
+          this.getSchemaName(enumOptions, options),
+        );
+        this.append(ret, sql);
+      }
     }
-    async getDropSchemaSQL(options = {}) {
-        await this.ensureDatabase();
-        const metadata = this.getOrderedMetadata(options.schema).reverse();
-        const schemas = this.getTargetSchema(options.schema).getNamespaces();
-        const schema = await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews);
-        const ret = [];
-        // Drop views first (views may depend on tables)
-        // Drop in reverse dependency order (dependent views first)
-        const targetSchema = this.getTargetSchema(options.schema);
-        const sortedViews = this.sortViewsByDependencies(targetSchema.getViews()).reverse();
-        for (const view of sortedViews) {
-            if (view.materialized) {
-                this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
-            }
-            else {
-                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
-            }
-        }
-        // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
-        for (const meta of metadata) {
-            if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
-                const table = schema.getTable(meta.tableName);
-                if (!table) {
-                    continue;
-                }
-                const foreignKeys = Object.values(table.getForeignKeys());
-                for (const fk of foreignKeys) {
-                    this.append(ret, this.helper.dropForeignKey(table.getShortestName(), fk.constraintName));
-                }
-            }
-        }
-        for (const meta of metadata) {
-            this.append(ret, this.helper.dropTableIfExists(meta.tableName, this.getSchemaName(meta, options)));
-        }
-        if (this.platform.supportsNativeEnums()) {
-            for (const enumOptions of Object.values(schema.getNativeEnums())) {
-                const sql = this.helper.getDropNativeEnumSQL(enumOptions.name, this.getSchemaName(enumOptions, options));
-                this.append(ret, sql);
-            }
-        }
-        if (options.dropMigrationsTable) {
-            this.append(ret, this.helper.dropTableIfExists(this.config.get('migrations').tableName, this.config.get('schema')));
-        }
-        return this.wrapSchema(ret, options);
+    for (const table of toSchema.getTables()) {
+      this.append(ret, this.helper.createTable(table), true);
     }
-    getSchemaName(meta, options) {
-        const schemaName = options.schema ?? this.config.get('schema');
-        /* v8 ignore next */
-        const resolvedName = meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
-        // skip default schema name
-        if (resolvedName === this.platform.getDefaultSchemaName()) {
-            return undefined;
-        }
-        return resolvedName;
-    }
-    async update(options = {}) {
-        const sql = await this.getUpdateSchemaSQL(options);
-        await this.execute(sql);
-    }
-    async getUpdateSchemaSQL(options = {}) {
-        await this.ensureDatabase();
-        const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
-        const comparator = new SchemaComparator(this.platform);
-        const diffUp = comparator.compare(fromSchema, toSchema);
-        return this.diffToSQL(diffUp, options);
-    }
-    async getUpdateSchemaMigrationSQL(options = {}) {
-        if (!options.fromSchema) {
-            await this.ensureDatabase();
-        }
-        const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
-        const comparator = new SchemaComparator(this.platform);
-        const diffUp = comparator.compare(fromSchema, toSchema);
-        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
-        return {
-            up: this.diffToSQL(diffUp, options),
-            down: this.platform.supportsDownMigrations() ? this.diffToSQL(diffDown, options) : '',
-        };
-    }
-    async prepareSchemaForComparison(options) {
-        options.safe ??= false;
-        options.dropTables ??= true;
-        const toSchema = this.getTargetSchema(options.schema);
-        const schemas = toSchema.getNamespaces();
-        const fromSchema = options.fromSchema ??
-            (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews));
-        const wildcardSchemaTables = [...this.metadata.getAll().values()]
-            .filter(meta => meta.schema === '*')
-            .map(meta => meta.tableName);
-        fromSchema.prune(options.schema, wildcardSchemaTables);
-        toSchema.prune(options.schema, wildcardSchemaTables);
-        return { fromSchema, toSchema };
-    }
-    diffToSQL(schemaDiff, options) {
-        const ret = [];
-        globalThis.idx = 0;
-        if (this.platform.supportsSchemas()) {
-            for (const newNamespace of schemaDiff.newNamespaces) {
-                const sql = this.helper.getCreateNamespaceSQL(newNamespace);
-                this.append(ret, sql);
-            }
-        }
-        if (this.platform.supportsNativeEnums()) {
-            for (const newNativeEnum of schemaDiff.newNativeEnums) {
-                const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, this.getSchemaName(newNativeEnum, options));
-                this.append(ret, sql);
-            }
-        }
-        // Drop removed and changed views first (before modifying tables they may depend on)
-        // Drop in reverse dependency order (dependent views first)
-        if (options.dropTables && !options.safe) {
-            const sortedRemovedViews = this.sortViewsByDependencies(Object.values(schemaDiff.removedViews)).reverse();
-            for (const view of sortedRemovedViews) {
-                if (view.materialized) {
-                    this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
-                }
-                else {
-                    this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
-                }
-            }
-        }
-        // Drop changed views (they will be recreated after table changes)
-        // Also in reverse dependency order
-        const changedViewsFrom = Object.values(schemaDiff.changedViews).map(v => v.from);
-        const sortedChangedViewsFrom = this.sortViewsByDependencies(changedViewsFrom).reverse();
-        for (const view of sortedChangedViewsFrom) {
-            if (view.materialized) {
-                this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
-            }
-            else {
-                this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
-            }
-        }
-        if (!options.safe && this.options.createForeignKeyConstraints) {
-            for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
-                const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName, true);
-                /* v8 ignore next */
-                const name = (schemaName ? schemaName + '.' : '') + tableName;
-                this.append(ret, this.helper.dropForeignKey(name, orphanedForeignKey.constraintName));
-            }
-            if (schemaDiff.orphanedForeignKeys.length > 0) {
-                ret.push('');
-            }
-        }
-        for (const newTable of Object.values(schemaDiff.newTables)) {
-            this.append(ret, this.helper.createTable(newTable, true), true);
-        }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const newTable of Object.values(schemaDiff.newTables)) {
-                const sql = [];
-                if (this.options.createForeignKeyConstraints) {
-                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
-                    this.append(sql, fks);
-                }
-                for (const check of newTable.getChecks()) {
-                    this.append(sql, this.helper.createCheck(newTable, check));
-                }
-                this.append(ret, sql, true);
-            }
-        }
-        if (options.dropTables && !options.safe) {
-            for (const table of Object.values(schemaDiff.removedTables)) {
-                this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
-            }
-            if (Utils.hasObjectKeys(schemaDiff.removedTables)) {
-                ret.push('');
-            }
-        }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            this.append(ret, this.preAlterTable(changedTable, options.safe), true);
-        }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
-        }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
-            this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
-        }
-        if (!options.safe && this.platform.supportsNativeEnums()) {
-            for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
-                this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
-            }
-        }
-        if (options.dropTables && !options.safe) {
-            for (const removedNamespace of schemaDiff.removedNamespaces) {
-                const sql = this.helper.getDropNamespaceSQL(removedNamespace);
-                this.append(ret, sql);
-            }
-        }
-        const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
-        for (const view of sortedNewViews) {
-            this.appendViewCreation(ret, view);
-        }
-        const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
-        const sortedChangedViews = this.sortViewsByDependencies(changedViews);
-        for (const view of sortedChangedViews) {
-            this.appendViewCreation(ret, view);
-        }
-        return this.wrapSchema(ret, options);
-    }
-    /**
-     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
-     */
-    preAlterTable(diff, safe) {
-        const ret = [];
-        this.append(ret, this.helper.getPreAlterTable(diff, safe));
-        for (const foreignKey of Object.values(diff.removedForeignKeys)) {
-            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
-        }
-        for (const foreignKey of Object.values(diff.changedForeignKeys)) {
-            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
-        }
-        return ret;
-    }
-    /**
-     * creates new database and connects to it
-     */
-    async createDatabase(name, options) {
-        name ??= this.config.get('dbName');
-        const sql = this.helper.getCreateDatabaseSQL(name);
-        if (sql) {
-            await this.execute(sql);
-        }
-        this.config.set('dbName', name);
-        await this.driver.reconnect(options);
-    }
-    async dropDatabase(name) {
-        name ??= this.config.get('dbName');
-        this.config.set('dbName', this.helper.getManagementDbName());
-        await this.driver.reconnect();
-        await this.execute(this.helper.getDropDatabaseSQL(name));
-        this.config.set('dbName', name);
-    }
-    async execute(sql, options = {}) {
-        options.wrap ??= false;
-        const lines = this.wrapSchema(sql, options).split('\n');
-        const groups = [];
-        let i = 0;
-        for (const line of lines) {
-            if (line.trim() === '') {
-                if (groups[i]?.length > 0) {
-                    i++;
-                }
-                continue;
-            }
-            groups[i] ??= [];
-            groups[i].push(line.trim());
-        }
-        if (groups.length === 0) {
-            return;
-        }
-        if (this.platform.supportsMultipleStatements()) {
-            for (const group of groups) {
-                const query = group.join('\n');
-                await this.driver.execute(query);
-            }
-            return;
-        }
-        const statements = groups.flatMap(group => {
-            return group
-                .join('\n')
-                .split(';\n')
-                .map(s => s.trim())
-                .filter(s => s);
-        });
-        await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
-    }
-    async dropTableIfExists(name, schema) {
-        const sql = this.helper.dropTableIfExists(name, schema);
-        return this.execute(sql);
-    }
-    wrapSchema(sql, options) {
-        const array = Utils.asArray(sql);
-        if (array.length === 0) {
-            return '';
-        }
-        if (array[array.length - 1] === '') {
-            array.pop();
-        }
-        if (options.wrap === false) {
-            return array.join('\n') + '\n';
-        }
-        let ret = this.helper.getSchemaBeginning(this.config.get('charset'), this.options.disableForeignKeys);
-        ret += array.join('\n') + '\n';
-        ret += this.helper.getSchemaEnd(this.options.disableForeignKeys);
-        return ret;
-    }
-    append(array, sql, pad) {
-        return this.helper.append(array, sql, pad);
-    }
-    matchName(name, nameToMatch) {
-        return typeof nameToMatch === 'string'
-            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
-            : nameToMatch.test(name);
-    }
-    isTableSkipped(tableName, schemaName) {
-        const skipTables = this.options.skipTables;
-        if (!skipTables || skipTables.length === 0) {
-            return false;
-        }
-        const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
-        return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
-    }
-    /**
-     * Sorts views by their dependencies so that views depending on other views are created after their dependencies.
-     * Uses topological sort based on view definition string matching.
-     */
-    sortViewsByDependencies(views) {
-        if (views.length <= 1) {
-            return views;
-        }
-        // Use CommitOrderCalculator for topological sort
-        const calc = new CommitOrderCalculator();
-        // Map views to numeric indices for the calculator
-        const viewToIndex = new Map();
-        const indexToView = new Map();
-        for (let i = 0; i < views.length; i++) {
-            viewToIndex.set(views[i], i);
-            indexToView.set(i, views[i]);
-            calc.addNode(i);
-        }
-        // Check each view's definition for references to other view names
-        for (const view of views) {
-            const definition = view.definition.toLowerCase();
-            const viewIndex = viewToIndex.get(view);
-            for (const otherView of views) {
-                if (otherView === view) {
-                    continue;
-                }
-                // Check if the definition references the other view's name
-                // Use word boundary matching to avoid false positives
-                const patterns = [new RegExp(`\\b${this.escapeRegExp(otherView.name.toLowerCase())}\\b`)];
-                if (otherView.schema) {
-                    patterns.push(new RegExp(`\\b${this.escapeRegExp(`${otherView.schema}.${otherView.name}`.toLowerCase())}\\b`));
-                }
-                for (const pattern of patterns) {
-                    if (pattern.test(definition)) {
-                        // view depends on otherView, so otherView must come first
-                        // addDependency(from, to) puts `from` before `to` in result
-                        const otherIndex = viewToIndex.get(otherView);
-                        calc.addDependency(otherIndex, viewIndex, 1);
-                        break;
-                    }
-                }
-            }
-        }
-        // Sort and map back to views
-        return calc.sort().map(index => indexToView.get(index));
+    if (this.helper.supportsSchemaConstraints()) {
+      for (const table of toSchema.getTables()) {
+        const fks = Object.values(table.getForeignKeys()).map(fk => this.helper.createForeignKey(table, fk));
+        this.append(ret, fks, true);
+      }
+    }
+    const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
+    for (const view of sortedViews) {
+      this.appendViewCreation(ret, view);
+    }
+    return this.wrapSchema(ret, options);
+  }
+  async drop(options = {}) {
+    if (options.dropDb) {
+      const name = this.config.get('dbName');
+      return this.dropDatabase(name);
+    }
+    const sql = await this.getDropSchemaSQL(options);
+    await this.execute(sql);
+  }
+  async createNamespace(name) {
+    const sql = this.helper.getCreateNamespaceSQL(name);
+    await this.execute(sql);
+  }
+  async dropNamespace(name) {
+    const sql = this.helper.getDropNamespaceSQL(name);
+    await this.execute(sql);
+  }
+  async clear(options) {
+    // truncate by default, so no value is considered as true
+    /* v8 ignore next */
+    if (options?.truncate === false) {
+      return super.clear(options);
+    }
+    if (this.options.disableForeignKeysForClear) {
+      await this.execute(this.helper.disableForeignKeysSQL());
+    }
+    const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+    for (const meta of this.getOrderedMetadata(schema).reverse()) {
+      try {
+        await this.driver
+          .createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
+          .withSchema(schema)
+          .truncate()
+          .execute();
+      } catch (e) {
+        if (this.platform.getExceptionConverter().convertException(e) instanceof TableNotFoundException) {
+          continue;
+        }
+        throw e;
+      }
+    }
+    if (this.options.disableForeignKeysForClear) {
+      await this.execute(this.helper.enableForeignKeysSQL());
+    }
+    if (options?.clearIdentityMap ?? true) {
+      this.clearIdentityMap();
+    }
+  }
+  async getDropSchemaSQL(options = {}) {
+    await this.ensureDatabase();
+    const metadata = this.getOrderedMetadata(options.schema).reverse();
+    const schemas = this.getTargetSchema(options.schema).getNamespaces();
+    const schema = await DatabaseSchema.create(
+      this.connection,
+      this.platform,
+      this.config,
+      options.schema,
+      schemas,
+      undefined,
+      this.options.skipTables,
+      this.options.skipViews,
+    );
+    const ret = [];
+    // Drop views first (views may depend on tables)
+    // Drop in reverse dependency order (dependent views first)
+    const targetSchema = this.getTargetSchema(options.schema);
+    const sortedViews = this.sortViewsByDependencies(targetSchema.getViews()).reverse();
+    for (const view of sortedViews) {
+      if (view.materialized) {
+        this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+      } else {
+        this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+      }
     }
-    appendViewCreation(ret, view) {
+    // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
+    for (const meta of metadata) {
+      if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
+        const table = schema.getTable(meta.tableName);
+        if (!table) {
+          continue;
+        }
+        const foreignKeys = Object.values(table.getForeignKeys());
+        for (const fk of foreignKeys) {
+          this.append(ret, this.helper.dropForeignKey(table.getShortestName(), fk.constraintName));
+        }
+      }
+    }
+    for (const meta of metadata) {
+      this.append(ret, this.helper.dropTableIfExists(meta.tableName, this.getSchemaName(meta, options)));
+    }
+    if (this.platform.supportsNativeEnums()) {
+      for (const enumOptions of Object.values(schema.getNativeEnums())) {
+        const sql = this.helper.getDropNativeEnumSQL(enumOptions.name, this.getSchemaName(enumOptions, options));
+        this.append(ret, sql);
+      }
+    }
+    if (options.dropMigrationsTable) {
+      this.append(
+        ret,
+        this.helper.dropTableIfExists(this.config.get('migrations').tableName, this.config.get('schema')),
+      );
+    }
+    return this.wrapSchema(ret, options);
+  }
+  getSchemaName(meta, options) {
+    const schemaName = options.schema ?? this.config.get('schema');
+    /* v8 ignore next */
+    const resolvedName = meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
+    // skip default schema name
+    if (resolvedName === this.platform.getDefaultSchemaName()) {
+      return undefined;
+    }
+    return resolvedName;
+  }
+  async update(options = {}) {
+    const sql = await this.getUpdateSchemaSQL(options);
+    await this.execute(sql);
+  }
+  async getUpdateSchemaSQL(options = {}) {
+    await this.ensureDatabase();
+    const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
+    const comparator = new SchemaComparator(this.platform);
+    const diffUp = comparator.compare(fromSchema, toSchema);
+    return this.diffToSQL(diffUp, options);
+  }
+  async getUpdateSchemaMigrationSQL(options = {}) {
+    if (!options.fromSchema) {
+      await this.ensureDatabase();
+    }
+    const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
+    const comparator = new SchemaComparator(this.platform);
+    const diffUp = comparator.compare(fromSchema, toSchema);
+    const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
+    return {
+      up: this.diffToSQL(diffUp, options),
+      down: this.platform.supportsDownMigrations() ? this.diffToSQL(diffDown, options) : '',
+    };
+  }
+  async prepareSchemaForComparison(options) {
+    options.safe ??= false;
+    options.dropTables ??= true;
+    const toSchema = this.getTargetSchema(options.schema);
+    const schemas = toSchema.getNamespaces();
+    const fromSchema =
+      options.fromSchema ??
+      (await DatabaseSchema.create(
+        this.connection,
+        this.platform,
+        this.config,
+        options.schema,
+        schemas,
+        undefined,
+        this.options.skipTables,
+        this.options.skipViews,
+      ));
+    const wildcardSchemaTables = [...this.metadata.getAll().values()]
+      .filter(meta => meta.schema === '*')
+      .map(meta => meta.tableName);
+    fromSchema.prune(options.schema, wildcardSchemaTables);
+    toSchema.prune(options.schema, wildcardSchemaTables);
+    return { fromSchema, toSchema };
+  }
+  diffToSQL(schemaDiff, options) {
+    const ret = [];
+    globalThis.idx = 0;
+    if (this.platform.supportsSchemas()) {
+      for (const newNamespace of schemaDiff.newNamespaces) {
+        const sql = this.helper.getCreateNamespaceSQL(newNamespace);
+        this.append(ret, sql);
+      }
+    }
+    if (this.platform.supportsNativeEnums()) {
+      for (const newNativeEnum of schemaDiff.newNativeEnums) {
+        const sql = this.helper.getCreateNativeEnumSQL(
+          newNativeEnum.name,
+          newNativeEnum.items,
+          this.getSchemaName(newNativeEnum, options),
+        );
+        this.append(ret, sql);
+      }
+    }
+    // Drop removed and changed views first (before modifying tables they may depend on)
+    // Drop in reverse dependency order (dependent views first)
+    if (options.dropTables && !options.safe) {
+      const sortedRemovedViews = this.sortViewsByDependencies(Object.values(schemaDiff.removedViews)).reverse();
+      for (const view of sortedRemovedViews) {
         if (view.materialized) {
-            this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            // Skip indexes for WITH NO DATA views — they have no data to index yet.
-            // Indexes will be created on the next schema:update after REFRESH populates data.
-            if (view.withData !== false) {
-                const viewName = this.helper.getTableName(view.name, view.schema);
-                for (const index of view.indexes ?? []) {
-                    this.append(ret, this.helper.getCreateIndexSQL(viewName, index));
-                }
-            }
-        }
-        else {
-            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+          this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+        } else {
+          this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
         }
+      }
+    }
+    // Drop changed views (they will be recreated after table changes)
+    // Also in reverse dependency order
+    const changedViewsFrom = Object.values(schemaDiff.changedViews).map(v => v.from);
+    const sortedChangedViewsFrom = this.sortViewsByDependencies(changedViewsFrom).reverse();
+    for (const view of sortedChangedViewsFrom) {
+      if (view.materialized) {
+        this.append(ret, this.helper.dropMaterializedViewIfExists(view.name, view.schema));
+      } else {
+        this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
+      }
+    }
+    if (!options.safe && this.options.createForeignKeyConstraints) {
+      for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
+        const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName, true);
+        /* v8 ignore next */
+        const name = (schemaName ? schemaName + '.' : '') + tableName;
+        this.append(ret, this.helper.dropForeignKey(name, orphanedForeignKey.constraintName));
+      }
+      if (schemaDiff.orphanedForeignKeys.length > 0) {
+        ret.push('');
+      }
+    }
+    for (const newTable of Object.values(schemaDiff.newTables)) {
+      this.append(ret, this.helper.createTable(newTable, true), true);
+    }
+    if (this.helper.supportsSchemaConstraints()) {
+      for (const newTable of Object.values(schemaDiff.newTables)) {
+        const sql = [];
+        if (this.options.createForeignKeyConstraints) {
+          const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+          this.append(sql, fks);
+        }
+        for (const check of newTable.getChecks()) {
+          this.append(sql, this.helper.createCheck(newTable, check));
+        }
+        this.append(ret, sql, true);
+      }
+    }
+    if (options.dropTables && !options.safe) {
+      for (const table of Object.values(schemaDiff.removedTables)) {
+        this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
+      }
+      if (Utils.hasObjectKeys(schemaDiff.removedTables)) {
+        ret.push('');
+      }
+    }
+    for (const changedTable of Object.values(schemaDiff.changedTables)) {
+      this.append(ret, this.preAlterTable(changedTable, options.safe), true);
+    }
+    for (const changedTable of Object.values(schemaDiff.changedTables)) {
+      this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
+    }
+    for (const changedTable of Object.values(schemaDiff.changedTables)) {
+      this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
+    }
+    if (!options.safe && this.platform.supportsNativeEnums()) {
+      for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
+        this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
+      }
+    }
+    if (options.dropTables && !options.safe) {
+      for (const removedNamespace of schemaDiff.removedNamespaces) {
+        const sql = this.helper.getDropNamespaceSQL(removedNamespace);
+        this.append(ret, sql);
+      }
+    }
+    const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
+    for (const view of sortedNewViews) {
+      this.appendViewCreation(ret, view);
+    }
+    const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
+    const sortedChangedViews = this.sortViewsByDependencies(changedViews);
+    for (const view of sortedChangedViews) {
+      this.appendViewCreation(ret, view);
+    }
+    return this.wrapSchema(ret, options);
+  }
+  /**
+   * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+   */
+  preAlterTable(diff, safe) {
+    const ret = [];
+    this.append(ret, this.helper.getPreAlterTable(diff, safe));
+    for (const foreignKey of Object.values(diff.removedForeignKeys)) {
+      ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
+    }
+    for (const foreignKey of Object.values(diff.changedForeignKeys)) {
+      ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
+    }
+    return ret;
+  }
+  /**
+   * creates new database and connects to it
+   */
+  async createDatabase(name, options) {
+    name ??= this.config.get('dbName');
+    const sql = this.helper.getCreateDatabaseSQL(name);
+    if (sql) {
+      await this.execute(sql);
+    }
+    this.config.set('dbName', name);
+    await this.driver.reconnect(options);
+  }
+  async dropDatabase(name) {
+    name ??= this.config.get('dbName');
+    this.config.set('dbName', this.helper.getManagementDbName());
+    await this.driver.reconnect();
+    await this.execute(this.helper.getDropDatabaseSQL(name));
+    this.config.set('dbName', name);
+  }
+  async execute(sql, options = {}) {
+    options.wrap ??= false;
+    const lines = this.wrapSchema(sql, options).split('\n');
+    const groups = [];
+    let i = 0;
+    for (const line of lines) {
+      if (line.trim() === '') {
+        if (groups[i]?.length > 0) {
+          i++;
+        }
+        continue;
+      }
+      groups[i] ??= [];
+      groups[i].push(line.trim());
+    }
+    if (groups.length === 0) {
+      return;
+    }
+    if (this.platform.supportsMultipleStatements()) {
+      for (const group of groups) {
+        const query = group.join('\n');
+        await this.driver.execute(query);
+      }
+      return;
+    }
+    const statements = groups.flatMap(group => {
+      return group
+        .join('\n')
+        .split(';\n')
+        .map(s => s.trim())
+        .filter(s => s);
+    });
+    await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
+  }
+  async dropTableIfExists(name, schema) {
+    const sql = this.helper.dropTableIfExists(name, schema);
+    return this.execute(sql);
+  }
+  wrapSchema(sql, options) {
+    const array = Utils.asArray(sql);
+    if (array.length === 0) {
+      return '';
+    }
+    if (array[array.length - 1] === '') {
+      array.pop();
+    }
+    if (options.wrap === false) {
+      return array.join('\n') + '\n';
+    }
+    let ret = this.helper.getSchemaBeginning(this.config.get('charset'), this.options.disableForeignKeys);
+    ret += array.join('\n') + '\n';
+    ret += this.helper.getSchemaEnd(this.options.disableForeignKeys);
+    return ret;
+  }
+  append(array, sql, pad) {
+    return this.helper.append(array, sql, pad);
+  }
+  matchName(name, nameToMatch) {
+    return typeof nameToMatch === 'string'
+      ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+      : nameToMatch.test(name);
+  }
+  isTableSkipped(tableName, schemaName) {
+    const skipTables = this.options.skipTables;
+    if (!skipTables || skipTables.length === 0) {
+      return false;
+    }
+    const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+    return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
+  }
+  /**
+   * Sorts views by their dependencies so that views depending on other views are created after their dependencies.
+   * Uses topological sort based on view definition string matching.
+   */
+  sortViewsByDependencies(views) {
+    if (views.length <= 1) {
+      return views;
+    }
+    // Use CommitOrderCalculator for topological sort
+    const calc = new CommitOrderCalculator();
+    // Map views to numeric indices for the calculator
+    const viewToIndex = new Map();
+    const indexToView = new Map();
+    for (let i = 0; i < views.length; i++) {
+      viewToIndex.set(views[i], i);
+      indexToView.set(i, views[i]);
+      calc.addNode(i);
+    }
+    // Check each view's definition for references to other view names
+    for (const view of views) {
+      const definition = view.definition.toLowerCase();
+      const viewIndex = viewToIndex.get(view);
+      for (const otherView of views) {
+        if (otherView === view) {
+          continue;
+        }
+        // Check if the definition references the other view's name
+        // Use word boundary matching to avoid false positives
+        const patterns = [new RegExp(`\\b${this.escapeRegExp(otherView.name.toLowerCase())}\\b`)];
+        if (otherView.schema) {
+          patterns.push(
+            new RegExp(`\\b${this.escapeRegExp(`${otherView.schema}.${otherView.name}`.toLowerCase())}\\b`),
+          );
+        }
+        for (const pattern of patterns) {
+          if (pattern.test(definition)) {
+            // view depends on otherView, so otherView must come first
+            // addDependency(from, to) puts `from` before `to` in result
+            const otherIndex = viewToIndex.get(otherView);
+            calc.addDependency(otherIndex, viewIndex, 1);
+            break;
+          }
+        }
+      }
     }
-    escapeRegExp(string) {
-        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Sort and map back to views
+    return calc.sort().map(index => indexToView.get(index));
+  }
+  appendViewCreation(ret, view) {
+    if (view.materialized) {
+      this.append(
+        ret,
+        this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true),
+      );
+      // Skip indexes for WITH NO DATA views — they have no data to index yet.
+      // Indexes will be created on the next schema:update after REFRESH populates data.
+      if (view.withData !== false) {
+        const viewName = this.helper.getTableName(view.name, view.schema);
+        for (const index of view.indexes ?? []) {
+          this.append(ret, this.helper.getCreateIndexSQL(viewName, index));
+        }
+      }
+    } else {
+      this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
     }
+  }
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
 }
 // for back compatibility
 export { SqlSchemaGenerator as SchemaGenerator };