@mikro-orm/sql 7.3.0-dev.10 → 7.3.0-dev.12

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

@@ -5,6 +5,8 @@ import { normalizePartitionBound, normalizePartitionDefinition } from '../../sch
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 /** Dollar-quote delimiter, e.g. `$$` or `$body$`, captured so `split` keeps it. */
 const DOLLAR_QUOTE_TAG = /(\$(?:[A-Za-z_]\w*)?\$)/;
+/** pg-added `(<operand>)::type` cast in a check body, including multi word types like `double precision`. */
+const CHECK_CAST_RE = /\(([^()]*)\)::\w+(?: precision| varying| with(?:out)? time zone)?(?:\[\])?/g;
 export class PostgreSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
@@ -106,10 +108,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 +134,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`;
@@ -387,15 +407,16 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       data_type,
       is_identity,
       identity_generation,
-      identity_start,
-      identity_increment,
       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);
@@ -435,14 +456,6 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 type += `(${col.numeric_precision},${col.numeric_scale})`;
             }
             const length = this.inferLengthFromColumnType(type) === -1 ? -1 : col.length;
-            // a descending sequence starts at -1 by default
-            const defaultIdentityStart = col.identity_increment?.startsWith('-') ? '-1' : '1';
-            // read back non-default identity options, so `identity (start with 1000)` does not diff against plain `identity`
-            const identityOptions = [
-                col.identity_start !== defaultIdentityStart && `start with ${col.identity_start}`,
-                col.identity_increment !== '1' && `increment by ${col.identity_increment}`,
-            ].filter(Boolean);
-            const identitySuffix = identityOptions.length > 0 ? ` (${identityOptions.join(' ')})` : '';
             const column = {
                 name: col.column_name,
                 type,
@@ -454,8 +467,11 @@ 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' : 'identity') + identitySuffix
+                    ? col.identity_generation === 'BY DEFAULT'
+                        ? 'by default as identity'
+                        : 'identity'
                     : col.generation_expression
                         ? col.generation_expression + ' stored'
                         : undefined,
@@ -513,7 +529,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             // SchemaHelper.createCheck).
             const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
             const single = m ? null : /^check \((.*)\)$/is.exec(check.expression);
-            const def = m ? m[1].replace(/\(([^()]*)\)::\w+(?:\[\])?/g, '$1') : single ? single[1] : check.expression;
+            const def = m ? m[1].replace(CHECK_CAST_RE, '$1') : single ? single[1] : check.expression;
             ret[key].push({
                 name: check.name,
                 columnName: check.column_name,
@@ -1040,11 +1056,15 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     columnType = this.quote(columnType);
                 }
             }
-            if (column.generated?.startsWith('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);
@@ -1201,14 +1221,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.3.0-dev.10",
+  "version": "7.3.0-dev.12",
   "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.2"
+    "@mikro-orm/core": "^7.2.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.10"
+    "@mikro-orm/core": "7.3.0-dev.12"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilderHelper.js

@@ -2,6 +2,16 @@ import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, JsonType, inspect,
 import { EMBEDDABLE_ARRAY_OPS, JoinType, QueryType } from './enums.js';
 /** Captures the column name that follows the alias placeholder. */
 const QUALIFYING_ALIAS_RE = new RegExp(ALIAS_REPLACEMENT_RE + '(?=["\'`\\]]*\\.["\'`\\[]?([\\w$]+))', 'g');
+/** Maps regexp tokens to LIKE pattern tokens, escaping LIKE wildcards with `!`. */
+const LIKE_REPLACEMENTS = {
+    '\\.': '.',
+    '\\/': '/',
+    '.*': '%',
+    '.': '_',
+    '!': '!!',
+    '%': '!%',
+    _: '!_',
+};
 /**
  * @internal
  */
@@ -359,19 +369,17 @@ export class QueryBuilderHelper {
         if (!(re instanceof RegExp)) {
             return false;
         }
-        if (re.flags.includes('i')) {
+        if (/[im]/.test(re.flags)) {
             return false;
         }
-        // when including the opening bracket/paren we consider it complex
-        return !/[{[(]/.exec(re.source);
+        // LIKE can only express edge anchors, `.`, `.*` and escaped `.` or `/`, anything else needs the regexp operator
+        return /^\^?(?:[^\\^$.*+?|{}[\]()]|\\[./]|\.\*?)*\$?$/.test(re.source);
     }
     getRegExpParam(re) {
         const value = re.source
-            .replace(/\.\*/g, '%') // .* -> %
-            .replace(/\./g, '_') // .  -> _
-            .replace(/\\_/g, '.') // \. -> .
-            .replace(/^\^/g, '') // remove ^ from start
-            .replace(/\$$/g, ''); // remove $ from end
+            .replace(/^\^/, '') // remove ^ from start
+            .replace(/\$$/, '') // remove $ from end
+            .replace(/\\[./]|\.\*|[.!%_]/g, m => LIKE_REPLACEMENTS[m]);
         if (re.source.startsWith('^') && re.source.endsWith('$')) {
             return value;
         }
@@ -445,7 +453,8 @@ export class QueryBuilderHelper {
         const parts = [];
         const params = [];
         if (this.isSimpleRegExp(cond[key])) {
-            parts.push(`${this.#platform.quoteIdentifier(this.mapper(key, type))} like ?`);
+            const escape = /[!%_]/.test(cond[key].source) ? ` escape '!'` : '';
+            parts.push(`${this.#platform.quoteIdentifier(this.mapper(key, type))} like ?${escape}`);
             params.push(this.getRegExpParam(cond[key]));
             return { sql: parts.join(' and '), params };
         }

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,
@@ -975,17 +977,22 @@ export class DatabaseTable {
             throw new Error(`Index '${name}' on entity '${meta.className}': cannot combine \`expression\` with \`where\` — inline the WHERE clause into the \`expression\` escape hatch, or drop \`expression\` and use structured \`properties\` + \`where\`.`);
         }
         const where = this.processIndexWhere(index.where, meta);
+        const expression = this.processIndexExpression(name, index.expression, meta);
         this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them.
             // Partial indexes (`where`) must use CREATE [UNIQUE] INDEX form — constraints can't carry predicates.
-            constraint: type !== 'index' && !properties.some((d) => d.includes('.')) && !where,
+            // Raw `create [unique] index` expressions are plain indexes, not constraints.
+            constraint: type !== 'index' &&
+                !properties.some((d) => d.includes('.')) &&
+                !where &&
+                !/^\s*create\s/i.test(expression ?? ''),
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: this.processIndexExpression(name, index.expression, meta),
+            expression,
             where,
             options: index.options,
             deferMode: index.deferMode,

package/schema/SchemaComparator.d.ts

@@ -30,7 +30,7 @@ export declare class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference): TableDifference | false;
+    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference, inverse?: boolean): TableDifference | false;
     /**
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.

package/schema/SchemaComparator.js

@@ -77,7 +77,7 @@ export class SchemaComparator {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
             else {
-                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName]);
+                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName], !!inverseDiff);
                 if (tableDifferences !== false) {
                     diff.changedTables[tableName] = tableDifferences;
                 }
@@ -319,7 +319,7 @@ export class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable, toTable, inverseTableDiff) {
+    diffTable(fromTable, toTable, inverseTableDiff, inverse = false) {
         let changes = 0;
         const tableDifferences = {
             name: fromTable.getShortestName(),
@@ -353,7 +353,9 @@ export class SchemaComparator {
             });
             changes++;
         }
-        if (diffPartitioning(fromTable.getPartitioning(), toTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
+        // partitioning is diffed one way (declared vs. existing), so the down diff has to compare it like the up one did
+        const [existingTable, declaredTable] = inverse ? [toTable, fromTable] : [fromTable, toTable];
+        if (diffPartitioning(existingTable.getPartitioning(), declaredTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
             tableDifferences.changedPartitioning = {
                 from: fromTable.getPartitioning(),
                 to: toTable.getPartitioning(),
@@ -477,8 +479,10 @@ export class SchemaComparator {
             if (!this.diffExpression(check.expression, toTableCheck.expression)) {
                 continue;
             }
+            // only auto-generated enum checks, a user check tagged with an enum column must be diffed by expression
             if (fromColumn?.enumItems &&
                 toColumn?.enumItems &&
+                check.name === this.#platform.getIndexName(fromTable.name, [fromColumn.name], 'check') &&
                 !this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
                 continue;
             }
@@ -708,7 +712,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');
         }
@@ -907,6 +913,7 @@ export class SchemaComparator {
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
                 // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bnot\s+in\s*\((.*?)\)/gi, '<> all (array[$1])')
                 .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
@@ -922,6 +929,8 @@ export class SchemaComparator {
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
                 // Strip these prefixes - match word.word patterns and keep only the last part
                 .replace(/\b\w+\.(\w+)/g, '$1')
+                // PostgreSQL rewrites `x [not] between a and b` to `x >= a and x <= b` (`x < a or x > b`), cast targets are skipped
+                .replace(/(?<!::\s*)\b(?!not\b)(\w+)\s+(not\s+)?between\s+(\S+)\s+and\s+(\S+)/gi, (_, x, not, a, b) => not ? `${x} < ${a} or ${x} > ${b}` : `${x} >= ${a} and ${x} <= ${b}`)
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
                 // PostgreSQL names an unaliased bare function call after the function itself,

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;
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -38,10 +38,13 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         schema?: string;
     }): string;
     /**
-     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     * Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild).
+     * Foreign keys the referencing table drops or changes in the same diff are left to its own alter, and those of dropped tables are skipped.
      */
-    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
     private getInboundForeignKeys;
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
     private preAlterTable;
     /**
      * creates new database and connects to it

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) {
@@ -327,14 +335,16 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Tables whose partitioning was added/changed can't be altered in place — they are rebuilt as a unit
         // (the helper handles the data-preserving swap), so keep them out of the regular alter passes.
         const changedTables = Object.values(schemaDiff.changedTables);
+        const dropsTables = !!options.dropTables && !options.safe;
         const partitioningRebuilds = changedTables
             .filter(changedTable => changedTable.changedPartitioning)
-            .map(diff => ({ diff, inboundForeignKeys: this.getInboundForeignKeys(schemaDiff.fromSchema, diff.toTable) }));
+            .map(diff => ({ diff, inboundForeignKeys: this.getInboundForeignKeys(schemaDiff, diff.toTable, dropsTables) }));
         const alteredTables = changedTables.filter(changedTable => !changedTable.changedPartitioning);
-        this.append(ret, this.helper.getPartitioningRebuildSQL(partitioningRebuilds, options.safe), true);
+        // before the rebuild, so inbound FKs the referencing table drops or changes are gone by then
         for (const changedTable of alteredTables) {
             this.append(ret, this.preAlterTable(changedTable, options.safe), true);
         }
+        this.append(ret, this.helper.getPartitioningRebuildSQL(partitioningRebuilds, options.safe), true);
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
         }
@@ -394,18 +404,24 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         return this.wrapSchema(ret, options);
     }
     /**
-     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     * Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild).
+     * Foreign keys the referencing table drops or changes in the same diff are left to its own alter, and those of dropped tables are skipped.
      */
-    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
-    getInboundForeignKeys(fromSchema, table) {
+    getInboundForeignKeys(schemaDiff, table, dropsTables) {
         const unqualified = (name) => name.split('.').pop();
         const targetName = unqualified(table.name);
         const ret = [];
-        for (const other of fromSchema.getTables()) {
-            if (other.name === table.name && other.schema === table.schema) {
+        for (const other of schemaDiff.fromSchema.getTables()) {
+            if ((other.name === table.name && other.schema === table.schema) ||
+                (dropsTables && other.getShortestName() in schemaDiff.removedTables)) {
                 continue;
             }
+            const otherDiff = schemaDiff.changedTables[other.getShortestName(false)];
             for (const foreignKey of Object.values(other.getForeignKeys())) {
+                const name = foreignKey.constraintName;
+                if (otherDiff && (name in otherDiff.removedForeignKeys || name in otherDiff.changedForeignKeys)) {
+                    continue;
+                }
                 if (unqualified(foreignKey.referencedTableName) === targetName) {
                     ret.push({ table: other, foreignKey });
                 }
@@ -413,6 +429,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return ret;
     }
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
     preAlterTable(diff, safe) {
         const ret = [];
         // removed/changed policies must be dropped before any column type alter, including the pre-alter

package/schema/partitioning.js

@@ -270,18 +270,18 @@ export const diffPartitioning = (from, to, defaultSchema) => {
     if (!from) {
         return true;
     }
-    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !==
-        normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition))) {
+    const toDefinition = normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition));
+    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !== toDefinition) {
         return true;
     }
-    if (from.partitions.length !== to.partitions.length) {
+    // list/range partitions created outside of metadata (e.g. at runtime) are left unmanaged, hash partitions are not
+    if (toDefinition.startsWith('hash') && from.partitions.length !== to.partitions.length) {
         return true;
     }
     const normalizeSchema = (schema) => (schema && schema !== defaultSchema ? schema : '');
     const serializePartition = (partition) => `${normalizeSchema(partition.schema)}.${partition.name}:${normalizeQuotedIdentifiers(normalizePartitionBound(partition.bound))}`;
-    const fromPartitions = from.partitions.map(serializePartition).sort();
-    const toPartitions = to.partitions.map(serializePartition).sort();
-    return fromPartitions.some((partition, index) => partition !== toPartitions[index]);
+    const fromPartitions = new Set(from.partitions.map(serializePartition));
+    return to.partitions.some(partition => !fromPartitions.has(serializePartition(partition)));
 };
 const SUPPORTED_PARTITION_TYPES = ['hash', 'list', 'range'];
 const isSupportedPartitionType = (value) => SUPPORTED_PARTITION_TYPES.includes(value);

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityMetadata, 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;