@mikro-orm/knex 7.0.0-dev.9 → 7.0.0-dev.91

package/query/raw.d.ts

@@ -0,0 +1,59 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
+import type { SelectQueryBuilder } from 'kysely';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function raw<T extends object = any, R = any>(sql: SelectQueryBuilder<any, any, any> | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;

package/query/raw.js

@@ -0,0 +1,68 @@
+import { raw as raw_, Utils } from '@mikro-orm/core';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function raw(sql, params) {
+    if (Utils.isObject(sql) && 'compile' in sql) {
+        const query = sql.compile();
+        return raw_(query.sql, query.parameters);
+    }
+    if (sql instanceof QueryBuilder) {
+        const query = sql.toQuery();
+        return raw_(query.sql, query.params);
+    }
+    return raw_(sql, params);
+}

package/query/rawKnex.d.ts

@@ -0,0 +1,58 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function rawKnex<T extends object = any, R = any>(sql: QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;

package/query/rawKnex.js

@@ -0,0 +1,72 @@
+import { raw } from '@mikro-orm/core';
+// import type { Knex } from 'knex';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function rawKnex(sql, params) {
+    // export function rawKnex<T extends object = any, R = any>(sql: Knex.QueryBuilder | Knex.Raw | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R> {
+    // if (Utils.isObject<Knex.QueryBuilder | Knex.Raw>(sql) && 'toSQL' in sql) {
+    //   const query = sql.toSQL();
+    //   return raw(query.sql, query.bindings);
+    // }
+    if (sql instanceof QueryBuilder) {
+        // FIXME this should live in the `knex` compat package, while what we have now should live in `sql` package
+        // @ts-ignore
+        const query = sql.toQuery()._sql;
+        return raw(query.sql, query.bindings);
+    }
+    return raw(sql, params);
+}

package/schema/DatabaseSchema.js

@@ -1,4 +1,4 @@
-import { ReferenceKind } from '@mikro-orm/core';
+import { ReferenceKind, RawQueryFragment, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 /**
  * @internal
@@ -69,6 +69,7 @@ export class DatabaseSchema {
     static fromMetadata(metadata, platform, config, schemaName) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
+        const skipColumns = config.get('schemaGenerator').skipColumns || {};
         for (const meta of metadata) {
             for (const prop of meta.props) {
                 if (prop.nativeEnumName) {
@@ -97,7 +98,7 @@ export class DatabaseSchema {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
             for (const prop of meta.props) {
-                if (!this.shouldHaveColumn(meta, prop)) {
+                if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
                 }
                 table.addColumnFromProperty(prop, meta, config);
@@ -107,9 +108,14 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).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);
+                }
                 table.addCheck({
                     name: check.name,
-                    expression: check.expression,
+                    expression,
                     definition: `check (${check.expression})`,
                     columnName,
                 });
@@ -129,10 +135,25 @@ export class DatabaseSchema {
         return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
             !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
     }
-    static shouldHaveColumn(meta, prop) {
+    static shouldHaveColumn(meta, prop, skipColumns) {
         if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
+        // Check if column should be skipped
+        if (skipColumns) {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema;
+            const fullTableName = tableSchema ? `${tableSchema}.${tableName}` : tableName;
+            // Check for skipColumns by table name or fully qualified table name
+            const columnsToSkip = skipColumns[tableName] || skipColumns[fullTableName];
+            if (columnsToSkip) {
+                for (const fieldName of prop.fieldNames) {
+                    if (columnsToSkip.some(pattern => this.matchName(fieldName, pattern))) {
+                        return false;
+                    }
+                }
+            }
+        }
         if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
             return true;
         }

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type IndexCallback, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper.js';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
@@ -54,12 +54,13 @@ export declare class DatabaseTable {
     private getPropertyTypeForForeignKey;
     private getPropertyTypeForColumn;
     private getPropertyDefaultValue;
+    private processIndexExpression;
     addIndex(meta: EntityMetadata, index: {
-        properties: string | string[];
+        properties?: string | string[];
         name?: string;
         type?: string;
-        expression?: string;
-        deferMode?: DeferMode;
+        expression?: string | IndexCallback<any>;
+        deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;

package/schema/DatabaseTable.js

@@ -1,4 +1,4 @@
-import { Cascade, DecimalType, EntitySchema, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
+import { Cascade, DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
 /**
  * @internal
  */
@@ -63,7 +63,7 @@ export class DatabaseTable {
             const mappedType = this.platform.getMappedType(type);
             if (mappedType instanceof DecimalType) {
                 const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
-                /* v8 ignore next 5 */
+                /* v8 ignore next */
                 if (match) {
                     prop.precision ??= +match[1];
                     prop.scale ??= +match[2];
@@ -91,7 +91,7 @@ export class DatabaseTable {
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.nativeEnumName || prop.items?.every(Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(i => typeof i === 'string') ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
@@ -104,37 +104,39 @@ export class DatabaseTable {
             this.columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
+            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('.')) {
                 schema = undefined;
             }
-            this.foreignKeys[constraintName] = {
-                constraintName,
-                columnNames: prop.fieldNames,
-                localTableName: this.getShortestName(false),
-                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';
+            if (prop.createForeignKeyConstraint) {
+                this.foreignKeys[constraintName] = {
+                    constraintName,
+                    columnNames: prop.fieldNames,
+                    localTableName: this.getShortestName(false),
+                    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';
+                    }
+                }
+                if (prop.deferMode) {
+                    this.foreignKeys[constraintName].deferMode = prop.deferMode;
                 }
-            }
-            if (prop.deferMode) {
-                this.foreignKeys[constraintName].deferMode = prop.deferMode;
             }
         }
         if (prop.index) {
@@ -160,7 +162,7 @@ export class DatabaseTable {
         }
     }
     getIndexName(value, columnNames, type) {
-        if (Utils.isString(value)) {
+        if (typeof value === 'string') {
             return value;
         }
         return this.platform.getIndexName(this.name, columnNames, type);
@@ -613,7 +615,7 @@ export class DatabaseTable {
             fkOptions.deferMode = fk.deferMode;
             fkOptions.columnTypes = fk.columnNames.map(col => this.getColumn(col).type);
         }
-        return {
+        const ret = {
             name: prop,
             type,
             runtimeType,
@@ -641,6 +643,11 @@ export class DatabaseTable {
             persist,
             ...fkOptions,
         };
+        const nativeEnumName = Object.keys(this.nativeEnums).find(name => name === column.type);
+        if (nativeEnumName) {
+            ret.nativeEnumName = nativeEnumName;
+        }
+        return ret;
     }
     getReferenceKind(fk, unique) {
         if (fk && unique) {
@@ -674,10 +681,17 @@ export class DatabaseTable {
         if (fk) {
             return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
+        const enumMode = this.platform.getConfig().get('entityGenerator').enumMode;
         // If this column is using an enum.
         if (column.enumItems?.length) {
-            // We will create a new enum name for this type and set it as the property type as well.
-            return namingStrategy.getEnumClassName(column.name, this.name, this.schema);
+            const name = column.nativeEnumName ?? column.name;
+            const tableName = column.nativeEnumName ? undefined : this.name;
+            if (enumMode === 'ts-enum') {
+                // We will create a new enum name for this type and set it as the property type as well.
+                return namingStrategy.getEnumClassName(name, tableName, this.schema);
+            }
+            // With other enum strategies, we need to use the type name.
+            return namingStrategy.getEnumTypeName(name, tableName, this.schema);
         }
         return column.mappedType?.runtimeType ?? 'unknown';
     }
@@ -700,6 +714,23 @@ export class DatabaseTable {
         }
         return '' + val;
     }
+    processIndexExpression(indexName, expression, meta) {
+        if (expression instanceof Function) {
+            const table = {
+                name: this.name,
+                schema: this.schema,
+                toString() {
+                    if (this.schema) {
+                        return `${this.schema}.${this.name}`;
+                    }
+                    return this.name;
+                },
+            };
+            const exp = expression(table, meta.createColumnMappingObject(), indexName);
+            return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+        }
+        return expression;
+    }
     addIndex(meta, index, type) {
         const properties = Utils.unique(Utils.flatten(Utils.asArray(index.properties).map(prop => {
             const parts = prop.split('.');
@@ -741,7 +772,7 @@ export class DatabaseTable {
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: index.expression,
+            expression: this.processIndexExpression(name, index.expression, meta),
             options: index.options,
             deferMode: index.deferMode,
         });

package/schema/SchemaComparator.js

@@ -1,5 +1,4 @@
-import { inspect } from 'node:util';
-import { ArrayType, BooleanType, DateTimeType, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { ArrayType, BooleanType, DateTimeType, JsonType, parseJsonSafe, Utils, inspect, } from '@mikro-orm/core';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -269,7 +268,7 @@ export class SchemaComparator {
         }
         for (const toConstraint of Object.values(toForeignKeys)) {
             tableDifferences.addedForeignKeys[toConstraint.constraintName] = toConstraint;
-            this.log(`FK constraint ${toConstraint.constraintName} added from table ${tableDifferences.name}`, { constraint: toConstraint });
+            this.log(`FK constraint ${toConstraint.constraintName} added to table ${tableDifferences.name}`, { constraint: toConstraint });
             changes++;
         }
         return changes ? tableDifferences : false;
@@ -308,7 +307,7 @@ export class SchemaComparator {
             const [removedColumn, addedColumn] = candidateColumns[0];
             const removedColumnName = removedColumn.name;
             const addedColumnName = addedColumn.name;
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (tableDifferences.renamedColumns[removedColumnName]) {
                 continue;
             }
@@ -511,14 +510,14 @@ export class SchemaComparator {
             return str
                 ?.replace(/_\w+'(.*?)'/g, '$1')
                 .replace(/in\s*\((.*?)\)/ig, '= any (array[$1])')
-                .replace(/['"`()]|::\w+| +/g, '')
+                .replace(/['"`()\n[\]]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/ig, '$1')
                 .toLowerCase();
         };
         return simplify(expr1) !== simplify(expr2);
     }
     parseJsonDefault(defaultValue) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!defaultValue) {
             return null;
         }

package/schema/SchemaHelper.d.ts

@@ -63,6 +63,8 @@ export declare abstract class SchemaHelper {
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected processComment(comment: string): string;

package/schema/SchemaHelper.js

@@ -74,7 +74,7 @@ export class SchemaHelper {
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
     getCreateIndexSQL(tableName, index) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (index.expression) {
             return index.expression;
         }
@@ -119,9 +119,8 @@ export class SchemaHelper {
                 }
             }
             Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items, the values are case insensitive
-                itemsOld = itemsOld.map(v => v.toLowerCase());
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
                 if (enumName.includes('.')) {
                     const [enumSchemaName, rawEnumName] = enumName.split('.');
                     ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld)));
@@ -142,7 +141,7 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.dropConstraint(diff.name, check.name));
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!safe && Object.values(diff.removedColumns).length > 0) {
             ret.push(this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
         }
@@ -225,7 +224,7 @@ export class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     castColumn(name, type) {
         return '';
     }
@@ -264,7 +263,12 @@ export class SchemaHelper {
         if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        if (useDefault) {
+            // https://dev.mysql.com/doc/refman/9.0/en/data-type-defaults.html
+            const needsExpression = ['blob', 'text', 'json', 'point', 'linestring', 'polygon', 'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection'].some(type => column.type.toLowerCase().startsWith(type));
+            const defaultSql = needsExpression && !column.default.startsWith('(') ? `(${column.default})` : column.default;
+            col.push(`default ${defaultSql}`);
+        }
         Utils.runIfNotEmpty(() => col.push(column.extra), column.extra);
         Utils.runIfNotEmpty(() => col.push(`comment ${this.platform.quoteValue(column.comment)}`), column.comment);
         return col.join(' ');
@@ -337,11 +341,11 @@ export class SchemaHelper {
     getDropDatabaseSQL(name) {
         return `drop database if exists ${this.quote(name)}`;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     getCreateNamespaceSQL(name) {
         return `create schema if not exists ${this.quote(name)}`;
     }
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     getDropNamespaceSQL(name) {
         return `drop schema if exists ${this.quote(name)}`;
     }
@@ -463,7 +467,7 @@ export class SchemaHelper {
     getReferencedTableName(referencedTableName, schema) {
         const [schemaName, tableName] = this.splitTableName(referencedTableName);
         schema = schemaName ?? schema ?? this.platform.getConfig().get('schema');
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }