@mikro-orm/sql 7.0.0-dev.230 → 7.0.0-dev.232

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -21,6 +21,15 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    /**
+     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
+     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     */
+    protected getIndexColumns(index: IndexDef): string;
+    /**
+     * Append MySQL-specific index suffixes like INVISIBLE.
+     */
+    protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
     getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -72,7 +72,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
     }
     async getAllIndexes(connection, tables) {
-        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name /*!80013 , expression as expression */
+        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, index_type as index_type, sub_part as sub_part, collation as sort_order /*!80013 , expression as expression, is_visible as is_visible */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
@@ -87,6 +87,26 @@ export class MySqlSchemaHelper extends SchemaHelper {
                 primary: index.index_name === 'PRIMARY',
                 constraint: !index.non_unique,
             };
+            // Capture column options (prefix length, sort order)
+            if (index.sub_part != null || index.sort_order === 'D') {
+                indexDef.columns = [{
+                        name: index.column_name,
+                        ...(index.sub_part != null && { length: index.sub_part }),
+                        ...(index.sort_order === 'D' && { sort: 'DESC' }),
+                    }];
+            }
+            // Capture index type for fulltext and spatial indexes
+            if (index.index_type === 'FULLTEXT') {
+                indexDef.type = 'fulltext';
+            }
+            else if (index.index_type === 'SPATIAL') {
+                /* v8 ignore next */
+                indexDef.type = 'spatial';
+            }
+            // Capture invisible flag (MySQL 8.0.13+)
+            if (index.is_visible === 'NO') {
+                indexDef.invisible = true;
+            }
             if (!index.column_name || index.expression?.match(/ where /i)) {
                 indexDef.expression = index.expression; // required for the `getCreateIndexSQL()` call
                 indexDef.expression = this.getCreateIndexSQL(index.table_name, indexDef, !!index.expression);
@@ -106,17 +126,66 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
-        const sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
+        let sql = `alter table ${tableName} add ${index.unique ? 'unique' : 'index'} ${keyName} `;
         if (index.expression && partialExpression) {
-            return `${sql}(${index.expression})`;
+            sql += `(${index.expression})`;
+            return this.appendMySqlIndexSuffix(sql, index);
         }
         // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
         if (index.columnNames.some(column => column.includes('.'))) {
             const columns = this.platform.getJsonIndexDefinition(index);
-            const sql = `alter table ${tableName} add ${index.unique ? 'unique ' : ''}index ${keyName} `;
-            return `${sql}(${columns.join(', ')})`;
+            sql = `alter table ${tableName} add ${index.unique ? 'unique ' : ''}index ${keyName} `;
+            sql += `(${columns.join(', ')})`;
+            return this.appendMySqlIndexSuffix(sql, index);
+        }
+        // Build column list with advanced options
+        const columns = this.getIndexColumns(index);
+        sql += `(${columns})`;
+        return this.appendMySqlIndexSuffix(sql, index);
+    }
+    /**
+     * Build the column list for a MySQL index, with MySQL-specific handling for collation.
+     * MySQL requires collation to be specified as an expression: (column_name COLLATE collation_name)
+     */
+    getIndexColumns(index) {
+        if (index.columns?.length) {
+            return index.columns.map(col => {
+                const quotedName = this.quote(col.name);
+                // MySQL supports collation via expression: (column_name COLLATE collation_name)
+                // When collation is specified, wrap in parentheses as an expression
+                if (col.collation) {
+                    let expr = col.length ? `${quotedName}(${col.length})` : quotedName;
+                    expr = `(${expr} collate ${col.collation})`;
+                    // Sort order comes after the expression
+                    if (col.sort) {
+                        expr += ` ${col.sort}`;
+                    }
+                    return expr;
+                }
+                // Standard column definition without collation
+                let colDef = quotedName;
+                // MySQL supports prefix length
+                if (col.length) {
+                    colDef += `(${col.length})`;
+                }
+                // MySQL supports sort order
+                if (col.sort) {
+                    colDef += ` ${col.sort}`;
+                }
+                return colDef;
+            }).join(', ');
         }
-        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+        return index.columnNames.map(c => this.quote(c)).join(', ');
+    }
+    /**
+     * Append MySQL-specific index suffixes like INVISIBLE.
+     */
+    appendMySqlIndexSuffix(sql, index) {
+        // MySQL 8.0+ supports INVISIBLE indexes
+        if (index.invisible) {
+            sql += ' invisible';
+        }
+        return sql;
     }
     async getAllColumns(connection, tables) {
         const sql = `select table_name as table_name,

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -29,6 +29,20 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     private getIgnoredNamespacesConditionSQL;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    /**
+     * Parses column definitions from the full CREATE INDEX expression.
+     * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
+     * we extract them from the full expression instead.
+     *
+     * We use columnDefs (from individual pg_get_indexdef calls) as the source
+     * of column names, and find their modifiers in the expression.
+     */
+    private parseIndexColumnsFromExpression;
+    /**
+     * Extracts the content inside parentheses starting at the given position.
+     * Handles nested parentheses correctly.
+     */
+    private extractParenthesizedContent;
     getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, nativeEnums?: Dictionary<{
         name: string;
         schema?: string;
@@ -62,6 +76,14 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
     dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    /**
+     * Build the column list for a PostgreSQL index.
+     */
+    protected getIndexColumns(index: IndexDef): string;
+    /**
+     * PostgreSQL-specific index options like fill factor.
+     */
+    protected getCreateIndexSuffix(index: IndexDef): string;
     private getIndexesSQL;
     private getChecksSQL;
     inferLengthFromColumnType(type: string): number | undefined;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -128,15 +128,31 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
+            // Extract INCLUDE columns from expression first, to filter them from key columns
+            const includeMatch = index.expression?.match(/include\s*\(([^)]+)\)/i);
+            const includeColumns = includeMatch
+                ? includeMatch[1].split(',').map((col) => unquote(col.trim()))
+                : [];
+            // Filter out INCLUDE columns from the column definitions to get only key columns
+            const keyColumnDefs = index.index_def.filter((col) => !includeColumns.includes(unquote(col)));
+            // Parse sort order and NULLS ordering from the full expression
+            // pg_get_indexdef individual columns don't include sort modifiers, so we parse from full expression
+            const columns = this.parseIndexColumnsFromExpression(index.expression, keyColumnDefs, unquote);
+            const columnNames = columns.map(col => col.name);
+            const hasAdvancedColumnOptions = columns.some(col => col.sort || col.nulls || col.collation);
             const indexDef = {
-                columnNames: index.index_def.map((name) => unquote(name)),
-                composite: index.index_def.length > 1,
+                columnNames,
+                composite: columnNames.length > 1,
                 // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
                 constraint: index.contype === 'u',
                 keyName: index.constraint_name,
                 unique: index.unique,
                 primary: index.primary,
             };
+            // Add columns array if there are advanced options
+            if (hasAdvancedColumnOptions) {
+                indexDef.columns = columns;
+            }
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
@@ -146,11 +162,91 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.deferrable) {
                 indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
+            // Extract fillFactor from reloptions
+            if (index.reloptions) {
+                const fillFactorMatch = index.reloptions.find((opt) => opt.startsWith('fillfactor='));
+                if (fillFactorMatch) {
+                    indexDef.fillFactor = parseInt(fillFactorMatch.split('=')[1], 10);
+                }
+            }
+            // Add INCLUDE columns (already extracted above)
+            if (includeColumns.length > 0) {
+                indexDef.include = includeColumns;
+            }
+            // Add index type if not btree (the default)
+            if (index.index_type && index.index_type !== 'btree') {
+                indexDef.type = index.index_type;
+            }
             ret[key] ??= [];
             ret[key].push(indexDef);
         }
         return ret;
     }
+    /**
+     * Parses column definitions from the full CREATE INDEX expression.
+     * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
+     * we extract them from the full expression instead.
+     *
+     * We use columnDefs (from individual pg_get_indexdef calls) as the source
+     * of column names, and find their modifiers in the expression.
+     */
+    parseIndexColumnsFromExpression(expression, columnDefs, unquote) {
+        // Extract just the column list from the expression (between first parens after USING)
+        // Pattern: ... USING method (...columns...) [INCLUDE (...)] [WHERE ...]
+        // Note: pg_get_indexdef always returns a valid expression with USING clause
+        const usingMatch = expression.match(/using\s+\w+\s*\(/i);
+        const startIdx = usingMatch.index + usingMatch[0].length - 1; // Position of opening (
+        const columnsStr = this.extractParenthesizedContent(expression, startIdx);
+        // Use the column names from columnDefs and find their modifiers in the expression
+        return columnDefs.map(colDef => {
+            const name = unquote(colDef);
+            const result = { name };
+            // Find this column in the expression and extract modifiers
+            // Create a pattern that matches the column name (quoted or unquoted) followed by modifiers
+            const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const colPattern = new RegExp(`"?${escapedName}"?\\s*([^,)]*?)(?:,|$)`, 'i');
+            const colMatch = columnsStr.match(colPattern);
+            if (colMatch) {
+                const modifiers = colMatch[1];
+                // Extract sort order (PostgreSQL omits ASC in output as it's the default)
+                if (/\bdesc\b/i.test(modifiers)) {
+                    result.sort = 'DESC';
+                }
+                // Extract NULLS ordering
+                const nullsMatch = modifiers.match(/nulls\s+(first|last)/i);
+                if (nullsMatch) {
+                    result.nulls = nullsMatch[1].toUpperCase();
+                }
+                // Extract collation
+                const collateMatch = modifiers.match(/collate\s+"?([^"\s,)]+)"?/i);
+                if (collateMatch) {
+                    result.collation = collateMatch[1];
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Extracts the content inside parentheses starting at the given position.
+     * Handles nested parentheses correctly.
+     */
+    extractParenthesizedContent(str, startIdx) {
+        let depth = 0;
+        const start = startIdx + 1;
+        for (let i = startIdx; i < str.length; i++) {
+            if (str[i] === '(') {
+                depth++;
+            }
+            else if (str[i] === ')') {
+                depth--;
+                if (depth === 0) {
+                    return str.slice(start, i);
+                }
+            }
+        }
+        /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
+        return '';
+    }
     async getAllColumns(connection, tablesBySchemas, nativeEnums) {
         const sql = `select table_schema as schema_name, table_name, column_name,
       column_default,
@@ -486,7 +582,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
         const value = to.comment ? this.platform.quoteValue(to.comment) : 'null';
-        return `comment on column ${name}."${to.name}" is ${value}`;
+        return `comment on column ${name}.${this.quote(to.name)} is ${value}`;
     }
     alterTableComment(table, comment) {
         return `comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(comment ?? '')}`;
@@ -522,7 +618,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `select 1 from pg_database where datname = '${name}'`;
     }
     getDatabaseNotExistsError(dbName) {
-        return `database "${dbName}" does not exist`;
+        return `database ${this.quote(dbName)} does not exist`;
     }
     getManagementDbName() {
         return this.platform.getConfig().get('schemaGenerator', {}).managementDbName ?? 'postgres';
@@ -544,6 +640,43 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return `drop index ${this.quote(oldIndexName)}`;
     }
