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

package/schema/DatabaseSchema.d.ts

@@ -1,6 +1,7 @@
 import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
+import type { DatabaseView } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -9,6 +10,7 @@ export declare class DatabaseSchema {
     private readonly platform;
     readonly name: string;
     private tables;
+    private views;
     private namespaces;
     private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
@@ -16,6 +18,10 @@ export declare class DatabaseSchema {
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
+    addView(name: string, schema: string | undefined | null, definition: string, materialized?: boolean, withData?: boolean): DatabaseView;
+    getViews(): DatabaseView[];
+    getView(name: string): DatabaseView | undefined;
+    hasView(name: string): boolean;
     setNativeEnums(nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -34,10 +40,17 @@ export declare class DatabaseSchema {
     hasNamespace(namespace: string): boolean;
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[]): Promise<DatabaseSchema>;
-    static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[]): Promise<DatabaseSchema>;
+    static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
+    private static getViewDefinition;
     private static getSchemaName;
+    /**
+     * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
+     * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
+     */
+    private static addTPTForeignKey;
     private static matchName;
+    private static isNameAllowed;
     private static isTableNameAllowed;
     private static shouldHaveColumn;
     toJSON(): Dictionary;

package/schema/DatabaseSchema.js

@@ -1,4 +1,4 @@
-import { ReferenceKind, RawQueryFragment, } from '@mikro-orm/core';
+import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 /**
  * @internal
@@ -7,6 +7,7 @@ export class DatabaseSchema {
     platform;
     name;
     tables = [];
+    views = [];
     namespaces = new Set();
     nativeEnums = {}; // for postgres
     constructor(platform, name) {
@@ -33,6 +34,24 @@ export class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
+    addView(name, schema, definition, materialized, withData) {
+        const namespaceName = schema ?? this.name;
+        const view = { name, schema: namespaceName, definition, materialized, withData };
+        this.views.push(view);
+        if (namespaceName != null) {
+            this.namespaces.add(namespaceName);
+        }
+        return view;
+    }
+    getViews() {
+        return this.views;
+    }
+    getView(name) {
+        return this.views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
+    }
+    hasView(name) {
+        return !!this.getView(name);
+    }
     setNativeEnums(nativeEnums) {
         this.nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
@@ -56,21 +75,35 @@ export class DatabaseSchema {
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
-        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const allTables = await platform.getSchemaHelper().getAllTables(connection, schemas);
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
         const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
         await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        // Load views from database
+        await platform.getSchemaHelper().loadViews(schema, connection);
+        // Load materialized views (PostgreSQL only)
+        if (platform.supportsMaterializedViews()) {
+            await platform.getSchemaHelper().loadMaterializedViews(schema, connection, schemaName);
+        }
+        // Filter out skipped views
+        if (skipViews && skipViews.length > 0) {
+            schema.views = schema.views.filter(v => this.isNameAllowed(v.name, skipViews));
+        }
         return schema;
     }
-    static fromMetadata(metadata, platform, config, schemaName) {
+    static fromMetadata(metadata, platform, config, schemaName, em) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
         const skipColumns = config.get('schemaGenerator').skipColumns || {};
         for (const meta of metadata) {
+            // Skip view entities when collecting native enums
+            if (meta.view) {
+                continue;
+            }
             for (const prop of meta.props) {
                 if (prop.nativeEnumName) {
                     let key = prop.nativeEnumName;
@@ -95,45 +128,134 @@ export class DatabaseSchema {
         }
         schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {
+            // Handle view entities separately
+            if (meta.view) {
+                const viewDefinition = this.getViewDefinition(meta, em, platform);
+                if (viewDefinition) {
+                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                }
+                continue;
+            }
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
-            for (const prop of meta.props) {
+            // For TPT child entities, only use ownProps (properties defined in this entity only)
+            // For all other entities (including TPT root), use all props
+            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps
+                ? meta.ownProps
+                : meta.props;
+            for (const prop of propsToProcess) {
                 if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
                 }
                 table.addColumnFromProperty(prop, meta, config);
             }
+            // For TPT child entities, always include the PK columns (they form the FK to parent)
+            if (meta.inheritanceType === 'tpt' && meta.tptParent) {
+                const pkProps = meta.primaryKeys.map(pk => meta.properties[pk]);
+                for (const pkProp of pkProps) {
+                    // Only add if not already added (it might be in ownProps if defined in this entity)
+                    if (!propsToProcess.includes(pkProp)) {
+                        table.addColumnFromProperty(pkProp, meta, config);
+                    }
+                    // Child PK must not be autoincrement — it references the parent PK via FK
+                    for (const field of pkProp.fieldNames) {
+                        const col = table.getColumn(field);
+                        if (col) {
+                            col.autoincrement = false;
+                        }
+                    }
+                }
+                // Add FK from child PK to parent PK with ON DELETE CASCADE
+                this.addTPTForeignKey(table, meta, config, platform);
+            }
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
-            table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
+            // For TPT child entities, the PK is also defined here
+            const pkPropsForIndex = meta.inheritanceType === 'tpt' && meta.tptParent
+                ? meta.primaryKeys.map(pk => meta.properties[pk])
+                : meta.props.filter(prop => prop.primary);
+            table.addIndex(meta, { properties: pkPropsForIndex.map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
-                let expression = check.expression;
-                const raw = RawQueryFragment.getKnownFragment(expression);
-                if (raw) {
-                    expression = platform.formatQuery(raw.sql, raw.params);
-                }
+                const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
-                    definition: `check (${check.expression})`,
+                    definition: `check (${expression})`,
                     columnName,
                 });
             }
         }
         return schema;
     }
+    static getViewDefinition(meta, em, platform) {
+        if (typeof meta.expression === 'string') {
+            return meta.expression;
+        }
+        // Expression is a function, need to evaluate it
+        /* v8 ignore next */
+        if (!em) {
+            return undefined;
+        }
+        const result = meta.expression(em, {}, {});
+        // Async expressions are not supported for view entities
+        if (result && typeof result.then === 'function') {
+            throw new Error(`View entity ${meta.className} expression returned a Promise. Async expressions are not supported for view entities.`);
+        }
+        /* v8 ignore next */
+        if (typeof result === 'string') {
+            return result;
+        }
+        /* v8 ignore next */
+        if (isRaw(result)) {
+            return platform.formatQuery(result.sql, result.params);
+        }
+        // Check if it's a QueryBuilder (has getFormattedQuery method)
+        if (result && typeof result.getFormattedQuery === 'function') {
+            return result.getFormattedQuery();
+        }
+        /* v8 ignore next - fallback for unknown result types */
+        return undefined;
+    }
     static getSchemaName(meta, config, schema) {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
+    /**
+     * Add a foreign key from a TPT child entity's PK to its parent entity's PK.
+     * This FK uses ON DELETE CASCADE to ensure child rows are deleted when parent is deleted.
+     */
+    static addTPTForeignKey(table, meta, config, platform) {
+        const parent = meta.tptParent;
+        const pkColumnNames = meta.primaryKeys.flatMap(pk => meta.properties[pk].fieldNames);
+        const parentPkColumnNames = parent.primaryKeys.flatMap(pk => parent.properties[pk].fieldNames);
+        // Determine the parent table name with schema
+        const parentSchema = parent.schema === '*' ? undefined : parent.schema ?? config.get('schema', platform.getDefaultSchemaName());
+        const parentTableName = parentSchema ? `${parentSchema}.${parent.tableName}` : parent.tableName;
+        // Create FK constraint name
+        const constraintName = platform.getIndexName(table.name, pkColumnNames, 'foreign');
+        // Add the foreign key to the table
+        const fks = table.getForeignKeys();
+        fks[constraintName] = {
+            constraintName,
+            columnNames: pkColumnNames,
+            localTableName: table.getShortestName(false),
+            referencedColumnNames: parentPkColumnNames,
+            referencedTableName: parentTableName,
+            deleteRule: 'cascade', // TPT always uses cascade delete
+            updateRule: 'cascade', // TPT always uses cascade update
+        };
+    }
     static matchName(name, nameToMatch) {
         return typeof nameToMatch === 'string'
             ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
             : nameToMatch.test(name);
     }
+    static isNameAllowed(name, skipNames) {
+        return !(skipNames?.some(pattern => this.matchName(name, pattern)) ?? false);
+    }
     static isTableNameAllowed(tableName, takeTables, skipTables) {
         return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
-            !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
+            this.isNameAllowed(tableName, skipTables));
     }
     static shouldHaveColumn(meta, prop, skipColumns) {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
@@ -175,9 +297,15 @@ export class DatabaseSchema {
                 || table.schema === schema // specified schema matches the table's one
                 || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
         });
-        // remove namespaces of ignored tables
+        this.views = this.views.filter(view => {
+            /* v8 ignore next */
+            return (!schema && !hasWildcardSchema)
+                || view.schema === schema
+                || (!schema && !wildcardSchemaTables.includes(view.name));
+        });
+        // remove namespaces of ignored tables and views
         for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+            if (!this.tables.some(t => t.schema === ns) && !this.views.some(v => v.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
                 this.namespaces.delete(ns);
             }
         }

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

@@ -1,4 +1,4 @@
-import { Cascade, DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
+import { DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
 /**
  * @internal
  */
@@ -80,7 +80,7 @@ export class DatabaseTable {
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
-                generated: prop.generated,
+                generated: prop.generated instanceof RawQueryFragment ? this.platform.formatQuery(prop.generated.sql, prop.generated.params) : prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ?? (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
@@ -103,7 +103,7 @@ export class DatabaseTable {
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
@@ -117,23 +117,9 @@ export class DatabaseTable {
                     referencedColumnNames: prop.referencedColumnNames,
                     referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
                 };
-                const cascade = prop.cascade.includes(Cascade.REMOVE) || prop.cascade.includes(Cascade.ALL);
-                if (prop.deleteRule || cascade || prop.nullable) {
-                    this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
-                }
-                if (prop.updateRule) {
-                    this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
-                }
-                if ((prop.cascade.includes(Cascade.PERSIST) || prop.cascade.includes(Cascade.ALL))) {
-                    const hasCascadePath = Object.values(this.foreignKeys).some(fk => {
-                        return fk.constraintName !== constraintName
-                            && ((fk.updateRule && fk.updateRule !== 'no action') || (fk.deleteRule && fk.deleteRule !== 'no action'))
-                            && fk.referencedTableName === this.foreignKeys[constraintName].referencedTableName;
-                    });
-                    if (!hasCascadePath || this.platform.supportsMultipleCascadePaths()) {
-                        this.foreignKeys[constraintName].updateRule ??= 'cascade';
-                    }
-                }
+                const schemaConfig = config.get('schemaGenerator');
+                this.foreignKeys[constraintName].deleteRule = prop.deleteRule ?? schemaConfig.defaultDeleteRule;
+                this.foreignKeys[constraintName].updateRule = prop.updateRule ?? schemaConfig.defaultUpdateRule;
                 if (prop.deferMode) {
                     this.foreignKeys[constraintName].deferMode = prop.deferMode;
                 }
@@ -181,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);
@@ -495,11 +508,19 @@ export class DatabaseTable {
             // Use the column name as a base for the FK prop.
             return columnName;
         }
-        if (!fks.some(fk => fk !== currentFk && fk.referencedTableName === currentFk.referencedTableName) && !this.getColumn(currentFk.referencedTableName)) {
-            // FK is the only one in this table that references this other table.
+        // Strip schema prefix from referenced table name (e.g., "public.fr_usuario" -> "fr_usuario")
+        const getTableName = (fullName) => {
+            const parts = fullName.split('.');
+            return parts[parts.length - 1];
+        };
+        const referencedTableName = getTableName(currentFk.referencedTableName);
+        // Check for conflicts using stripped table names (handles cross-schema FKs to same-named tables)
+        const hasConflictingFk = fks.some(fk => fk !== currentFk && getTableName(fk.referencedTableName) === referencedTableName);
+        if (!hasConflictingFk && !this.getColumn(referencedTableName)) {
+            // FK is the only one in this table that references a table with this name.
             // The name of the referenced table is not shared with a column in this table,
             // so it is safe to output prop name based on the referenced entity.
-            return currentFk.referencedTableName;
+            return referencedTableName;
         }
         // Any ambiguous FK is rendered with a name based on the FK constraint name
         let finalPropBaseName = currentFk.constraintName;
@@ -716,22 +737,24 @@ export class DatabaseTable {
     }
     processIndexExpression(indexName, expression, meta) {
         if (expression instanceof Function) {
+            const qualifiedName = this.schema ? `${this.schema}.${this.name}` : this.name;
             const table = {
                 name: this.name,
                 schema: this.schema,
-                toString() {
-                    if (this.schema) {
-                        return `${this.schema}.${this.name}`;
-                    }
-                    return this.name;
-                },
+                qualifiedName,
+                toString: () => qualifiedName,
             };
-            const exp = expression(table, meta.createColumnMappingObject(), indexName);
+            const columns = meta.createSchemaColumnMappingObject();
+            const exp = expression(columns, table, indexName);
             return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
         }
         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];
@@ -763,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,
@@ -775,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;