@mikro-orm/sql 7.1.0-dev.9 → 7.1.1-dev.0

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,6 @@
 import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
-import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import { SchemaHelper, stripStatementNewlines } from '../../schema/SchemaHelper.js';
+import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 export class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -12,23 +13,45 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         'null::timestamp with time zone': ['null'],
         'null::timestamp without time zone': ['null'],
     };
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+)$/is;
+    static FUNCTIONAL_COL_RE = /[(): ,"'`]/;
     getSchemaBeginning(charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `set names '${charset}';\n${this.disableForeignKeysSQL()}\n\n`;
         }
         return `set names '${charset}';\n\n`;
     }
+    getSetSchemaSQL(schema) {
+        // session-level `SET` (not `SET LOCAL`) so it also works outside a transaction; the runner
+        // emits `getResetSchemaSQL` afterwards to avoid leaking onto the pooled connection
+        return `set search_path to ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(_defaultSchema) {
+        return 'reset search_path';
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
     getCreateDatabaseSQL(name) {
         return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
+        // The `pg_inherits` anti-join compares on (schema, table) pairs so cross-schema child
+        // partitions are excluded even when their schema is not on the session `search_path`
+        // (in which case `inhrelid::regclass::text` renders as `schema.name` rather than bare `name`,
+        // breaking a plain `table_name not in (...)` predicate).
         return (`select table_name, table_schema as schema_name, ` +
             `(select pg_catalog.obj_description(c.oid) from pg_catalog.pg_class c
           where c.oid = (select ('"' || table_schema || '"."' || table_name || '"')::regclass::oid) and c.relname = table_name) as table_comment ` +
-            `from information_schema.tables ` +
+            `from information_schema.tables t ` +
             `where ${this.getIgnoredNamespacesConditionSQL('table_schema')} ` +
             `and table_name != 'geometry_columns' and table_name != 'spatial_ref_sys' and table_type != 'VIEW' ` +
-            `and table_name not in (select inhrelid::regclass::text from pg_inherits) ` +
+            `and not exists (` +
+            `select 1 from pg_inherits i ` +
+            `join pg_class c on c.oid = i.inhrelid ` +
+            `join pg_namespace n on n.oid = c.relnamespace ` +
+            `where c.relname = t.table_name and n.nspname = t.table_schema` +
+            `) ` +
             `order by table_name`);
     }
     getIgnoredViewsCondition() {
@@ -79,6 +102,23 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const dataClause = withData ? ' with data' : ' with no data';
         return `create materialized view ${viewName} as ${definition}${dataClause}`;
     }
+    createTable(table, alter) {
+        const partitioning = table.getPartitioning();
+        if (!partitioning) {
+            return super.createTable(table, alter);
+        }
+        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}`;
+        });
+        // SchemaHelper.append() always terminates the CREATE TABLE with `;`; we rely on that to splice
+        // the `partition by ...` clause in before the terminator. Use slice instead of replace() so that
+        // 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];
+    }
     dropMaterializedViewIfExists(name, schema) {
         return `drop materialized view if exists ${this.quote(this.getTableName(name, schema))} cascade`;
     }