+    /**
+     * Build the column list for a PostgreSQL index.
+     */
+    getIndexColumns(index) {
+        if (index.columns?.length) {
+            return index.columns.map(col => {
+                let colDef = this.quote(col.name);
+                // PostgreSQL supports collation with double quotes
+                if (col.collation) {
+                    colDef += ` collate ${this.quote(col.collation)}`;
+                }
+                // PostgreSQL supports sort order
+                if (col.sort) {
+                    colDef += ` ${col.sort}`;
+                }
+                // PostgreSQL supports NULLS FIRST/LAST
+                if (col.nulls) {
+                    colDef += ` nulls ${col.nulls}`;
+                }
+                return colDef;
+            }).join(', ');
+        }
+        return index.columnNames.map(c => this.quote(c)).join(', ');
+    }
+    /**
+     * PostgreSQL-specific index options like fill factor.
+     */
+    getCreateIndexSuffix(index) {
+        const withOptions = [];
+        if (index.fillFactor != null) {
+            withOptions.push(`fillfactor = ${index.fillFactor}`);
+        }
+        if (withOptions.length > 0) {
+            return ` with (${withOptions.join(', ')})`;
+        }
+        return super.getCreateIndexSuffix(index);
+    }
     getIndexesSQL(tables) {
         return `select indrelid::regclass as table_name, ns.nspname as schema_name, relname as constraint_name, idx.indisunique as unique, idx.indisprimary as primary, contype, condeferrable, condeferred,
       array(
@@ -553,10 +686,13 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       ) as index_def,
       pg_get_indexdef(idx.indexrelid) as expression,
       c.condeferrable as deferrable,
-      c.condeferred as initially_deferred
+      c.condeferred as initially_deferred,
+      i.reloptions,
+      am.amname as index_type
       from pg_index idx
       join pg_class as i on i.oid = idx.indexrelid
       join pg_namespace as ns on i.relnamespace = ns.oid
+      join pg_am as am on am.oid = i.relam
       left join pg_constraint as c on c.conname = i.relname
       where indrelid in (${tables.map(t => `${this.platform.quoteValue(`${this.quote(t.schema_name)}.${this.quote(t.table_name)}`)}::regclass`).join(', ')})
       order by relname`;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -211,7 +211,8 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const columns = this.platform.getJsonIndexDefinition(index);
             return `${sqlPrefix} (${columns.join(', ')})`;
         }
