@mikro-orm/sql 7.3.0-dev.1 → 7.3.0-dev.11

package/AbstractSqlDriver.js

@@ -850,9 +850,13 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 props.forEach(prop => {
                     // For STI with conflicting fieldNames, use discriminator to determine which field gets value
                     if (prop.stiFieldNames && prop.stiFieldNameMap && meta.discriminatorColumn) {
-                        const activeField = prop.stiFieldNameMap[row[meta.discriminatorColumn]];
+                        // the map misses subtypes whose props were not initialized yet during discovery (root column owner, grandchildren)
+                        const discriminator = row[meta.discriminatorColumn];
+                        const childClass = meta.discriminatorMap?.[discriminator];
+                        const activeField = prop.stiFieldNameMap[discriminator] ??
+                            (childClass && this.metadata.find(childClass)?.properties[prop.name]?.fieldNames[0]);
                         for (const field of prop.stiFieldNames) {
-                            params.push(field === activeField ? row[prop.name] : null);
+                            params.push(field === activeField ? (row[prop.name] ?? null) : null);
                             keys.push('?');
                         }
                         return;
@@ -1809,7 +1813,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (!this.platform.shouldHaveColumn(prop, populate, exclude)) {
             return false;
         }
-        if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
+        if (!fields ||
+            fields.includes('*') ||
+            prop.primary ||
+            meta.root.discriminatorColumn === prop.name ||
+            meta.root.targetKeys?.includes(prop.name)) {
             return true;
         }
         return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
@@ -1865,11 +1873,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         const tptMeta = this.metadata.get(targetMeta.class);
                         this.addTPTPolymorphicJoinsForRelation(qb, tptMeta, tableAlias, fields);
                     }
-                    if (ref) {
-                        // For filter :ref hints, schedule filter check for each target (no field selection)
-                        qb.scheduleFilterCheck(targetPath);
-                    }
-                    else {
+                    // target filters apply per target, both for filter :ref hints and populated relations
+                    qb.scheduleFilterCheck(targetPath);
+                    if (!ref) {
                         // Select fields from each target table
                         fields.push(...this.getFieldsForJoinedLoad(qb, targetMeta, {
                             ...options,
@@ -2469,6 +2475,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
             }
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
+                // `targetKey` values identify the entity like its PK, references resolve it by them
+                ret.push(...(meta.root.targetKeys ?? []).filter(key => meta.properties[key] && !options.fields.includes(key)));
             }
             if (meta.root.inheritanceType === 'sti' &&
                 !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {

package/SqlEntityManager.js

@@ -1,4 +1,4 @@
-import { EntityManager, raw, Utils, } from '@mikro-orm/core';
+import { EntityManager, QueryFlag, raw, Utils, } from '@mikro-orm/core';
 import { MikroKyselyPlugin } from './plugin/index.js';
 /**
  * @inheritDoc
@@ -87,6 +87,7 @@ export class SqlEntityManager extends EntityManager {
         // match `em.count()` semantics: an active transaction always wins over the requested connection type
         const connectionType = em.getTransactionContext() ? 'write' : options.connectionType;
         const qb = em.createQueryBuilder(meta.class, undefined, connectionType);
+        qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
         qb
             .select([...fields, raw('count(*) as cnt')])
             .where(where)

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -37,6 +37,7 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     getDefaultMappedType(type: string): Type<unknown>;
     isNumericColumn(mappedType: Type<unknown>): boolean;
     supportsUnsigned(): boolean;
+    supportsAutoincrementIncrement(): boolean;
     /** MySQL/MariaDB identifier limit. */
     getMaxIdentifierLength(): number;
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -90,6 +90,9 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
     supportsUnsigned() {
         return true;
     }
+    supportsAutoincrementIncrement() {
+        return false;
+    }
     /** MySQL/MariaDB identifier limit. */
     getMaxIdentifierLength() {
         return 64;

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -20,6 +20,8 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
     getListViewsSQL(): string;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -42,12 +42,25 @@ export class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL() {
         return 'set foreign_key_checks = 1;';
     }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        return `alter table ${this.quote(this.getTableName(tableName, schemaName))} auto_increment = ${startWith}`;
+    }
+    getAddColumnsSQL(table, columns) {
+        const [sql, ...rest] = super.getAddColumnsSQL(table, columns);
+        const startWith = columns.find(column => column.autoincrement)?.sequence?.startWith;
+        // the table option numbers the existing rows of the added column from the declared start too
+        return [startWith != null ? `${sql}, auto_increment = ${startWith}` : sql, ...rest];
+    }
     finalizeTable(table, charset, collate) {
         let sql = ` default character set ${charset}`;
         if (collate) {
             sql += ` collate ${collate}`;
         }
         sql += ' engine = InnoDB';
+        const startWith = table.getColumns().find(column => column.autoincrement)?.sequence?.startWith;
+        if (startWith != null) {
+            sql += ` auto_increment = ${startWith}`;
+        }
         if (table.comment) {
             sql += ` comment = ${this.platform.quoteValue(table.comment)}`;
         }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -29,6 +29,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
     createTable(table: DatabaseTable, alter?: boolean): string[];
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
     dropMaterializedViewIfExists(name: string, schema?: string): string;
     refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
@@ -134,6 +135,7 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     castColumn(name: string, type: string): string;
     dropForeignKey(tableName: string, constraintName: string): string;
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     private getAlterColumnAutoincrement;
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     alterTableComment(table: DatabaseTable, comment?: string): string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -106,10 +106,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     }
     createTable(table, alter) {
         const partitioning = table.getPartitioning();
+        const [createTable, ...rest] = super.createTable(table, alter);
+        // `serial` columns can't declare sequence options inline, so alter the implicit sequence right after creating the table
+        const sequences = table
+            .getColumns()
+            .filter(column => column.autoincrement && !column.generated && this.getSequenceOptionsSQL(column))
+            .map(column => {
+            const sequence = `pg_get_serial_sequence(${this.platform.quoteValue(table.getQuotedName())}, ${this.platform.quoteValue(column.name)})`;
+            const { startWith = -1, incrementBy = 1 } = column.sequence;
+            // `alter sequence` keeps the ascending bounds of the serial, so a descending one gets the bounds and start of a fresh sequence
+            const options = incrementBy < 0
+                ? `no minvalue maxvalue ${Math.max(startWith, -1)} start with ${startWith} increment by ${incrementBy}`
+                : this.getSequenceOptionsSQL(column);
+            return `do $$ begin execute format('alter sequence %s ${options} restart', ${sequence}); end $$`;
+        });
         if (!partitioning) {
-            return super.createTable(table, alter);
+            return [createTable, ...sequences, ...rest];
         }
-        const [createTable, ...rest] = super.createTable(table, alter);
         const partitions = partitioning.partitions.map(partition => {
             const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
             return `create table ${partitionName} partition of ${table.getQuotedName()} ${partition.bound}`;
@@ -119,7 +132,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         // regex replacement tokens like `$$`, `$&`, or `$1` inside user-supplied expressions (e.g., a
         // callback that returns a dollar-quoted literal) are not interpreted as back-references.
         const spliced = `${createTable.slice(0, -1)} partition by ${partitioning.definition};`;
-        return [spliced, ...rest, ...partitions];
+        return [spliced, ...sequences, ...rest, ...partitions];
+    }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        const table = this.platform.quoteValue(this.quote(this.getTableName(tableName, schemaName)));
+        // `truncate … restart identity` goes back to the start the sequence was created with, which the metadata may not match
+        return `select setval(pg_get_serial_sequence(${table}, ${this.platform.quoteValue(columnName)}), ${startWith}, false)`;
     }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
@@ -389,11 +407,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       identity_generation,
       generation_expression,
       pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
-      coll.collname as collation_name
+      coll.collname as collation_name,
+      seq.seqstart as sequence_start,
+      seq.seqincrement as sequence_increment
       from information_schema.columns cols
       join pg_class pgc on cols.table_name = pgc.relname
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
       left join pg_collation coll on pga.attcollation = coll.oid and coll.collname <> 'default'
+      left join pg_sequence seq on seq.seqrelid = pg_get_serial_sequence(quote_ident(cols.table_schema) || '.' || quote_ident(cols.table_name), cols.column_name)::regclass
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
         const allColumns = await connection.execute(sql, [], 'all', ctx);
@@ -444,6 +465,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 default: str(this.normalizeDefaultValue(col.column_default, col.length)),
                 unsigned: increments,
                 autoincrement: increments,
+                sequence: increments ? this.getIntrospectedSequence(col.sequence_start, col.sequence_increment) : undefined,
                 generated: col.is_identity === 'YES'
                     ? col.identity_generation === 'BY DEFAULT'
                         ? 'by default as identity'
@@ -1032,11 +1054,15 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     columnType = this.quote(columnType);
                 }
             }
-            if (column.generated === 'by default as identity') {
-                columnType += ` generated ${column.generated}`;
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            const generated = sequenceOptions && /^(by default as )?identity$/.test(column.generated ?? '')
+                ? `${column.generated} (${sequenceOptions})`
+                : column.generated;
+            if (generated?.startsWith('by default as identity')) {
+                columnType += ` generated ${generated}`;
             }
-            else if (column.generated) {
-                columnType += ` generated always as ${column.generated}`;
+            else if (generated) {
+                columnType += ` generated always as ${generated}`;
             }
             col.push(columnType);
             Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
@@ -1193,14 +1219,50 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    getAddColumnsSQL(table, columns) {
+        const compositePK = table.getPrimaryKey()?.composite;
+        const before = [];
+        const after = [];
+        const adds = columns.map(column => {
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            if (!sequenceOptions || !column.autoincrement || column.generated) {
+                return column;
+            }
+            // a `serial` column numbers the existing rows right away, so expand it to a sequence created with the options upfront
+            const seqName = this.quote(this.getTableName(this.platform.getIndexName(table.name, [column.name], 'sequence'), table.schema));
+            before.push(`create sequence ${seqName} ${sequenceOptions}`);
+            after.push(`alter sequence ${seqName} owned by ${table.getQuotedName()}.${this.quote(column.name)}`);
+            // the expanded column has no inline `primary key`, which `alterTable` expects from an added autoincrement PK
+            if (column.primary && !compositePK && !this.hasNonDefaultPrimaryKeyName(table)) {
+                after.push(`alter table ${table.getQuotedName()} add primary key (${this.quote(column.name)})`);
+            }
+            return {
+                ...column,
+                type: column.mappedType.getColumnType({ autoincrement: false }, this.platform),
+                autoincrement: false,
+                nullable: false,
+                default: `nextval('${seqName}')`,
+            };
+        });
+        return [...before, ...super.getAddColumnsSQL(table, adds), ...after];
+    }
     getAlterColumnAutoincrement(tableName, column, schemaName) {
         const ret = [];
         /* v8 ignore next */
         const name = (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName;
         if (column.autoincrement) {
             const seqName = this.platform.getIndexName(tableName, [column.name], 'sequence');
-            ret.push(`create sequence if not exists ${this.quote(seqName)}`);
-            ret.push(`select setval('${seqName}', (select max(${this.quote(column.name)}) from ${this.quote(name)}))`);
+            const sequenceOptions = this.getSequenceOptionsSQL(column);
+            const { incrementBy = 1, startWith = incrementBy < 0 ? -1 : 1 } = column.sequence ?? {};
+            const lastValue = `(select ${incrementBy < 0 ? 'min' : 'max'}(${this.quote(column.name)}) from ${this.quote(name)})`;
+            ret.push(`create sequence if not exists ${this.quote(seqName)}${sequenceOptions ? ` ${sequenceOptions}` : ''}`);
+            if (sequenceOptions) {
+                // continue after the existing values, but never before the declared start
+                ret.push(`select setval('${seqName}', ${incrementBy < 0 ? 'least' : 'greatest'}(${lastValue} + ${incrementBy}, ${startWith}), false)`);
+            }
+            else {
+                ret.push(`select setval('${seqName}', ${lastValue})`);
+            }
             ret.push(`alter table ${this.quote(name)} alter column ${this.quote(column.name)} set default nextval('${seqName}')`);
         }
         return ret;

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -14,6 +14,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     usesReturningStatement(): boolean;
     usesEnumCheckConstraints(): boolean;
     supportsComments(): boolean;
+    supportsAutoincrementIncrement(): boolean;
     getCurrentTimestampSQL(length: number): string;
     getDateTimeTypeDeclarationSQL(column: {
         length: number;

package/dialects/sqlite/SqlitePlatform.js

@@ -26,6 +26,9 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     supportsComments() {
         return false;
     }
+    supportsAutoincrementIncrement() {
+        return false;
+    }
     getCurrentTimestampSQL(length) {
         return `(strftime('%s', 'now') * 1000)`;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -21,6 +21,7 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     getDropDatabaseSQL(name: string): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     createTable(table: DatabaseTable, alter?: boolean): string[];
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
     createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
     getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
     dropForeignKey(tableName: string, constraintName: string): string;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -144,6 +144,13 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         const ret = [];
         this.append(ret, sql);
+        const startWith = columns.find(column => column.autoincrement)?.sequence?.startWith;
+        if (startWith != null) {
+            // a table rebuild renames the counter row of the temp table over, so only seed it when missing
+            const sequenceTable = this.quote(this.getTableName('sqlite_sequence', table.schema));
+            const name = this.platform.quoteValue(table.name);
+            this.append(ret, `insert into ${sequenceTable} (name, seq) select ${name}, ${startWith - 1} where not exists (select 1 from ${sequenceTable} where name = ${name})`);
+        }
         for (const index of table.getIndexes()) {
             this.append(ret, this.createIndex(index, table));
         }
@@ -152,6 +159,12 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        const sequenceTable = this.quote(this.getTableName('sqlite_sequence', schemaName));
+        const name = this.platform.quoteValue(tableName);
+        // the counter row does not exist before the first insert when the table was created without `sequence`
+        return `delete from ${sequenceTable} where name = ${name};\ninsert into ${sequenceTable} (name, seq) values (${name}, ${startWith - 1})`;
+    }
     createTableColumn(column, table, _changedProperties) {
         const col = [this.quote(column.name)];
         const checks = table.getChecks();
@@ -499,7 +512,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (Utils.hasObjectKeys(diff.removedChecks) ||
             Utils.hasObjectKeys(diff.changedChecks) ||
             Utils.hasObjectKeys(diff.changedForeignKeys) ||
-            Utils.hasObjectKeys(diff.changedColumns)) {
+            Utils.hasObjectKeys(diff.changedColumns) ||
+            // sqlite can only add or change a primary key by rebuilding the table
+            [...Object.values(diff.addedIndexes), ...Object.values(diff.changedIndexes)].some(index => index.primary)) {
             return this.getAlterTempTableSQL(diff);
         }
         for (const index of Object.values(diff.removedIndexes)) {
@@ -644,10 +659,11 @@ export class SqliteSchemaHelper extends SchemaHelper {
             first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
         ];
         const columns = [];
+        const renamedFrom = Object.fromEntries(Object.entries(changedTable.renamedColumns).map(([oldName, column]) => [column.name, oldName]));
         for (const column of changedTable.toTable.getColumns()) {
-            const fromColumn = changedTable.fromTable.getColumn(column.name);
-            if (fromColumn) {
-                columns.push(this.quote(column.name));
+            const fromName = renamedFrom[column.name] ?? column.name;
+            if (changedTable.fromTable.getColumn(fromName)) {
+                columns.push(this.quote(fromName));
             }
             else {
                 columns.push(`null as ${this.quote(column.name)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.1",
+  "version": "7.3.0-dev.11",
   "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.",
   "keywords": [
     "data-mapper",
@@ -50,10 +50,10 @@
     "kysely": "0.29.6"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.1"
+    "@mikro-orm/core": "^7.2.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.1"
+    "@mikro-orm/core": "7.3.0-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -92,6 +92,7 @@ export declare class MikroTransformer extends OperationNodeTransformer {
      * This is called for SELECT queries when columnNamingStrategy is 'property'
      */
     transformResult(rows: Record<string, any>[] | undefined, entityMap: Map<string, EntityMetadata>): Record<string, any>[] | undefined;
+    private getResultMaps;
     buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
     buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
     /**
@@ -108,6 +109,6 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row: Record<string, any>, fieldToPropertyMap: Record<string, EntityProperty>, relationFieldMap: Record<string, string>): Record<string, any>;
+    transformRow(row: Record<string, any>, fieldEntries: [string, EntityProperty][], relationEntries: [string, string][]): Record<string, any>;
     prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
 }

package/plugin/transformer.js

@@ -1,5 +1,12 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+/** Past this many query shapes the cache of one metadata storage starts over, so generated aliases cannot grow it. */
+const RESULT_MAPS_LIMIT = 1000;
+/**
+ * Result maps per query shape (the aliases and entities of its entity map). They are derived from metadata alone, so
+ * they are built once and shared by every transformer, as `getKysely()` creates a new one per call.
+ */
+const resultMapsCache = new WeakMap();
 const EXPANDABLE_KINDS = new Set([
     ReferenceKind.SCALAR,
     ReferenceKind.EMBEDDED,
@@ -884,12 +891,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (byEntity) {
             return byEntity;
         }
-        const allMetadata = Array.from(this.#metadata);
-        const byTable = allMetadata.find(m => m.tableName === name);
-        if (byTable) {
-            return byTable;
-        }
-        return undefined;
+        return this.#metadata.getByTableName(name);
     }
     /**
      * Transform result rows by mapping database column names to property names
@@ -906,11 +908,35 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (entityMap.size === 0) {
             return rows;
         }
-        // Build a global mapping from database field names to property objects
-        const fieldToPropertyMap = this.buildGlobalFieldMap(entityMap);
-        const relationFieldMap = this.buildGlobalRelationFieldMap(entityMap);
+        // The global mapping from database field names to property objects, built once per query shape
+        const { fields, relations } = this.getResultMaps(entityMap);
         // Transform each row
-        return rows.map(row => this.transformRow(row, fieldToPropertyMap, relationFieldMap));
+        return rows.map(row => this.transformRow(row, fields, relations));
+    }
+    getResultMaps(entityMap) {
+        let byShape = resultMapsCache.get(this.#metadata);
+        if (!byShape) {
+            byShape = new Map();
+            resultMapsCache.set(this.#metadata, byShape);
+        }
+        let shape = '';
+        for (const [alias, meta] of entityMap) {
+            shape += `${alias}\0${meta._id}\0`;
+        }
+        const cached = byShape.get(shape);
+        if (cached && Array.from(entityMap.values()).every((meta, i) => meta.props === cached.props[i])) {
+            return cached;
+        }
+        if (byShape.size >= RESULT_MAPS_LIMIT) {
+            byShape.clear();
+        }
+        const maps = {
+            props: Array.from(entityMap.values(), meta => meta.props),
+            fields: Object.entries(this.buildGlobalFieldMap(entityMap)),
+            relations: Object.entries(this.buildGlobalRelationFieldMap(entityMap)),
+        };
+        byShape.set(shape, maps);
+        return maps;
     }
     buildGlobalFieldMap(entityMap) {
         const map = {};
@@ -986,10 +1012,10 @@ export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Transform a single row by mapping column names to property names
      */
-    transformRow(row, fieldToPropertyMap, relationFieldMap) {
+    transformRow(row, fieldEntries, relationEntries) {
         const transformed = { ...row };
         // First pass: map regular fields from fieldName to propertyName and convert values
-        for (const [fieldName, prop] of Object.entries(fieldToPropertyMap)) {
+        for (const [fieldName, prop] of fieldEntries) {
             if (!(fieldName in transformed)) {
                 continue;
             }
@@ -1011,7 +1037,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         // Second pass: handle relation fields
         // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
         if (this.#options.columnNamingStrategy === 'property') {
-            for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
+            for (const [fieldName, relationPropertyName] of relationEntries) {
                 if (fieldName in transformed && !(relationPropertyName in transformed)) {
                     // Move the foreign key value to the relation property name
                     transformed[relationPropertyName] = transformed[fieldName];

package/query/CriteriaNode.d.ts

@@ -17,6 +17,8 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     index?: number;
     constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | RawQueryFragmentSymbol | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    /** Whether this node holds the condition for a single target of a polymorphic relation (e.g. `imageable[Article]`). */
+    isPolymorphicBranch(): boolean;
     unwrap(): any;
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;

package/query/CriteriaNode.js

@@ -1,4 +1,4 @@
-import { RawQueryFragment, ReferenceKind, Utils, inspect, } from '@mikro-orm/core';
+import { QueryHelper, RawQueryFragment, ReferenceKind, Utils, inspect, } from '@mikro-orm/core';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
  * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
@@ -28,7 +28,9 @@ export class CriteriaNode {
                 return;
             }
             for (const k of pks) {
-                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
+                const [name, target] = QueryHelper.splitPolymorphicKey(k);
+                this.prop = meta.props.find(prop => (prop.name === name && (!target || QueryHelper.findTargetMetas(prop, k).length > 0)) ||
+                    (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
                 if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
@@ -40,6 +42,10 @@ export class CriteriaNode {
     process(qb, options) {
         return this.payload;
     }
+    /** Whether this node holds the condition for a single target of a polymorphic relation (e.g. `imageable[Article]`). */
+    isPolymorphicBranch() {
+        return !!this.prop?.polymorphic && typeof this.key === 'string' && this.key.endsWith(']');
+    }
     unwrap() {
         return this.payload;
     }

package/query/CriteriaNodeFactory.js

@@ -1,4 +1,4 @@
-import { GroupOperator, isRaw, JsonType, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { GroupOperator, isRaw, JsonType, QueryHelper, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { ObjectCriteriaNode } from './ObjectCriteriaNode.js';
 import { ArrayCriteriaNode } from './ArrayCriteriaNode.js';
 import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
@@ -50,8 +50,9 @@ export class CriteriaNodeFactory {
     }
     static createObjectItemNode(metadata, entityName, node, payload, key, meta, validate = true) {
         const rawField = RawQueryFragment.isKnownFragmentSymbol(key);
-        const prop = rawField ? null : meta?.properties[key];
-        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.targetMeta.class : entityName;
+        const prop = rawField ? null : meta?.properties[QueryHelper.splitPolymorphicKey(key)[0]];
+        const target = rawField ? undefined : QueryHelper.findTargetMeta(prop, key);
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR && target ? target.class : entityName;
         const isNotEmbedded = rawField || prop?.kind !== ReferenceKind.EMBEDDED;
         const val = payload[key];
         if (isNotEmbedded && prop?.customType instanceof JsonType) {

package/query/ObjectCriteriaNode.d.ts

@@ -5,6 +5,8 @@ import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
  */
 export declare class ObjectCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    private processPolymorphicOrderBy;
     isStrict(): boolean;
     unwrap(): any;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;

package/query/ObjectCriteriaNode.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, GroupOperator, QueryFlag, QueryHelper, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { CriteriaNode } from './CriteriaNode.js';
 import { JoinType, QueryType } from './enums.js';
 const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
@@ -7,6 +7,10 @@ const COLLECTION_OPERATORS = ['$some', '$none', '$every', '$size', '$all'];
  */
 export class ObjectCriteriaNode extends CriteriaNode {
     process(qb, options) {
+        const targets = this.isPolymorphicBranch() ? QueryHelper.findTargetMetas(this.prop, this.key) : [];
+        if (options?.type === 'orderBy' && targets.length > 1) {
+            return this.processPolymorphicOrderBy(qb, targets, options);
+        }
         const matchPopulateJoins = options?.matchPopulateJoins ||
             (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
@@ -99,7 +103,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
             // with an exclusive condition on the join columns:
             // - if the owning column is null, the row is missing, we don't apply the filter
             // - if the target column is not null, the row is matched, we apply the filter
-            if (toOneProperty && this.prop.nullable && this.isStrict()) {
+            if (toOneProperty && this.prop.nullable && this.isStrict() && !this.isPolymorphicBranch()) {
                 const key = this.prop.owner ? this.prop.name : this.prop.referencedPKs;
                 qb.andWhere({
                     $or: [
@@ -109,7 +113,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 });
             }
         }
-        return keys.reduce((o, field) => {
+        const ret = keys.reduce((o, field) => {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, { ...options, alias: this.prop ? alias : ownerAlias });
             const operator = Utils.isOperator(field);
@@ -149,6 +153,31 @@ export class ObjectCriteriaNode extends CriteriaNode {
             }
             return o;
         }, {});
+        // the target is left joined, so its condition must only match rows that point to it
+        if (this.isPolymorphicBranch() && alias && options?.type !== 'orderBy') {
+            const pk = this.metadata.find(this.entityName).primaryKeys[0];
+            this.inlineCondition(`${alias}.${pk}`, ret, { $ne: null });
+        }
+        return ret;
+    }
+    /** Orders by the first non-null value of the property across the joined polymorphic targets. */
+    processPolymorphicOrderBy(qb, targets, options) {
+        const ownerAlias = options.alias || qb.alias;
+        const aliases = targets.map(target => {
+            const path = `${this.parent.getPath()}.${this.prop.name}[${target.className}]`;
+            const alias = qb.getAliasForJoinPath(path, { ...options, matchPopulateJoins: true });
+            if (alias) {
+                return alias;
+            }
+            const newAlias = qb.getNextAlias(target.class);
+            qb.addPolymorphicJoin(this.prop, target, ownerAlias, newAlias, JoinType.leftJoin, path);
+            return newAlias;
+        });
+        return Utils.getObjectQueryKeys(this.payload).reduce((o, field) => {
+            const columns = targets.map((target, i) => `${aliases[i]}.${target.properties[field].fieldNames[0]}`);
+            o[raw(`coalesce(${columns.map(() => '??').join(', ')})`, columns)] = this.payload[field].payload;
+            return o;
+        }, {});
     }
     isStrict() {
         return (this.strict ||
@@ -186,8 +215,9 @@ export class ObjectCriteriaNode extends CriteriaNode {
         const operator = Utils.isObject(payload) &&
             Utils.getObjectQueryKeys(payload).every(k => {
                 if (k === '$not' && Utils.isPlainObject(payload[k])) {
-                    // $not wrapping non-operator conditions (entity props) should be inlined
-                    return Utils.getObjectQueryKeys(payload[k]).every(ik => Utils.isOperator(ik, false));
+                    // $not wrapping non-operator conditions (entity props) or an empty one should be inlined
+                    const inner = Utils.getObjectQueryKeys(payload[k]);
+                    return inner.length > 0 && inner.every(ik => Utils.isOperator(ik, false));
                 }
                 return Utils.isOperator(k, false);
             });
@@ -211,16 +241,19 @@ export class ObjectCriteriaNode extends CriteriaNode {
         this.inlineCondition(key, obj, value);
     }
     inlineChildPayload(o, payload, field, alias, childAlias) {
-        const prop = this.metadata.find(this.entityName).properties[field];
+        const prop = this.payload[field].prop;
         for (const k of Utils.getObjectQueryKeys(payload)) {
             if (RawQueryFragment.isKnownFragmentSymbol(k)) {
                 o[k] = payload[k];
             }
             else if (k === '$not' &&
                 Utils.isPlainObject(payload[k]) &&
-                Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false))) {
-                // $not wraps entity conditions (from auto-join), inline at current level
-                this.inlineCondition(k, o, payload[k]);
+                (!Utils.hasObjectKeys(payload[k]) ||
+                    Utils.getObjectQueryKeys(payload[k]).some(ik => !Utils.isOperator(ik, false)))) {
+                // $not wraps entity conditions (from auto-join) or an empty one, inline at current level with the same key mapping
+                const inner = {};
+                this.inlineChildPayload(inner, payload[k], field, alias, childAlias);
+                this.inlineCondition(k, o, inner);
             }
             else if (Utils.isOperator(k, false)) {
                 const tmp = payload[k];
@@ -273,6 +306,10 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (keys.some(k => this.isCollectionOperator(k))) {
             return true;
         }
+        // the target's discriminator is checked in the join condition, so it is needed even for PK conditions
+        if (this.isPolymorphicBranch()) {
+            return !nestedAlias;
+        }
         const meta = this.metadata.find(this.entityName);
         const embeddable = this.prop.kind === ReferenceKind.EMBEDDED;
         const knownKey = [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE, ReferenceKind.EMBEDDED].includes(this.prop.kind) ||
@@ -291,6 +328,13 @@ export class ObjectCriteriaNode extends CriteriaNode {
             });
         const primaryKeys = knownKey &&
             keys.every(key => {
+                if (key === '$not') {
+                    // e.g. `{ author: { $not: { id: 1 } } }` compares the FK column, relation PKs still need the join
+                    const childPayload = this.payload[key].payload;
+                    return (Utils.isPlainObject(childPayload) &&
+                        Utils.getObjectQueryKeys(childPayload).every(k => meta.primaryKeys.includes(k) &&
+                            meta.properties[k].kind === ReferenceKind.SCALAR));
+                }
                 if (typeof key !== 'string' || !meta.primaryKeys.includes(key)) {
                     return false;
                 }
@@ -317,10 +361,16 @@ export class ObjectCriteriaNode extends CriteriaNode {
         if (this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator)) {
             qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
+        else if (this.isPolymorphicBranch()) {
+            const targetMeta = this.metadata.find(this.entityName);
+            qb.addPolymorphicJoin(this.prop, targetMeta, alias, nestedAlias, JoinType.leftJoin, path);
+        }
         else {
             const prev = qb.state.fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
-            const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
+            // ordering must not drop rows whose polymorphic relation points to another target
+            const orderByPolymorphic = this.prop.polymorphic && options?.type === 'orderBy';
+            const joinType = toOneProperty && !this.prop.nullable && !orderByPolymorphic ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
                 qb.state.fields = prev;

package/query/QueryBuilder.js

@@ -1032,9 +1032,11 @@ export class QueryBuilder {
      * @internal
      */
     addPolymorphicJoin(prop, targetMeta, ownerAlias, alias, type, path, schema) {
-        // Override referencedColumnNames to use the specific target's PK columns
+        // Override referencedColumnNames to use the specific target's PK (or `targetKey`) columns
         // (polymorphic targets may have different PK column names, e.g. org_id vs user_id)
-        const referencedColumnNames = targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
+        const referencedColumnNames = prop.targetKey
+            ? targetMeta.properties[prop.targetKey].fieldNames
+            : targetMeta.getPrimaryProps().flatMap(pk => pk.fieldNames);
         const targetProp = { ...prop, targetMeta, referencedColumnNames };
         const aliasedName = `${ownerAlias}.${prop.name}[${targetMeta.className}]#${alias}`;
         this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(targetProp, ownerAlias, alias, type, {}, schema);

package/schema/DatabaseTable.js

@@ -155,6 +155,7 @@ export class DatabaseTable {
                 comment: prop.comment,
                 collation: prop.collation,
                 extra: prop.extra,
+                sequence: prop.sequence,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
             this.#columns[field].unsigned ??= this.#columns[field].autoincrement;
@@ -796,6 +797,7 @@ export class DatabaseTable {
             nullable: column.nullable,
             primary: column.primary && persist,
             autoincrement: column.autoincrement,
+            sequence: column.sequence,
             fieldName: column.name,
             unsigned: column.unsigned,
             length: column.length,

package/schema/SchemaComparator.js

@@ -708,7 +708,9 @@ export class SchemaComparator {
             log(`'nullable' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('nullable');
         }
-        if (this.diffExpression(fromColumn.generated, toColumn.generated)) {
+        // identity options (start/increment) are applied on create only, same as the `sequence` option
+        const withoutIdentityOptions = (generated) => generated?.replace(/^((?:by default as )?identity)\s*\(.*\)$/is, '$1');
+        if (this.diffExpression(withoutIdentityOptions(fromColumn.generated), withoutIdentityOptions(toColumn.generated))) {
             log(`'generated' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('generated');
         }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
+import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment, type SequenceOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
@@ -45,6 +45,12 @@ export declare abstract class SchemaHelper {
     resolveMigrationSchema(schema: string | undefined): string | undefined;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     appendComments(table: DatabaseTable): string[];
+    /** Returns SQL that moves the autoincrement counter back to `sequence.startWith` after `clear()` truncated the table. */
+    getResetSequenceSQL(tableName: string, schemaName: string | undefined, columnName: string, startWith: number): string;
+    /** Maps the introspected start and increment of an autoincrement column to its `sequence` option, omitting defaults. */
+    protected getIntrospectedSequence(start: unknown, increment: unknown): SequenceOptions | undefined;
+    /** Renders the `start with … increment by …` clause for the `sequence` option of an autoincrement column. */
+    protected getSequenceOptionsSQL(column: Column): string;
     supportsSchemaConstraints(): boolean;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     inferLengthFromColumnType(type: string): number | undefined;

package/schema/SchemaHelper.js

@@ -91,6 +91,38 @@ export class SchemaHelper {
     appendComments(table) {
         return [];
     }
+    /** Returns SQL that moves the autoincrement counter back to `sequence.startWith` after `clear()` truncated the table. */
+    /* v8 ignore next */
+    getResetSequenceSQL(tableName, schemaName, columnName, startWith) {
+        return '';
+    }
+    /** Maps the introspected start and increment of an autoincrement column to its `sequence` option, omitting defaults. */
+    getIntrospectedSequence(start, increment) {
+        if (start == null) {
+            return undefined;
+        }
+        const incrementBy = Number(increment ?? 1);
+        const startWith = Number(start);
+        const sequence = {};
+        if (startWith !== (incrementBy < 0 ? -1 : 1)) {
+            sequence.startWith = startWith;
+        }
+        if (incrementBy !== 1) {
+            sequence.incrementBy = incrementBy;
+        }
+        return Utils.hasObjectKeys(sequence) ? sequence : undefined;
+    }
+    /** Renders the `start with … increment by …` clause for the `sequence` option of an autoincrement column. */
+    getSequenceOptionsSQL(column) {
+        const { startWith, incrementBy } = column.sequence ?? {};
+        const descending = incrementBy != null && incrementBy < 0;
+        // a sequence is bounded by 1 (ascending) or -1 (descending) by default, a start beyond that has to move the bound
+        const bound = startWith != null &&
+            (descending ? startWith > -1 && `maxvalue ${startWith}` : startWith < 1 && `minvalue ${startWith}`);
+        return [startWith != null && `start with ${startWith}`, incrementBy != null && `increment by ${incrementBy}`, bound]
+            .filter(Boolean)
+            .join(' ');
+    }
     supportsSchemaConstraints() {
         return true;
     }
@@ -474,10 +506,16 @@ export class SchemaHelper {
         for (const foreignKey of Object.values(diff.changedForeignKeys)) {
             ret.push(this.createForeignKey(diff.toTable, foreignKey));
         }
-        for (const index of Object.values(diff.addedIndexes)) {
-            ret.push(this.createIndex(index, diff.toTable));
-        }
-        for (const index of Object.values(diff.changedIndexes)) {
+        for (const index of [...Object.values(diff.addedIndexes), ...Object.values(diff.changedIndexes)]) {
+            const addedColumn = diff.addedColumns[index.columnNames[0]];
+            // an added autoincrement PK column already declares the primary key inline
+            if (index.primary &&
+                !index.composite &&
+                addedColumn?.autoincrement &&
+                addedColumn.primary &&
+                !this.hasNonDefaultPrimaryKeyName(diff.toTable)) {
+                continue;
+            }
             ret.push(this.createIndex(index, diff.toTable, true));
         }
         for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {

package/schema/SqlSchemaGenerator.js

@@ -141,6 +141,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                     .withSchema(schema)
                     .truncate()
                     .execute();
+                // the counters of a TPT child's inherited columns (PK included) belong to the parent table
+                const props = meta.tptParent ? (meta.ownProps ?? []) : meta.props;
+                for (const prop of props.filter(prop => prop.autoincrement && prop.sequence?.startWith != null)) {
+                    const sql = this.helper.getResetSequenceSQL(meta.tableName, this.getSchemaName(meta, { schema }), prop.fieldNames[0], prop.sequence.startWith);
+                    if (sql) {
+                        await this.execute(sql, { ctx: this.em?.getTransactionContext() });
+                    }
+                }
             }
             catch (e) {
                 if (this.platform.getExceptionConverter().convertException(e) instanceof TableNotFoundException) {

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityMetadata, EntityProperty, EntitySchemaWithMeta, ExtractDefineEntityProperties, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, SequenceOptions, Type } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -37,6 +37,8 @@ export interface Column {
     mappedType: Type<unknown>;
     unsigned?: boolean;
     autoincrement?: boolean;
+    /** applied only when the column is created, never diffed */
+    sequence?: SequenceOptions;
     nullable?: boolean;
     length?: number;
     precision?: number;
@@ -295,6 +297,8 @@ export interface IQueryBuilder<T> {
     scheduleFilterCheck(path: string): void;
     /** @internal */
     ensureTPTJoins(): void;
+    /** @internal */
+    addPolymorphicJoin(prop: EntityProperty, targetMeta: EntityMetadata, ownerAlias: string, alias: string, type: JoinType, path: string, schema?: string): void;
     withSchema(schema: string): this;
 }
 export interface ICriteriaNodeProcessOptions {