@mikro-orm/sql 7.0.4 → 7.0.5-dev.0

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -2,542 +2,529 @@ import { Utils } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 /** SpatiaLite system views that should be automatically ignored */
 const SPATIALITE_VIEWS = [
-  'geometry_columns',
-  'spatial_ref_sys',
-  'views_geometry_columns',
-  'virts_geometry_columns',
-  'geom_cols_ref_sys',
-  'spatial_ref_sys_aux',
-  'vector_layers',
-  'vector_layers_auth',
-  'vector_layers_field_infos',
-  'vector_layers_statistics',
-  'ElementaryGeometries',
+    'geometry_columns',
+    'spatial_ref_sys',
+    'views_geometry_columns',
+    'virts_geometry_columns',
+    'geom_cols_ref_sys',
+    'spatial_ref_sys_aux',
+    'vector_layers',
+    'vector_layers_auth',
+    'vector_layers_field_infos',
+    'vector_layers_statistics',
+    'ElementaryGeometries',
 ];
 export class SqliteSchemaHelper extends SchemaHelper {
-  disableForeignKeysSQL() {
-    return 'pragma foreign_keys = off;';
-  }
-  enableForeignKeysSQL() {
-    return 'pragma foreign_keys = on;';
-  }
-  supportsSchemaConstraints() {
-    return false;
-  }
-  getCreateNamespaceSQL(name) {
-    return '';
-  }
-  getDropNamespaceSQL(name) {
-    return '';
-  }
-  getListTablesSQL() {
-    return (
-      `select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
-      `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`
-    );
-  }
-  async getAllTables(connection, schemas) {
-    const databases = await this.getDatabaseList(connection);
-    const hasAttachedDbs = databases.length > 1; // More than just 'main'
-    // If no attached databases, use original behavior
-    if (!hasAttachedDbs && !schemas?.length) {
-      return connection.execute(this.getListTablesSQL());
-    }
-    // With attached databases, query each one
-    const targetSchemas = schemas?.length ? schemas : databases;
-    const allTables = [];
-    for (const dbName of targetSchemas) {
-      const prefix = this.getSchemaPrefix(dbName);
-      const tables = await connection.execute(
-        `select name from ${prefix}sqlite_master where type = 'table' ` +
-          `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`,
-      );
-      for (const t of tables) {
-        allTables.push({ table_name: t.name, schema_name: dbName });
-      }
-    }
-    return allTables;
-  }
-  async getNamespaces(connection) {
-    return this.getDatabaseList(connection);
-  }
-  getIgnoredViewsCondition() {
-    return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
-  }
-  getListViewsSQL() {
-    return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
-  }
-  async loadViews(schema, connection, schemaName) {
-    const databases = await this.getDatabaseList(connection);
-    const hasAttachedDbs = databases.length > 1; // More than just 'main'
-    // If no attached databases and no specific schema, use original behavior
-    if (!hasAttachedDbs && !schemaName) {
-      const views = await connection.execute(this.getListViewsSQL());
-      for (const view of views) {
-        schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
-      }
-      return;
-    }
-    // With attached databases, query each one
-    /* v8 ignore next - schemaName branch not commonly used */
-    const targetDbs = schemaName ? [schemaName] : databases;
-    for (const dbName of targetDbs) {
-      const prefix = this.getSchemaPrefix(dbName);
-      const views = await connection.execute(
-        `select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`,
-      );
-      for (const view of views) {
-        schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
-      }
-    }
-  }
-  getDropDatabaseSQL(name) {
-    if (name === ':memory:') {
-      return '';
-    }
-    /* v8 ignore next */
-    return `drop database if exists ${this.quote(name)}`;
-  }
-  async loadInformationSchema(schema, connection, tables, schemas) {
-    for (const t of tables) {
-      const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
-      const cols = await this.getColumns(connection, table.name, table.schema);
-      const indexes = await this.getIndexes(connection, table.name, table.schema);
-      const checks = await this.getChecks(connection, table.name, table.schema);
-      const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
-      const fks = await this.getForeignKeys(connection, table.name, table.schema);
-      const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
-      table.init(cols, indexes, checks, pks, fks, enums);
-    }
-  }
-  createTable(table, alter) {
-    let sql = `create table ${table.getQuotedName()} (`;
-    const columns = table.getColumns();
-    const lastColumn = columns[columns.length - 1].name;
-    for (const column of columns) {
-      const col = this.createTableColumn(column, table);
-      if (col) {
-        const comma = column.name === lastColumn ? '' : ', ';
-        sql += col + comma;
-      }
-    }
-    const primaryKey = table.getPrimaryKey();
-    const createPrimary = primaryKey?.composite;
-    if (createPrimary && primaryKey) {
-      sql += `, primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
-    }
-    const parts = [];
-    for (const fk of Object.values(table.getForeignKeys())) {
-      parts.push(this.createForeignKey(table, fk, false));
-    }
-    for (const check of table.getChecks()) {
-      const sql = `constraint ${this.quote(check.name)} check (${check.expression})`;
-      parts.push(sql);
-    }
-    if (parts.length > 0) {
-      sql += ', ' + parts.join(', ');
-    }
-    sql += ')';
-    if (table.comment) {
-      sql += ` /* ${table.comment} */`;
-    }
-    const ret = [];
-    this.append(ret, sql);
-    for (const index of table.getIndexes()) {
-      this.append(ret, this.createIndex(index, table));
-    }
-    return ret;
-  }
-  createTableColumn(column, table, _changedProperties) {
-    const col = [this.quote(column.name)];
-    const checks = table.getChecks();
-    const check = checks.findIndex(check => check.columnName === column.name);
-    const useDefault = column.default != null && column.default !== 'null';
-    let columnType = column.type;
-    if (column.autoincrement) {
-      columnType = 'integer';
-    }
-    if (column.generated) {
-      columnType += ` generated always as ${column.generated}`;
-    }
-    col.push(columnType);
-    if (check !== -1) {
-      col.push(`check (${checks[check].expression})`);
-      checks.splice(check, 1);
-    }
-    Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
-    Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
-    Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
-    Utils.runIfNotEmpty(() => col.push('autoincrement'), column.autoincrement);
-    Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
-    return col.join(' ');
-  }
-  getAddColumnsSQL(table, columns, diff) {
-    return columns.map(column => {
-      let sql = `alter table ${table.getQuotedName()} add column ${this.createTableColumn(column, table)}`;
-      const foreignKey = Object.values(diff.addedForeignKeys).find(
-        fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name,
-      );
-      if (foreignKey && this.options.createForeignKeyConstraints) {
-        delete diff.addedForeignKeys[foreignKey.constraintName];
-        sql += ' ' + this.createForeignKey(diff.toTable, foreignKey, false, true);
-      }
-      return sql;
-    });
-  }
-  dropForeignKey(tableName, constraintName) {
-    return '';
-  }
-  getDropColumnsSQL(tableName, columns, schemaName) {
-    /* v8 ignore next */
-    const name = this.quote(
-      (schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName,
-    );
-    return columns
-      .map(column => {
-        return `alter table ${name} drop column ${this.quote(column.name)}`;
-      })
-      .join(';\n');
-  }
-  getCreateIndexSQL(tableName, index) {
-    /* v8 ignore next */
-    if (index.expression) {
-      return index.expression;
-    }
-    // SQLite requires: CREATE INDEX schema.index_name ON table_name (columns)
-    // NOT: CREATE INDEX index_name ON schema.table_name (columns)
-    const [schemaName, rawTableName] = this.splitTableName(tableName);
-    const quotedTableName = this.quote(rawTableName);
-    // If there's a schema, prefix the index name with it
-    let keyName;
-    if (schemaName && schemaName !== 'main') {
-      keyName = `${this.quote(schemaName)}.${this.quote(index.keyName)}`;
-    } else {
-      keyName = this.quote(index.keyName);
-    }
-    const sqlPrefix = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${quotedTableName}`;
-    /* v8 ignore next 4 */
-    if (index.columnNames.some(column => column.includes('.'))) {
-      // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-      const columns = this.platform.getJsonIndexDefinition(index);
-      return `${sqlPrefix} (${columns.join(', ')})`;
-    }
-    // Use getIndexColumns to support advanced options like sort order and collation
-    return `${sqlPrefix} (${this.getIndexColumns(index)})`;
-  }
-  parseTableDefinition(sql, cols) {
-    const columns = {};
-    const constraints = [];
-    // extract all columns definitions
-    let columnsDef = new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i').exec(sql.replaceAll('\n', ''))?.[1];
-    /* v8 ignore next */
-    if (columnsDef) {
-      if (columnsDef.includes(', constraint ')) {
-        constraints.push(...columnsDef.substring(columnsDef.indexOf(', constraint') + 2).split(', '));
-        columnsDef = columnsDef.substring(0, columnsDef.indexOf(', constraint'));
-      }
-      for (let i = cols.length - 1; i >= 0; i--) {
-        const col = cols[i];
-        const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
-        const columnDef = new RegExp(re, 'i').exec(columnsDef);
-        if (columnDef) {
-          columns[col.name] = { name: col.name, definition: columnDef[1] };
-          columnsDef = columnsDef.substring(0, columnDef.index);
-        }
-      }
-    }
-    return { columns, constraints };
-  }
-  /**
-   * Returns schema prefix for pragma and sqlite_master queries.
-   * Returns empty string for main database (no prefix needed).
-   */
-  getSchemaPrefix(schemaName) {
-    if (!schemaName || schemaName === 'main') {
-      return '';
-    }
-    return `${this.platform.quoteIdentifier(schemaName)}.`;
-  }
-  /**
-   * Returns all database names excluding 'temp'.
-   */
-  async getDatabaseList(connection) {
-    const databases = await connection.execute('pragma database_list');
-    return databases.filter(d => d.name !== 'temp').map(d => d.name);
-  }
-  /**
-   * Extracts the SELECT part from a CREATE VIEW statement.
-   */
-  extractViewDefinition(viewDefinition) {
-    const match = /create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/is.exec(viewDefinition);
-    /* v8 ignore next - fallback for non-standard view definitions */
-    return match ? match[1] : viewDefinition;
-  }
-  async getColumns(connection, tableName, schemaName) {
-    const prefix = this.getSchemaPrefix(schemaName);
-    const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
-    const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-    const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
-    const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
-    // there can be only one, so naive check like this should be enough
-    const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
-    const { columns: columnDefinitions } = this.parseTableDefinition(tableDefinition.sql, columns);
-    return columns.map(col => {
-      const mappedType = connection.getPlatform().getMappedType(col.type);
-      let generated;
-      if (col.hidden > 1) {
+    disableForeignKeysSQL() {
+        return 'pragma foreign_keys = off;';
+    }
+    enableForeignKeysSQL() {
+        return 'pragma foreign_keys = on;';
+    }
+    supportsSchemaConstraints() {
+        return false;
+    }
+    getCreateNamespaceSQL(name) {
+        return '';
+    }
+    getDropNamespaceSQL(name) {
+        return '';
+    }
+    getListTablesSQL() {
+        return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
+            `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
+    }
+    async getAllTables(connection, schemas) {
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases, use original behavior
+        if (!hasAttachedDbs && !schemas?.length) {
+            return connection.execute(this.getListTablesSQL());
+        }
+        // With attached databases, query each one
+        const targetSchemas = schemas?.length ? schemas : databases;
+        const allTables = [];
+        for (const dbName of targetSchemas) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const tables = await connection.execute(`select name from ${prefix}sqlite_master where type = 'table' ` +
+                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`);
+            for (const t of tables) {
+                allTables.push({ table_name: t.name, schema_name: dbName });
+            }
+        }
+        return allTables;
+    }
+    async getNamespaces(connection) {
+        return this.getDatabaseList(connection);
+    }
+    getIgnoredViewsCondition() {
+        return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
+    }
+    getListViewsSQL() {
+        return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
+    }
+    async loadViews(schema, connection, schemaName) {
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases and no specific schema, use original behavior
+        if (!hasAttachedDbs && !schemaName) {
+            const views = await connection.execute(this.getListViewsSQL());
+            for (const view of views) {
+                schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
+            }
+            return;
+        }
+        // With attached databases, query each one
+        /* v8 ignore next - schemaName branch not commonly used */
+        const targetDbs = schemaName ? [schemaName] : databases;
+        for (const dbName of targetDbs) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`);
+            for (const view of views) {
+                schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
+            }
+        }
+    }
+    getDropDatabaseSQL(name) {
+        if (name === ':memory:') {
+            return '';
+        }
         /* v8 ignore next */
-        const storage = col.hidden === 2 ? 'virtual' : 'stored';
-        const re = new RegExp(`(generated always)? as \\((.*)\\)( ${storage})?$`, 'i');
-        const match = columnDefinitions[col.name].definition.match(re);
-        if (match) {
-          generated = `${match[2]} ${storage}`;
-        }
-      }
-      return {
-        name: col.name,
-        type: col.type,
-        default: this.wrapExpressionDefault(col.dflt_value),
-        nullable: !col.notnull,
-        primary: !!col.pk,
-        mappedType,
-        unsigned: false,
-        autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
-        generated,
-      };
-    });
-  }
-  /**
-   * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
-   * We need to add them back so they match what we generate in DDL.
-   */
-  wrapExpressionDefault(value) {
-    if (value == null) {
-      return null;
-    }
-    // simple values that are returned as-is from pragma (no wrapping needed)
-    if (
-      /^-?\d/.test(value) ||
-      /^[xX]'/.test(value) ||
-      value.startsWith("'") ||
-      value.startsWith('"') ||
-      value.startsWith('(')
-    ) {
-      return value;
-    }
-    const lower = value.toLowerCase();
-    if (['null', 'true', 'false', 'current_timestamp', 'current_date', 'current_time'].includes(lower)) {
-      return value;
-    }
-    // everything else is an expression that had its outer parens stripped
-    return `(${value})`;
-  }
-  async getEnumDefinitions(connection, tableName, schemaName) {
-    const prefix = this.getSchemaPrefix(schemaName);
-    const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-    const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
-    const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
-    return checkConstraints.reduce((o, item) => {
-      // check constraints are defined as (note that last closing paren is missing):
-      // `type` text check (`type` in ('local', 'global')
-      const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
-      /* v8 ignore next */
-      if (match) {
-        o[match[1]] = match[2].split(',').map(item => /^\(?'(.*)'/.exec(item.trim())[1]);
-      }
-      return o;
-    }, {});
-  }
-  async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-    const prefix = this.getSchemaPrefix(schemaName);
-    const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
-    const cols = await connection.execute(sql);
-    return cols.filter(col => !!col.pk).map(col => col.name);
-  }
-  async getIndexes(connection, tableName, schemaName) {
-    const prefix = this.getSchemaPrefix(schemaName);
-    const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
-    const cols = await connection.execute(sql);
-    const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
-    const ret = [];
-    for (const col of cols.filter(c => c.pk)) {
-      ret.push({
-        columnNames: [col.name],
-        keyName: 'primary',
-        constraint: true,
-        unique: true,
-        primary: true,
-      });
-    }
-    for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
-      const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
-      ret.push(
-        ...res.map(row => ({
-          columnNames: [row.name],
-          keyName: index.name,
-          unique: !!index.unique,
-          constraint: !!index.unique,
-          primary: false,
-        })),
-      );
-    }
-    return this.mapIndexes(ret);
-  }
-  async getChecks(connection, tableName, schemaName) {
-    const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
-    const checks = [];
-    for (const key of Object.keys(columns)) {
-      const column = columns[key];
-      const expression = / (check \((.*)\))/i.exec(column.definition);
-      if (expression) {
-        checks.push({
-          name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
-          definition: expression[1],
-          expression: expression[2],
-          columnName: column.name,
+        return `drop database if exists ${this.quote(name)}`;
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
+    createTable(table, alter) {
+        let sql = `create table ${table.getQuotedName()} (`;
+        const columns = table.getColumns();
+        const lastColumn = columns[columns.length - 1].name;
+        for (const column of columns) {
+            const col = this.createTableColumn(column, table);
+            if (col) {
+                const comma = column.name === lastColumn ? '' : ', ';
+                sql += col + comma;
+            }
+        }
+        const primaryKey = table.getPrimaryKey();
+        const createPrimary = primaryKey?.composite;
+        if (createPrimary && primaryKey) {
+            sql += `, primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
+        }
+        const parts = [];
+        for (const fk of Object.values(table.getForeignKeys())) {
+            parts.push(this.createForeignKey(table, fk, false));
+        }
+        for (const check of table.getChecks()) {
+            const sql = `constraint ${this.quote(check.name)} check (${check.expression})`;
+            parts.push(sql);
+        }
+        if (parts.length > 0) {
+            sql += ', ' + parts.join(', ');
+        }
+        sql += ')';
+        if (table.comment) {
+            sql += ` /* ${table.comment} */`;
+        }
+        const ret = [];
+        this.append(ret, sql);
+        for (const index of table.getIndexes()) {
+            this.append(ret, this.createIndex(index, table));
+        }
+        return ret;
+    }
+    createTableColumn(column, table, _changedProperties) {
+        const col = [this.quote(column.name)];
+        const checks = table.getChecks();
+        const check = checks.findIndex(check => check.columnName === column.name);
+        const useDefault = column.default != null && column.default !== 'null';
+        let columnType = column.type;
+        if (column.autoincrement) {
+            columnType = 'integer';
+        }
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        col.push(columnType);
+        if (check !== -1) {
+            col.push(`check (${checks[check].expression})`);
+            checks.splice(check, 1);
+        }
+        Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
+        Utils.runIfNotEmpty(() => col.push('autoincrement'), column.autoincrement);
+        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        return col.join(' ');
+    }
+    getAddColumnsSQL(table, columns, diff) {
+        return columns.map(column => {
+            let sql = `alter table ${table.getQuotedName()} add column ${this.createTableColumn(column, table)}`;
+            const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
+            if (foreignKey && this.options.createForeignKeyConstraints) {
+                delete diff.addedForeignKeys[foreignKey.constraintName];
+                sql += ' ' + this.createForeignKey(diff.toTable, foreignKey, false, true);
+            }
+            return sql;
         });
-      }
-    }
-    for (const constraint of constraints) {
-      const expression = /constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i.exec(constraint);
-      if (expression) {
-        checks.push({
-          name: expression[1],
-          definition: expression[2],
-          expression: expression[3],
+    }
+    dropForeignKey(tableName, constraintName) {
+        return '';
+    }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        /* v8 ignore next */
+        const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        return columns
+            .map(column => {
+            return `alter table ${name} drop column ${this.quote(column.name)}`;
+        })
+            .join(';\n');
+    }
+    getCreateIndexSQL(tableName, index) {
+        /* v8 ignore next */
+        if (index.expression) {
+            return index.expression;
+        }
+        // SQLite requires: CREATE INDEX schema.index_name ON table_name (columns)
+        // NOT: CREATE INDEX index_name ON schema.table_name (columns)
+        const [schemaName, rawTableName] = this.splitTableName(tableName);
+        const quotedTableName = this.quote(rawTableName);
+        // If there's a schema, prefix the index name with it
+        let keyName;
+        if (schemaName && schemaName !== 'main') {
+            keyName = `${this.quote(schemaName)}.${this.quote(index.keyName)}`;
+        }
+        else {
+            keyName = this.quote(index.keyName);
+        }
+        const sqlPrefix = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${quotedTableName}`;
+        /* v8 ignore next 4 */
+        if (index.columnNames.some(column => column.includes('.'))) {
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            const columns = this.platform.getJsonIndexDefinition(index);
+            return `${sqlPrefix} (${columns.join(', ')})`;
+        }
+        // Use getIndexColumns to support advanced options like sort order and collation
+        return `${sqlPrefix} (${this.getIndexColumns(index)})`;
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        const constraints = [];
+        // extract all columns definitions
+        let columnsDef = new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i').exec(sql.replaceAll('\n', ''))?.[1];
+        /* v8 ignore next */
+        if (columnsDef) {
+            if (columnsDef.includes(', constraint ')) {
+                constraints.push(...columnsDef.substring(columnsDef.indexOf(', constraint') + 2).split(', '));
+                columnsDef = columnsDef.substring(0, columnsDef.indexOf(', constraint'));
+            }
+            for (let i = cols.length - 1; i >= 0; i--) {
+                const col = cols[i];
+                const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
+                const columnDef = new RegExp(re, 'i').exec(columnsDef);
+                if (columnDef) {
+                    columns[col.name] = { name: col.name, definition: columnDef[1] };
+                    columnsDef = columnsDef.substring(0, columnDef.index);
+                }
+            }
+        }
+        return { columns, constraints };
+    }
+    /**
+     * Returns schema prefix for pragma and sqlite_master queries.
+     * Returns empty string for main database (no prefix needed).
+     */
+    getSchemaPrefix(schemaName) {
+        if (!schemaName || schemaName === 'main') {
+            return '';
+        }
+        return `${this.platform.quoteIdentifier(schemaName)}.`;
+    }
+    /**
+     * Returns all database names excluding 'temp'.
+     */
+    async getDatabaseList(connection) {
+        const databases = await connection.execute('pragma database_list');
+        return databases.filter(d => d.name !== 'temp').map(d => d.name);
+    }
+    /**
+     * Extracts the SELECT part from a CREATE VIEW statement.
+     */
+    extractViewDefinition(viewDefinition) {
+        const match = /create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/is.exec(viewDefinition);
+        /* v8 ignore next - fallback for non-standard view definitions */
+        return match ? match[1] : viewDefinition;
+    }
+    async getColumns(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
+        // there can be only one, so naive check like this should be enough
+        const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
+        const { columns: columnDefinitions } = this.parseTableDefinition(tableDefinition.sql, columns);
+        return columns.map(col => {
+            const mappedType = connection.getPlatform().getMappedType(col.type);
+            let generated;
+            if (col.hidden > 1) {
+                /* v8 ignore next */
+                const storage = col.hidden === 2 ? 'virtual' : 'stored';
+                const re = new RegExp(`(generated always)? as \\((.*)\\)( ${storage})?$`, 'i');
+                const match = columnDefinitions[col.name].definition.match(re);
+                if (match) {
+                    generated = `${match[2]} ${storage}`;
+                }
+            }
+            return {
+                name: col.name,
+                type: col.type,
+                default: this.wrapExpressionDefault(col.dflt_value),
+                nullable: !col.notnull,
+                primary: !!col.pk,
+                mappedType,
+                unsigned: false,
+                autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
+                generated,
+            };
         });
-      }
-    }
-    return checks;
-  }
-  async getColumnDefinitions(connection, tableName, schemaName) {
-    const prefix = this.getSchemaPrefix(schemaName);
-    const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
-    const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-    const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
-    return this.parseTableDefinition(tableDefinition.sql, columns);
-  }
-  async getForeignKeys(connection, tableName, schemaName) {
-    const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
-    const prefix = this.getSchemaPrefix(schemaName);
-    const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
-    const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
-    return fks.reduce((ret, fk) => {
-      const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
-      const constraint = constraints?.find(c => c.includes(constraintName));
-      ret[constraintName] = {
-        constraintName,
-        columnName: fk.from,
-        columnNames: [fk.from],
-        localTableName: qualifiedTableName,
-        referencedTableName: fk.table,
-        referencedColumnName: fk.to,
-        referencedColumnNames: [fk.to],
-        updateRule: fk.on_update.toLowerCase(),
-        deleteRule: fk.on_delete.toLowerCase(),
-        deferMode: constraint?.match(/ deferrable initially (deferred|immediate)/i)?.[1].toLowerCase(),
-      };
-      return ret;
-    }, {});
-  }
-  getManagementDbName() {
-    return '';
-  }
-  getCreateDatabaseSQL(name) {
-    return '';
-  }
-  async databaseExists(connection, name) {
-    const tables = await connection.execute(this.getListTablesSQL());
-    return tables.length > 0;
-  }
-  /**
-   * Implicit indexes will be ignored when diffing
-   */
-  isImplicitIndex(name) {
-    // Ignore indexes with reserved names, e.g. autoindexes
-    return name.startsWith('sqlite_');
-  }
-  dropIndex(table, index, oldIndexName = index.keyName) {
-    return `drop index ${this.quote(oldIndexName)}`;
-  }
-  /**
-   * SQLite does not support schema-qualified table names in REFERENCES clauses.
-   * Foreign key references can only point to tables in the same database.
-   */
-  getReferencedTableName(referencedTableName, schema) {
-    const [schemaName, tableName] = this.splitTableName(referencedTableName);
-    // Strip any schema prefix - SQLite REFERENCES clause doesn't support it
-    return tableName;
-  }
-  alterTable(diff, safe) {
-    const ret = [];
-    const [schemaName, tableName] = this.splitTableName(diff.name);
-    if (
-      Utils.hasObjectKeys(diff.removedChecks) ||
-      Utils.hasObjectKeys(diff.changedChecks) ||
-      Utils.hasObjectKeys(diff.changedForeignKeys) ||
-      Utils.hasObjectKeys(diff.changedColumns)
-    ) {
-      return this.getAlterTempTableSQL(diff);
-    }
-    for (const index of Object.values(diff.removedIndexes)) {
-      this.append(ret, this.dropIndex(diff.name, index));
-    }
-    for (const index of Object.values(diff.changedIndexes)) {
-      this.append(ret, this.dropIndex(diff.name, index));
-    }
-    /* v8 ignore next */
-    if (!safe && Object.values(diff.removedColumns).length > 0) {
-      this.append(ret, this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
-    }
-    if (Object.values(diff.addedColumns).length > 0) {
-      this.append(ret, this.getAddColumnsSQL(diff.toTable, Object.values(diff.addedColumns), diff));
-    }
-    if (Utils.hasObjectKeys(diff.addedForeignKeys) || Utils.hasObjectKeys(diff.addedChecks)) {
-      return this.getAlterTempTableSQL(diff);
-    }
-    for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
-      this.append(ret, this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
-    }
-    for (const index of Object.values(diff.addedIndexes)) {
-      ret.push(this.createIndex(index, diff.toTable));
-    }
-    for (const index of Object.values(diff.changedIndexes)) {
-      ret.push(this.createIndex(index, diff.toTable, true));
-    }
-    for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
-      if (index.unique) {
-        this.append(ret, this.dropIndex(diff.name, index, oldIndexName));
-        this.append(ret, this.createIndex(index, diff.toTable));
-      } else {
-        this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
-      }
-    }
-    return ret;
-  }
-  getAlterTempTableSQL(changedTable) {
-    const tempName = `${changedTable.toTable.name}__temp_alter`;
-    const quotedName = this.quote(changedTable.toTable.name);
-    const quotedTempName = this.quote(tempName);
-    const [first, ...rest] = this.createTable(changedTable.toTable);
-    const sql = [
-      'pragma foreign_keys = off;',
-      first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
-    ];
-    const columns = [];
-    for (const column of changedTable.toTable.getColumns()) {
-      const fromColumn = changedTable.fromTable.getColumn(column.name);
-      if (fromColumn) {
-        columns.push(this.quote(column.name));
-      } else {
-        columns.push(`null as ${this.quote(column.name)}`);
-      }
-    }
-    sql.push(`insert into ${quotedTempName} select ${columns.join(', ')} from ${quotedName};`);
-    sql.push(`drop table ${quotedName};`);
-    sql.push(`alter table ${quotedTempName} rename to ${quotedName};`);
-    sql.push(...rest);
-    sql.push('pragma foreign_keys = on;');
-    return sql;
-  }
+    }
+    /**
+     * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
+     * We need to add them back so they match what we generate in DDL.
+     */
+    wrapExpressionDefault(value) {
+        if (value == null) {
+            return null;
+        }
+        // simple values that are returned as-is from pragma (no wrapping needed)
+        if (/^-?\d/.test(value) ||
+            /^[xX]'/.test(value) ||
+            value.startsWith("'") ||
+            value.startsWith('"') ||
+            value.startsWith('(')) {
+            return value;
+        }
+        const lower = value.toLowerCase();
+        if (['null', 'true', 'false', 'current_timestamp', 'current_date', 'current_time'].includes(lower)) {
+            return value;
+        }
+        // everything else is an expression that had its outer parens stripped
+        return `(${value})`;
+    }
+    async getEnumDefinitions(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
+        return checkConstraints.reduce((o, item) => {
+            // check constraints are defined as (note that last closing paren is missing):
+            // `type` text check (`type` in ('local', 'global')
+            const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
+            /* v8 ignore next */
+            if (match) {
+                o[match[1]] = match[2].split(',').map((item) => /^\(?'(.*)'/.exec(item.trim())[1]);
+            }
+            return o;
+        }, {});
+    }
+    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        return cols.filter(col => !!col.pk).map(col => col.name);
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
+        const ret = [];
+        for (const col of cols.filter(c => c.pk)) {
+            ret.push({
+                columnNames: [col.name],
+                keyName: 'primary',
+                constraint: true,
+                unique: true,
+                primary: true,
+            });
+        }
+        for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
+            const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
+            ret.push(...res.map(row => ({
+                columnNames: [row.name],
+                keyName: index.name,
+                unique: !!index.unique,
+                constraint: !!index.unique,
+                primary: false,
+            })));
+        }
+        return this.mapIndexes(ret);
+    }
+    async getChecks(connection, tableName, schemaName) {
+        const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const checks = [];
+        for (const key of Object.keys(columns)) {
+            const column = columns[key];
+            const expression = / (check \((.*)\))/i.exec(column.definition);
+            if (expression) {
+                checks.push({
+                    name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
+                    definition: expression[1],
+                    expression: expression[2],
+                    columnName: column.name,
+                });
+            }
+        }
+        for (const constraint of constraints) {
+            const expression = /constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i.exec(constraint);
+            if (expression) {
+                checks.push({
+                    name: expression[1],
+                    definition: expression[2],
+                    expression: expression[3],
+                });
+            }
+        }
+        return checks;
+    }
+    async getColumnDefinitions(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        return this.parseTableDefinition(tableDefinition.sql, columns);
+    }
+    async getForeignKeys(connection, tableName, schemaName) {
+        const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const prefix = this.getSchemaPrefix(schemaName);
+        const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
+        const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+        return fks.reduce((ret, fk) => {
+            const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
+            const constraint = constraints?.find(c => c.includes(constraintName));
+            ret[constraintName] = {
+                constraintName,
+                columnName: fk.from,
+                columnNames: [fk.from],
+                localTableName: qualifiedTableName,
+                referencedTableName: fk.table,
+                referencedColumnName: fk.to,
+                referencedColumnNames: [fk.to],
+                updateRule: fk.on_update.toLowerCase(),
+                deleteRule: fk.on_delete.toLowerCase(),
+                deferMode: constraint?.match(/ deferrable initially (deferred|immediate)/i)?.[1].toLowerCase(),
+            };
+            return ret;
+        }, {});
+    }
+    getManagementDbName() {
+        return '';
+    }
+    getCreateDatabaseSQL(name) {
+        return '';
+    }
+    async databaseExists(connection, name) {
+        const tables = await connection.execute(this.getListTablesSQL());
+        return tables.length > 0;
+    }
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name) {
+        // Ignore indexes with reserved names, e.g. autoindexes
+        return name.startsWith('sqlite_');
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        return `drop index ${this.quote(oldIndexName)}`;
+    }
+    /**
+     * SQLite does not support schema-qualified table names in REFERENCES clauses.
+     * Foreign key references can only point to tables in the same database.
+     */
+    getReferencedTableName(referencedTableName, schema) {
+        const [schemaName, tableName] = this.splitTableName(referencedTableName);
+        // Strip any schema prefix - SQLite REFERENCES clause doesn't support it
+        return tableName;
+    }
+    alterTable(diff, safe) {
+        const ret = [];
+        const [schemaName, tableName] = this.splitTableName(diff.name);
+        if (Utils.hasObjectKeys(diff.removedChecks) ||
+            Utils.hasObjectKeys(diff.changedChecks) ||
+            Utils.hasObjectKeys(diff.changedForeignKeys) ||
+            Utils.hasObjectKeys(diff.changedColumns)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const index of Object.values(diff.removedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        /* v8 ignore next */
+        if (!safe && Object.values(diff.removedColumns).length > 0) {
+            this.append(ret, this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
+        }
+        if (Object.values(diff.addedColumns).length > 0) {
+            this.append(ret, this.getAddColumnsSQL(diff.toTable, Object.values(diff.addedColumns), diff));
+        }
+        if (Utils.hasObjectKeys(diff.addedForeignKeys) || Utils.hasObjectKeys(diff.addedChecks)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
+            this.append(ret, this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
+        }
+        for (const index of Object.values(diff.addedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable, true));
+        }
+        for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
+            if (index.unique) {
+                this.append(ret, this.dropIndex(diff.name, index, oldIndexName));
+                this.append(ret, this.createIndex(index, diff.toTable));
+            }
+            else {
+                this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
+            }
+        }
+        return ret;
+    }
+    getAlterTempTableSQL(changedTable) {
+        const tempName = `${changedTable.toTable.name}__temp_alter`;
+        const quotedName = this.quote(changedTable.toTable.name);
+        const quotedTempName = this.quote(tempName);
+        const [first, ...rest] = this.createTable(changedTable.toTable);
+        const sql = [
+            'pragma foreign_keys = off;',
+            first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
+        ];
+        const columns = [];
+        for (const column of changedTable.toTable.getColumns()) {
+            const fromColumn = changedTable.fromTable.getColumn(column.name);
+            if (fromColumn) {
+                columns.push(this.quote(column.name));
+            }
+            else {
+                columns.push(`null as ${this.quote(column.name)}`);
+            }
+        }
+        sql.push(`insert into ${quotedTempName} select ${columns.join(', ')} from ${quotedName};`);
+        sql.push(`drop table ${quotedName};`);
+        sql.push(`alter table ${quotedTempName} rename to ${quotedName};`);
+        sql.push(...rest);
+        sql.push('pragma foreign_keys = on;');
+        return sql;
+    }
 }