@mikro-orm/sql 7.0.2-dev.8 → 7.0.2

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -2,529 +2,542 @@ 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 '';
-        }
+  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) {
         /* 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;
+        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,
         });
-    }
-    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+(.*)/i.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,
-            };
+      }
+    }
+    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],
         });
-    }
-    /**
-     * 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;
-    }
+      }
+    }
+    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;
+  }
 }