@@ -118,10 +158,13 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const partitionings = await this.getPartitions(connection, tablesBySchema, ctx);
         const triggers = await this.getAllTriggers(connection, tablesBySchema);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             if (columns[key]) {
@@ -130,7 +173,60 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (triggers[key]) {
                 table.setTriggers(triggers[key]);
             }
+            table.setPartitioning(partitionings[key]);
+        }
+    }
+    /**
+     * Introspects direct partitions only: the `pg_inherits` join surfaces a parent's children but
+     * does not recurse into sub-partitioning (e.g. hash-of-range). Declarative `partitionBy`
+     * metadata does not express multi-level partitioning either, so grandchildren are intentionally
+     * invisible to schema diffing.
+     *
+     * Entries with an undefined schema bucket are resolved against `current_schema()` so they do
+     * not match same-named tables in unrelated schemas.
+     */
+    async getPartitions(connection, tablesBySchemas, ctx) {
+        // Collapse every (schema, table) pair into a single `values (...)` relation and join against
+        // the catalog, instead of building an OR-tree of per-schema `in (...)` predicates. This keeps
+        // the query size O(pairs) rather than O(schemas × predicate_overhead) and stays sargable when
+        // many schemas are in play.
+        const pairs = [...tablesBySchemas.entries()].flatMap(([schema, tables]) => tables.map(t => {
+            const schemaLiteral = schema == null ? 'null::text' : `${this.platform.quoteValue(schema)}::text`;
+            return `(${schemaLiteral}, ${this.platform.quoteValue(t.table_name)})`;
+        }));
+        if (pairs.length === 0) {
+            return {};
+        }
+        const sql = `with targets(schema_name, table_name) as (values ${pairs.join(', ')})
+      select parent_ns.nspname as schema_name,
+      parent.relname as table_name,
+      pg_get_partkeydef(parent.oid) as partition_definition,
+      child_ns.nspname as partition_schema_name,
+      child.relname as partition_name,
+      pg_get_expr(child.relpartbound, child.oid) as partition_bound
+      from targets
+      join pg_class parent on parent.relname = targets.table_name
+      join pg_namespace parent_ns on parent_ns.oid = parent.relnamespace
+        and parent_ns.nspname = coalesce(targets.schema_name, current_schema())
+      join pg_partitioned_table partitioned on partitioned.partrelid = parent.oid
+      left join pg_inherits inherits on inherits.inhparent = parent.oid
+      left join pg_class child on child.oid = inherits.inhrelid
+      left join pg_namespace child_ns on child_ns.oid = child.relnamespace
+      order by parent_ns.nspname, parent.relname, child_ns.nspname, child.relname`;
+        const rows = await connection.execute(sql, [], 'all', ctx);
+        const ret = {};
+        for (const row of rows) {
+            const key = this.getTableKey(row);
+            ret[key] ??= { definition: normalizePartitionDefinition(row.partition_definition), partitions: [] };
+            if (row.partition_name && row.partition_bound) {
+                ret[key].partitions.push({
+                    name: row.partition_name,
+                    schema: row.partition_schema_name,
+                    bound: normalizePartitionBound(row.partition_bound),
+                });
+            }
         }
+        return ret;
     }
     async getAllIndexes(connection, tables, ctx) {
         const sql = this.getIndexesSQL(tables);
@@ -165,9 +261,22 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
-            if (index.index_def.some((col) => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
+            const hasFunctionalColumns = index.index_def.some((col) => PostgreSqlSchemaHelper.FUNCTIONAL_COL_RE.exec(col));
+            const whereMatch = hasFunctionalColumns
+                ? null
+                : PostgreSqlSchemaHelper.PARTIAL_WHERE_RE.exec(index.expression ?? '');
+            if (hasFunctionalColumns) {
+                // Functional-column expression can't be diffed structurally — keep the whole CREATE
+                // statement (WHERE included) on `expression`; don't try to split the predicate.
                 indexDef.expression = index.expression;
             }
+            else if (whereMatch) {
+                let where = whereMatch[1].trim();
+                if (where.startsWith('(') && where.endsWith(')') && this.isBalancedWrap(where)) {
+                    where = where.slice(1, -1).trim();
+                }
+                indexDef.where = where;
+            }
             if (index.deferrable) {
                 indexDef.deferMode = index.initially_deferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
@@ -253,7 +362,6 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 }
             }
         }
-        /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
         return '';
     }
     async getAllColumns(connection, tablesBySchemas, nativeEnums, ctx) {
@@ -270,10 +378,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       is_identity,
       identity_generation,
       generation_expression,
-      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment
+      pg_catalog.col_description(pgc.oid, cols.ordinal_position::int) column_comment,
+      coll.collname as collation_name
       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'
       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);
@@ -323,6 +433,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                         ? col.generation_expression + ' stored'
                         : undefined,
                 comment: col.column_comment,
+                collation: col.collation_name ?? undefined,
             };
             let enumKey = column.type;
             let enumEntry = nativeEnums?.[enumKey];
@@ -400,6 +511,118 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
         return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
     }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const params = this.formatRoutineParams(routine);