-        return `${sqlPrefix} (${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+        // Use getIndexColumns to support advanced options like sort order and collation
+        return `${sqlPrefix} (${this.getIndexColumns(index)})`;
     }
     parseTableDefinition(sql, cols) {
         const columns = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.230",
+  "version": "7.0.0-dev.232",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.230"
+    "@mikro-orm/core": "7.0.0-dev.232"
   }
 }

package/schema/DatabaseTable.d.ts

@@ -62,6 +62,18 @@ export declare class DatabaseTable {
         expression?: string | IndexCallback<any>;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
+        columns?: {
+            name: string;
+            sort?: 'ASC' | 'DESC' | 'asc' | 'desc';
+            nulls?: 'FIRST' | 'LAST' | 'first' | 'last';
+            length?: number;
+            collation?: string;
+        }[];
+        include?: string | string[];
+        fillFactor?: number;
+        invisible?: boolean;
+        disabled?: boolean;
+        clustered?: boolean;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;
     toJSON(): Dictionary;

package/schema/DatabaseTable.js

@@ -167,13 +167,40 @@ export class DatabaseTable {
             )
             // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
             && !(index.columnNames.some(col => !col) && !index.expression));
+        // Helper to map column name to property name
+        const columnToPropertyName = (colName) => this.getPropertyName(namingStrategy, colName);
         for (const index of potentiallyUnmappedIndexes) {
+            // Build the index/unique options object with advanced options
             const ret = {
                 name: index.keyName,
                 deferMode: index.deferMode,
                 expression: index.expression,
+                // Advanced index options - convert column names to property names
+                columns: index.columns?.map(col => ({
+                    ...col,
+                    name: columnToPropertyName(col.name),
+                })),
+                include: index.include?.map(colName => columnToPropertyName(colName)),
+                fillFactor: index.fillFactor,
+                disabled: index.disabled,
             };
-            const isTrivial = !index.deferMode && !index.expression;
+            // Index-only options (not valid for Unique)
+            if (!index.unique) {
+                if (index.type) {
+                    // Convert index type - IndexDef.type can be string or object, IndexOptions.type is just string
+                    ret.type = typeof index.type === 'string' ? index.type : index.type.indexType;
+                }
+                if (index.invisible) {
+                    ret.invisible = index.invisible;
+                }
+                if (index.clustered) {
+                    ret.clustered = index.clustered;
+                }
+            }
+            // An index is trivial if it has no special options that require entity-level declaration
+            const hasAdvancedOptions = index.columns?.length || index.include?.length || index.fillFactor ||
+                index.type || index.invisible || index.disabled || index.clustered;
+            const isTrivial = !index.deferMode && !index.expression && !hasAdvancedOptions;
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
                 const fkForIndex = fkIndexes.get(index);
@@ -724,6 +751,10 @@ export class DatabaseTable {
         return expression;
     }
     addIndex(meta, index, type) {
+        // If columns are specified but properties are not, derive properties from column names
+        if (index.columns?.length && !index.expression && (!index.properties || Utils.asArray(index.properties).length === 0)) {
+            index = { ...index, properties: index.columns.map(c => c.name) };
+        }
         const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
             const parts = prop.split('.');
             const root = parts[0];
@@ -755,6 +786,37 @@ export class DatabaseTable {
             return;
         }
         const name = this.getIndexName(index.name, properties, type);
+        // Process include columns (map property names to field names)
+        const includeColumns = index.include ? Utils.unique(Utils.flatten(Utils.asArray(index.include).map(prop => {
+            if (meta.properties[prop]) {
+                return meta.properties[prop].fieldNames;
+            }
+            /* v8 ignore next */
+            return [prop];
+        }))) : undefined;
+        // Process columns with advanced options (map property names to field names)
+        const columns = index.columns?.map(col => {
+            const fieldName = meta.properties[col.name]?.fieldNames[0] ?? col.name;
+            return {
+                name: fieldName,
+                sort: col.sort?.toUpperCase(),
+                nulls: col.nulls?.toUpperCase(),
+                length: col.length,
+                collation: col.collation,
+            };
+        });
+        // Validate that column options reference fields in the index properties
+        if (columns?.length && properties.length > 0) {
+            for (const col of columns) {
+                if (!properties.includes(col.name)) {
+                    throw new Error(`Index '${name}' on entity '${meta.className}': column option references field '${col.name}' which is not in the index properties`);
+                }
+            }
+        }
+        // Validate fillFactor range
+        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 '${name}' on entity '${meta.className}'`);
+        }
         this.indexes.push({
             keyName: name,
             columnNames: properties,
@@ -767,6 +829,12 @@ export class DatabaseTable {
             expression: this.processIndexExpression(name, index.expression, meta),
             options: index.options,
             deferMode: index.deferMode,
+            columns,
+            include: includeColumns,
+            fillFactor: index.fillFactor,
+            invisible: index.invisible,
+            disabled: index.disabled,
+            clustered: index.clustered,
         });
     }
     addCheck(check) {

package/schema/SchemaComparator.d.ts

@@ -50,6 +50,14 @@ export declare class SchemaComparator {
      * Checks if the other index already fulfills all the indexing and constraint needs of the current one.
      */
     isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
+    /**
+     * Compare advanced column options between two indexes.
+     */
+    private compareIndexColumns;
+    /**
+     * Compare two arrays for equality (order matters).
+     */
+    private compareArrays;
     diffExpression(expr1: string, expr2: string): boolean;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     hasSameDefaultValue(from: Column, to: Column): boolean;

package/schema/SchemaComparator.js

@@ -517,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
@@ -529,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)

package/schema/SchemaHelper.d.ts

@@ -27,6 +27,15 @@ export declare abstract class SchemaHelper {
     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[];