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

package/schema/SchemaComparator.js

@@ -1,4 +1,4 @@
-import { ArrayType, BooleanType, DateTimeType, JsonType, parseJsonSafe, Utils, inspect, } from '@mikro-orm/core';
+import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -23,6 +23,9 @@ export class SchemaComparator {
             newTables: {},
             removedTables: {},
             changedTables: {},
+            newViews: {},
+            changedViews: {},
+            removedViews: {},
             orphanedForeignKeys: [],
             newNativeEnums: [],
             removedNativeEnums: [],
@@ -109,6 +112,29 @@ export class SchemaComparator {
                 }
             }
         }
+        // Compare views
+        for (const toView of toSchema.getViews()) {
+            const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
+            if (!fromSchema.hasView(toView.name) && !fromSchema.hasView(viewName)) {
+                diff.newViews[viewName] = toView;
+                this.log(`view ${viewName} added`);
+            }
+            else {
+                const fromView = fromSchema.getView(toView.name) ?? fromSchema.getView(viewName);
+                if (fromView && this.diffExpression(fromView.definition, toView.definition)) {
+                    diff.changedViews[viewName] = { from: fromView, to: toView };
+                    this.log(`view ${viewName} changed`);
+                }
+            }
+        }
+        // Check for removed views
+        for (const fromView of fromSchema.getViews()) {
+            const viewName = fromView.schema ? `${fromView.schema}.${fromView.name}` : fromView.name;
+            if (!toSchema.hasView(fromView.name) && !toSchema.hasView(viewName)) {
+                diff.removedViews[viewName] = fromView;
+                this.log(`view ${viewName} removed`);
+            }
+        }
         return diff;
     }
     /**
@@ -491,6 +517,30 @@ export class SchemaComparator {
         if (!spansColumns()) {
             return false;
         }
+        // Compare advanced column options (sort order, nulls, length, collation)
+        if (!this.compareIndexColumns(index1, index2)) {
+            return false;
+        }
+        // Compare INCLUDE columns for covering indexes
+        if (!this.compareArrays(index1.include, index2.include)) {
+            return false;
+        }
+        // Compare fill factor
+        if (index1.fillFactor !== index2.fillFactor) {
+            return false;
+        }
+        // Compare invisible flag
+        if (!!index1.invisible !== !!index2.invisible) {
+            return false;
+        }
+        // Compare disabled flag
+        if (!!index1.disabled !== !!index2.disabled) {
+            return false;
+        }
+        // Compare clustered flag
+        if (!!index1.clustered !== !!index2.clustered) {
+            return false;
+        }
         if (!index1.unique && !index1.primary) {
             // this is a special case: If the current key is neither primary or unique, any unique or
             // primary key will always have the same effect for the index and there cannot be any constraint
@@ -503,6 +553,58 @@ export class SchemaComparator {
         }
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
+    /**
+     * Compare advanced column options between two indexes.
+     */
+    compareIndexColumns(index1, index2) {
+        const cols1 = index1.columns ?? [];
+        const cols2 = index2.columns ?? [];
+        // If neither has column options, they match
+        if (cols1.length === 0 && cols2.length === 0) {
+            return true;
+        }
+        // If only one has column options, they don't match
+        if (cols1.length !== cols2.length) {
+            return false;
+        }
+        // Compare each column's options
+        // Note: We don't check c1.name !== c2.name because the indexes already have matching columnNames
+        // and the columns array is derived from those same column names
+        for (let i = 0; i < cols1.length; i++) {
+            const c1 = cols1[i];
+            const c2 = cols2[i];
+            const sort1 = c1.sort?.toUpperCase() ?? 'ASC';
+            const sort2 = c2.sort?.toUpperCase() ?? 'ASC';
+            if (sort1 !== sort2) {
+                return false;
+            }
+            const defaultNulls = (s) => s === 'DESC' ? 'FIRST' : 'LAST';
+            const nulls1 = c1.nulls?.toUpperCase() ?? defaultNulls(sort1);
+            const nulls2 = c2.nulls?.toUpperCase() ?? defaultNulls(sort2);
+            if (nulls1 !== nulls2) {
+                return false;
+            }
+            if (c1.length !== c2.length) {
+                return false;
+            }
+            if (c1.collation !== c2.collation) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Compare two arrays for equality (order matters).
+     */
+    compareArrays(arr1, arr2) {
+        if (!arr1 && !arr2) {
+            return true;
+        }
+        if (!arr1 || !arr2 || arr1.length !== arr2.length) {
+            return false;
+        }
+        return arr1.every((val, i) => val === arr2[i]);
+    }
     diffExpression(expr1, expr2) {
         // expressions like check constraints might be normalized by the driver,
         // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
@@ -510,9 +612,30 @@ export class SchemaComparator {
             return str
                 ?.replace(/_\w+'(.*?)'/g, '$1')
                 .replace(/in\s*\((.*?)\)/ig, '= any (array[$1])')
-                .replace(/['"`()\n[\]]|::\w+| +/g, '')
+                // MySQL normalizes count(*) to count(0)
+                .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // Remove quotes first so we can process identifiers
+                .replace(/['"`]/g, '')
+                // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
+                // Strip these prefixes - match word.word patterns and keep only the last part
+                .replace(/\b\w+\.(\w+)/g, '$1')
+                // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
+                .replace(/\binner\s+join\b/gi, 'join')
+                // Remove redundant column aliases like `title AS title` -> `title`
+                .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
+                // Remove AS keyword (optional in SQL, MySQL may add/remove it)
+                .replace(/\bas\b/gi, '')
+                // Remove remaining special chars, parentheses, type casts, asterisks, and normalize whitespace
+                .replace(/[()\n[\]*]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/ig, '$1')
-                .toLowerCase();
+                .toLowerCase()
+                // PostgreSQL adds default aliases to aggregate functions (e.g., count(*) AS count)
+                // After removing AS and whitespace, this results in duplicate adjacent words
+                // Remove these duplicates: "countcount" -> "count", "minmin" -> "min"
+                // Use lookahead to match repeated patterns of 3+ chars (avoid false positives on short sequences)
+                .replace(/(\w{3,})\1/g, '$1')
+                // Remove trailing semicolon (PostgreSQL adds it to view definitions)
+                .replace(/;$/, '');
         };
         return simplify(expr1) !== simplify(expr2);
     }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary, RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
@@ -21,9 +21,21 @@ export declare abstract class SchemaHelper {
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
-    getListTablesSQL(schemaName?: string): string;
+    getListTablesSQL(): string;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    /**
+     * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
+     */
+    protected getCreateIndexSuffix(_index: IndexDef): string;
+    /**
+     * Build the column list for an index, supporting advanced options like sort order, nulls ordering, and collation.
+     * Note: Prefix length is only supported by MySQL/MariaDB which override this method.
+     */
+    protected getIndexColumns(index: IndexDef): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
     alterTable(diff: TableDifference, safe?: boolean): string[];
@@ -39,7 +51,7 @@ export declare abstract class SchemaHelper {
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
-    normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
+    normalizeDefaultValue(defaultValue: string | RawQueryFragment, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
     getCreateNamespaceSQL(name: string): string;
@@ -61,11 +73,15 @@ export declare abstract class SchemaHelper {
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
     get options(): {
         disableForeignKeys?: boolean;
+        disableForeignKeysForClear?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
         skipTables?: (string | RegExp)[];
+        skipViews?: (string | RegExp)[];
         skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
+        defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
+        defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
     };
     protected processComment(comment: string): string;
     protected quote(...keys: (string | undefined)[]): string;
@@ -73,4 +89,11 @@ export declare abstract class SchemaHelper {
     dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
     dropConstraint(table: string, name: string): string;
     dropTableIfExists(name: string, schema?: string): string;
+    createView(name: string, schema: string | undefined, definition: string): string;
+    dropViewIfExists(name: string, schema?: string): string;
+    createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+    dropMaterializedViewIfExists(name: string, schema?: string): string;
+    refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
+    getListMaterializedViewsSQL(): string;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
 }

package/schema/SchemaHelper.js

@@ -62,7 +62,16 @@ export class SchemaHelper {
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
-    getListTablesSQL(schemaName) {
+    getListTablesSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    async getAllTables(connection, schemas) {
+        return connection.execute(this.getListTablesSQL());
+    }
+    getListViewsSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    async loadViews(schema, connection, schemaName) {
         throw new Error('Not supported by given driver');
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
@@ -78,20 +87,61 @@ export class SchemaHelper {
         if (index.expression) {
             return index.expression;
         }
+        if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
+            throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${index.keyName}'`);
+        }
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
-        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
         if (index.unique && index.constraint) {
-            sql = `alter table ${tableName} add constraint ${keyName} unique `;
+            sql = `alter table ${tableName} add constraint ${keyName} unique`;
         }
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sql}(${columns.join(', ')})${defer}`;
+            return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${defer}`;
+        }
+        // Build column list with advanced options
+        const columns = this.getIndexColumns(index);
+        sql += ` (${columns})`;
+        // Add INCLUDE clause for covering indexes (PostgreSQL, MSSQL)
+        if (index.include?.length) {
+            sql += ` include (${index.include.map(c => this.quote(c)).join(', ')})`;
         }
-        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})${defer}`;
+        return sql + this.getCreateIndexSuffix(index) + defer;
+    }
+    /**
+     * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
+     */
+    getCreateIndexSuffix(_index) {
+        return '';
+    }
+    /**
+     * Build the column list for an index, supporting advanced options like sort order, nulls ordering, and collation.
+     * Note: Prefix length is only supported by MySQL/MariaDB which override this method.
+     */
+    getIndexColumns(index) {
+        if (index.columns?.length) {
+            return index.columns.map(col => {
+                let colDef = this.quote(col.name);
+                // Collation comes after column name (SQLite syntax: column COLLATE name)
+                if (col.collation) {
+                    colDef += ` collate ${col.collation}`;
+                }
+                // Sort order
+                if (col.sort) {
+                    colDef += ` ${col.sort}`;
+                }
+                // NULLS ordering (PostgreSQL)
+                if (col.nulls) {
+                    colDef += ` nulls ${col.nulls}`;
+                }
+                return colDef;
+            }).join(', ');
+        }
+        return index.columnNames.map(c => this.quote(c)).join(', ');
     }
     getDropIndexSQL(tableName, index) {
         return `drop index ${this.quote(index.keyName)}`;
@@ -289,8 +339,20 @@ export class SchemaHelper {
         const map = {};
         indexes.forEach(index => {
             if (map[index.keyName]) {
-                map[index.keyName].composite = true;
-                map[index.keyName].columnNames.push(index.columnNames[0]);
+                if (index.columnNames.length > 0) {
+                    map[index.keyName].composite = true;
+                    map[index.keyName].columnNames.push(index.columnNames[0]);
+                }
+                // Merge columns array for advanced column options (sort, length, collation, etc.)
+                if (index.columns?.length) {
+                    map[index.keyName].columns ??= [];
+                    map[index.keyName].columns.push(index.columns[0]);
+                }
+                // Merge INCLUDE columns
+                if (index.include?.length) {
+                    map[index.keyName].include ??= [];
+                    map[index.keyName].include.push(index.include[0]);
+                }
             }
             else {
                 map[index.keyName] = index;
@@ -323,9 +385,8 @@ export class SchemaHelper {
         if (defaultValue == null) {
             return defaultValue;
         }
-        const raw = RawQueryFragment.getKnownFragment(defaultValue);
-        if (raw) {
-            return this.platform.formatQuery(raw.sql, raw.params);
+        if (defaultValue instanceof RawQueryFragment) {
+            return this.platform.formatQuery(defaultValue.sql, defaultValue.params);
         }
         const genericValue = defaultValue.replace(/\(\d+\)/, '(?)').toLowerCase();
         const norm = defaultValues[genericValue];
@@ -542,4 +603,30 @@ export class SchemaHelper {
         }
         return sql;
     }
+    createView(name, schema, definition) {
+        const viewName = this.quote(this.getTableName(name, schema));
+        return `create view ${viewName} as ${definition}`;
+    }
+    dropViewIfExists(name, schema) {
+        let sql = `drop view if exists ${this.quote(this.getTableName(name, schema))}`;
+        if (this.platform.usesCascadeStatement()) {
+            sql += ' cascade';
+        }
+        return sql;
+    }
+    createMaterializedView(name, schema, definition, withData = true) {
+        throw new Error('Not supported by given driver');
+    }
+    dropMaterializedViewIfExists(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    refreshMaterializedView(name, schema, concurrently = false) {
+        throw new Error('Not supported by given driver');
+    }
+    getListMaterializedViewsSQL() {
+        throw new Error('Not supported by given driver');
+    }
+    async loadMaterializedViews(schema, connection, schemaName) {
+        throw new Error('Not supported by given driver');
+    }
 }

package/schema/SqlSchemaGenerator.d.ts

@@ -6,11 +6,15 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     protected readonly helper: import("./SchemaHelper.js").SchemaHelper;
     protected readonly options: {
         disableForeignKeys?: boolean;
+        disableForeignKeysForClear?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
         skipTables?: (string | RegExp)[];
+        skipViews?: (string | RegExp)[];
         skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
+        defaultUpdateRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
+        defaultDeleteRule?: "cascade" | "no action" | "set null" | "set default" | "restrict";
     };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
@@ -61,5 +65,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private append;
     private matchName;
     private isTableSkipped;
+    /**
+     * 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.
+     */
+    private sortViewsByDependencies;
+    private escapeRegExp;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -1,4 +1,4 @@
-import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, CommitOrderCalculator, Utils, } from '@mikro-orm/core';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import { SchemaComparator } from './SchemaComparator.js';
 export class SqlSchemaGenerator extends AbstractSchemaGenerator {
@@ -45,7 +45,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     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);
+        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
     }
     getOrderedMetadata(schema) {
         const metadata = super.getOrderedMetadata(schema);
@@ -87,6 +87,17 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, fks, true);
             }
         }
+        // Create views after tables (views may depend on tables)
+        // Sort views by dependencies (views depending on other views come later)
+        const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
+        for (const view of sortedViews) {
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
+        }
         return this.wrapSchema(ret, options);
     }
     async drop(options = {}) {
@@ -111,15 +122,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         if (options?.truncate === false) {
             return super.clear(options);
         }
-        await this.execute(this.helper.disableForeignKeysSQL());
+        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()) {
-            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+            await this.driver.createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
                 .withSchema(schema)
                 .truncate()
                 .execute();
         }
-        await this.execute(this.helper.enableForeignKeysSQL());
+        if (this.options.disableForeignKeysForClear) {
+            await this.execute(this.helper.enableForeignKeysSQL());
+        }
         if (options?.clearIdentityMap ?? true) {
             this.clearIdentityMap();
         }
@@ -128,8 +143,20 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         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);
+        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)) {
@@ -196,8 +223,8 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         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));
-        const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
+        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 };
@@ -217,6 +244,31 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 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);
@@ -272,6 +324,28 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, sql);
             }
         }
+        // Create new views after all table changes are done
+        // Sort views by dependencies (views depending on other views come later)
+        const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
+        for (const view of sortedNewViews) {
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
+        }
+        // Recreate changed views (also sorted by dependencies)
+        const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
+        const sortedChangedViews = this.sortViewsByDependencies(changedViews);
+        for (const view of sortedChangedViews) {
+            if (view.materialized) {
+                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            }
+            else {
+                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+            }
+        }
         return this.wrapSchema(ret, options);
     }
     /**
@@ -332,7 +406,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             }
             return;
         }
-        await Utils.runSerial(groups.flat(), line => this.driver.execute(line));
+        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);
@@ -370,6 +447,57 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         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));
+    }
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
 }
 // for back compatibility
 export { SqlSchemaGenerator as SchemaGenerator };