+        // Default `sql` for functions, `plpgsql` for procedures (block syntax required).
+        const language = (routine.language ?? (routine.type === 'procedure' ? 'plpgsql' : 'sql')).toLowerCase();
+        const security = routine.security === 'definer' ? ' security definer' : routine.security === 'invoker' ? ' security invoker' : '';
+        const determinism = routine.deterministic === true ? ' immutable' : routine.deterministic === false ? ' volatile' : '';
+        const flatten = (s) => stripStatementNewlines(s).trim();
+        if (routine.type === 'procedure') {
+            const body = language === 'sql' ? flatten(routine.body ?? '') : this.wrapRoutineBody(routine.body ?? '');
+            return `create or replace procedure ${qualifiedName}(${params})${security} language ${language} as $$ ${body} $$`;
+        }
+        const returnType = routine.returns?.type ?? 'void';
+        const body = language === 'sql' ? flatten(routine.body ?? '') : this.wrapRoutineBody(routine.body ?? '');
+        return `create or replace function ${qualifiedName}(${params}) returns ${returnType}${security}${determinism} language ${language} as $$ ${body} $$`;
+    }
+    dropRoutine(routine) {
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const argTypes = routine.params.map(p => p.type).join(', ');
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${qualifiedName}(${argTypes})`;
+    }
+    async getAllRoutines(connection, schemas = []) {
+        const target = (schemas.length > 0 ? schemas : [this.platform.getDefaultSchemaName()]).filter(Boolean);
+        const schemaList = target.map(s => this.platform.quoteValue(s)).join(', ');
+        const sql = `
+      select
+        n.nspname as schema_name,
+        p.proname as name,
+        case when p.prokind = 'p' then 'procedure' else 'function' end as kind,
+        l.lanname as language,
+        case when p.proisstrict then false else null end as is_strict,
+        case when p.provolatile = 'i' then true when p.provolatile = 'v' then false else null end as deterministic,
+        case when p.prosecdef then 'definer' else 'invoker' end as security,
+        pg_get_functiondef(p.oid) as full_def,
+        pg_get_function_arguments(p.oid) as arg_signature,
+        pg_get_function_result(p.oid) as result_type,
+        d.description as comment
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+      join pg_language l on l.oid = p.prolang
+      left join pg_description d on d.objoid = p.oid and d.classoid = 'pg_proc'::regclass
+      where n.nspname in (${schemaList})
+        and l.lanname not in ('c', 'internal')
+        -- exclude functions owned by extensions (PostGIS et al.)
+        and not exists (
+          select 1 from pg_depend dep
+          where dep.objid = p.oid
+            and dep.classid = 'pg_proc'::regclass
+            and dep.deptype = 'e'
+        )
+        -- exclude trigger-helper functions; they're managed alongside their owning trigger.
+        and p.prorettype <> 'trigger'::regtype
+    `;
+        const rows = await connection.execute(sql);
+        return rows.map(row => {
+            const params = this.parseRoutineParams(row.arg_signature);
+            const body = this.extractRoutineBody(row.full_def);
+            return {
+                name: row.name,
+                schema: row.schema_name,
+                type: row.kind,
+                language: row.language,
+                comment: row.comment ?? undefined,
+                security: row.security,
+                deterministic: row.deterministic ?? undefined,
+                body,
+                params,
+                returns: row.kind === 'function' && row.result_type ? { type: row.result_type, nullable: true } : undefined,
+            };
+        });
+    }
+    formatRoutineParams(routine) {
+        return routine.params
+            .map(p => {
+            const dir = p.direction === 'in' ? '' : `${p.direction.toUpperCase()} `;
+            const def = p.defaultRaw ? ` default ${p.defaultRaw}` : '';
+            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}${def}`;
+        })
+            .join(', ');
+    }
+    parseRoutineParams(signature) {
+        if (!signature.trim()) {
+            return [];
+        }
+        return signature.split(/,(?![^()]*\))/).map(part => {
+            const trimmed = part.trim();
+            // INOUT before IN/OUT, with required trailing space so identifiers like `input` aren't
+            // mis-parsed as a direction keyword.
+            const match = /^(?:(INOUT|VARIADIC|IN|OUT)\s+)?(?:"((?:[^"]|"")+)"|([\w$]+))\s+(.+?)(?:\s+default\s+.+)?$/i.exec(trimmed);
+            /* v8 ignore next 3: defensive guard for unexpected `pg_get_function_arguments` output shapes */
+            if (!match) {
+                throw new Error(`Could not parse PostgreSQL routine parameter signature: ${JSON.stringify(trimmed)}`);
+            }
+            const dirRaw = (match[1] ?? 'in').toLowerCase();
+            const direction = dirRaw === 'inout' ? 'inout' : dirRaw === 'out' ? 'out' : 'in';
+            const name = match[2] != null ? match[2].replaceAll('""', '"') : match[3];
+            return {
+                name,
+                type: match[4].trim(),
+                direction,
+            };
+        });
+    }
+    /** PG canonicalises `$$` quoting to a tagged form like `$function$ ... $function$`; match the tag-aware form. */
+    extractRoutineBody(fullDef) {
+        const tagged = /\bAS\s+\$(\w*)\$([\s\S]*?)\$\1\$/i.exec(fullDef);
+        return this.stripRoutineBody(tagged ? tagged[2] : fullDef);
+    }
     getSchemaQualifiedTriggerFnName(table, trigger) {
         const rawName = `${table.name}_${trigger.name}_fn`;
         const defaultSchema = this.platform.getDefaultSchemaName();
@@ -408,6 +631,15 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return this.platform.quoteIdentifier(rawName);
     }
+    /**
+     * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),
+     * so the comparator can treat `@Property({ collation: '<datcollate>' })` as equivalent
+     * to a column that introspects as using the default.
+     */
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select datcollate as collation from pg_database where datname = current_database()`, [], 'all', ctx);
+        return row?.collation;
+    }
     async getAllTriggers(connection, tablesBySchemas) {
         const sql = this.getTriggersSQL(tablesBySchemas);
         const allTriggers = await connection.execute(sql);
@@ -598,6 +830,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
+    getCollateSQL(collation) {
+        return `collate ${this.platform.quoteCollation(collation)}`;
+    }
     createTableColumn(column, table) {
         const pk = table.getPrimaryKey();
         const compositePK = pk?.composite;
@@ -630,6 +865,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 columnType += ` generated always as ${column.generated}`;
             }
             col.push(columnType);
+            Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
             Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
             Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable);
         }
@@ -641,6 +877,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
+        if (tableDiff.changedPartitioning) {
+            const from = tableDiff.changedPartitioning.from?.definition;
+            const to = tableDiff.changedPartitioning.to?.definition;
+            const action = !from ? 'Adding' : !to ? 'Removing' : 'Changing';
+            throw new Error(`${action} partition definitions for existing PostgreSQL tables is not supported automatically (${tableDiff.name}: '${from ?? '<none>'}' -> '${to ?? '<none>'}'); create a manual migration instead`);
+        }
         const ret = [];
         const parts = tableDiff.name.split('.');
         const tableName = parts.pop();
@@ -773,33 +1015,32 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         if (index.primary || (index.unique && index.constraint)) {
             return `alter table ${this.quote(table)} drop constraint ${this.quote(oldIndexName)}`;
         }
-        return `drop index ${this.quote(oldIndexName)}`;
+        const [schemaName] = this.splitTableName(table);
+        return `drop index ${this.quote(schemaName, oldIndexName)}`;
     }
     /**
      * Build the column list for a PostgreSQL index.
      */
     getIndexColumns(index) {
-        if (index.columns?.length) {
-            return index.columns
-                .map(col => {
-                let colDef = this.quote(col.name);
-                // PostgreSQL supports collation with double quotes
-                if (col.collation) {
-                    colDef += ` collate ${this.quote(col.collation)}`;
-                }
-                // PostgreSQL supports sort order
-                if (col.sort) {
-                    colDef += ` ${col.sort}`;
-                }
-                // PostgreSQL supports NULLS FIRST/LAST
-                if (col.nulls) {
-                    colDef += ` nulls ${col.nulls}`;
-                }
-                return colDef;
-            })
-                .join(', ');
-        }
-        return index.columnNames.map(c => this.quote(c)).join(', ');
+        return index.columnNames
+            .map(name => {
+            const col = index.columns?.find(c => c.name === name);
+            let colDef = this.quote(name);
+            // PostgreSQL supports collation with double quotes
+            if (col?.collation) {
+                colDef += ` collate ${this.quote(col.collation)}`;
+            }
+            // PostgreSQL supports sort order
+            if (col?.sort) {
+                colDef += ` ${col.sort}`;
+            }
+            // PostgreSQL supports NULLS FIRST/LAST
+            if (col?.nulls) {
+                colDef += ` nulls ${col.nulls}`;
+            }
+            return colDef;
+        })
+            .join(', ');
     }
     /**
      * PostgreSQL-specific index options like fill factor.

package/dialects/postgresql/index.d.ts

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/index.js

@@ -1,4 +1,6 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
 export * from './BasePostgreSqlPlatform.js';
+export * from './BasePostgreSqlEntityManager.js';
 export * from './FullTextType.js';
 export * from './PostgreSqlSchemaHelper.js';
+export * from './typeOverrides.js';

package/dialects/postgresql/typeOverrides.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MikroORM keeps PostgreSQL date/timestamp/interval values as raw strings
+ * (and array variants as `string[]`); both `pg` and `pglite` would otherwise
+ * eagerly parse them via `pg-types`. Centralizing the OID list here keeps the
+ * postgres and pglite drivers in lockstep, while leaving the actual array
+ * parsing implementation to the leaf driver (so `@mikro-orm/sql` stays free of
+ * postgres-array / postgres-date / postgres-interval dependencies).
+ *
+ * Use `select typname, oid, typarray from pg_type order by oid` to look up OIDs.
+ */
+type PostgreSqlArrayParser = (value: string) => string[];
+type PostgreSqlValueParser = (value: string) => unknown;
+export declare function createPostgreSqlTypeParsers(arrayParse: PostgreSqlArrayParser): Record<number, PostgreSqlValueParser>;
+export {};

package/dialects/postgresql/typeOverrides.js

@@ -0,0 +1,12 @@
+export function createPostgreSqlTypeParsers(arrayParse) {
+    const parsers = {};
+    for (const oid of [1082, 1114, 1184, 1186]) {
+        // date, timestamp, timestamptz, interval — kept as raw strings
+        parsers[oid] = str => str;
+    }
+    for (const oid of [1182, 1115, 1185, 1187]) {
+        // date[], timestamp[], timestamptz[], interval[]
+        parsers[oid] = arrayParse;
+    }
+    return parsers;
+}

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -15,6 +15,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column: {
         length: number;
     }): string;
+    getDefaultVersionLength(): number;
     getBeginTransactionSQL(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -62,7 +63,7 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
      * including all Date properties, as we would be comparing Date object with timestamp.
      */
     processDateProperty(value: unknown): string | number | Date;
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence' | 'check'): string;
     supportsDeferredUniqueConstraints(): boolean;
     /**
      * SQLite supports schemas via ATTACH DATABASE. Returns true when there are

package/dialects/sqlite/SqlitePlatform.js

@@ -24,6 +24,10 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    // sqlite's datetime DDL drops precision and the current-ts expression hardcodes ms scaling
+    getDefaultVersionLength() {
+        return 0;
+    }
     getBeginTransactionSQL(options) {
         return ['begin'];
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -5,11 +5,13 @@ import type { Column, IndexDef, Table, TableDifference, SqlTriggerDef } from '..
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 export declare class SqliteSchemaHelper extends SchemaHelper {
+    private static readonly PARTIAL_WHERE_RE;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     supportsSchemaConstraints(): boolean;
     getCreateNamespaceSQL(name: string): string;
     getDropNamespaceSQL(name: string): string;
+    tableExists(connection: AbstractSqlConnection, tableName: string, _schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getListTablesSQL(): string;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
@@ -44,7 +46,8 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      * We need to add them back so they match what we generate in DDL.
      */
     private wrapExpressionDefault;
-    private getEnumDefinitions;
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    private extractEnumValuesFromChecks;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     private getIndexes;
     private getChecks;