feat(deleteColumns): Add confirmation dialog for dependent indexes

When deleting columns that have dependent indexes, the extension now:
- Detects indexes that reference the columns being deleted
- Shows a warning dialog listing affected indexes
- Asks user to confirm dropping indexes or cancel
- Only proceeds if user confirms, avoiding silent database reload on cancel

Added findDependentIndexes() method to both WASM and native backends.
Updated LoggingDatabaseOperations wrapper to forward the new methods.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: zknpr

core/ui/modules/crud.js

@@ -202,7 +202,14 @@ async function submitDeleteColumns() {
 
     try {
         updateStatus('Deleting columns...');
-        await backendApi.deleteColumns(state.selectedTable, columnNames);
+        const result = await backendApi.deleteColumns(state.selectedTable, columnNames);
+
+        // If user cancelled the operation (e.g., declined to drop dependent indexes), don't reload
+        if (result && result.cancelled) {
+            updateStatus('Delete cancelled');
+            closeModal('deleteModal');
+            return;
+        }
 
         closeModal('deleteModal');
         state.selectedColumns.clear();

core/ui/viewer.html

@@ -474,14 +474,75 @@ class WasmDatabaseEngine implements DatabaseOperations {
     await this.executeQuery(sql, validIds);
   }
 
+  /**
+   * Find indexes that depend on specific columns.
+   *
+   * @param table - Table name
+   * @param columns - Column names to check
+   * @returns Array of index names that reference any of the columns
+   */
+  async findDependentIndexes(table: string, columns: string[]): Promise<string[]> {
+    const dependentIndexes: string[] = [];
+
+    // Query sqlite_master for indexes on this table
+    const indexQuery = `
+      SELECT name, sql FROM sqlite_master
+      WHERE type = 'index'
+        AND tbl_name = ?
+        AND sql IS NOT NULL
+    `;
+    const indexResult = await this.executeQuery(indexQuery, [table]);
+
+    if (indexResult.length > 0 && indexResult[0].rows) {
+      for (const row of indexResult[0].rows) {
+        const indexName = row[0] as string;
+        const indexSql = row[1] as string;
+
+        // Check if this index references any of the columns
+        const referencesColumn = columns.some(col => {
+          const colLower = col.toLowerCase();
+          // Match column name in index definition (quoted or unquoted)
+          const patterns = [
+            new RegExp(`[\\(,]\\s*${colLower}\\s*[\\),]`, 'i'),
+            new RegExp(`[\\(,]\\s*"${colLower}"\\s*[\\),]`, 'i'),
+            new RegExp(`[\\(,]\\s*\\[${colLower}\\]\\s*[\\),]`, 'i'),
+            new RegExp(`[\\(,]\\s*\`${colLower}\`\\s*[\\),]`, 'i')
+          ];
+          return patterns.some(p => p.test(indexSql));
+        });
+
+        if (referencesColumn) {
+          dependentIndexes.push(indexName);
+        }
+      }
+    }
+
+    return dependentIndexes;
+  }
+
   /**
    * Delete columns by name.
+   *
+   * If dropDependentIndexes is provided, those indexes will be dropped first.
+   * Otherwise, deletion may fail if indexes reference the columns.
+   *
+   * @param table - Table name
+   * @param columns - Column names to delete
+   * @param dropDependentIndexes - Optional list of indexes to drop first
    */
-  async deleteColumns(table: string, columns: string[]): Promise<void> {
+  async deleteColumns(table: string, columns: string[], dropDependentIndexes?: string[]): Promise<void> {
     if (columns.length === 0) return;
 
     const escapedTable = escapeIdentifier(table);
 
+    // Drop specified dependent indexes first
+    if (dropDependentIndexes && dropDependentIndexes.length > 0) {
+      for (const indexName of dropDependentIndexes) {
+        await this.executeQuery(`DROP INDEX IF EXISTS ${escapeIdentifier(indexName)}`);
+      }
+    }
+
+    // Now drop the columns
     for (const col of columns) {
       const sql = `ALTER TABLE ${escapedTable} DROP COLUMN ${escapeIdentifier(col)}`;
       await this.executeQuery(sql);
@@ -967,9 +1028,14 @@ export function createWorkerEndpoint() {
       return activeEngine.deleteRows(table, rowIds);
     },
 
-    async deleteColumns(table: string, columns: string[]): Promise<void> {
+    async deleteColumns(table: string, columns: string[], dropDependentIndexes?: string[]): Promise<void> {
+      if (!activeEngine) throw new Error('No database initialized');
+      return activeEngine.deleteColumns(table, columns, dropDependentIndexes);
+    },
+
+    async findDependentIndexes(table: string, columns: string[]): Promise<string[]> {
       if (!activeEngine) throw new Error('No database initialized');
-      return activeEngine.deleteColumns(table, columns);
+      return activeEngine.findDependentIndexes(table, columns);
     },
 
     async createTable(table: string, columns: ColumnDefinition[]): Promise<void> {

src/core/sqlite-db.ts

@@ -220,7 +220,10 @@ export interface DatabaseOperations {
   deleteRows(table: string, rowIds: RecordId[]): Promise<void>;
 
   /** Delete columns by name */
-  deleteColumns(table: string, columns: string[]): Promise<void>;
+  deleteColumns(table: string, columns: string[], dropDependentIndexes?: string[]): Promise<void>;
+
+  /** Find indexes that depend on specific columns */
+  findDependentIndexes(table: string, columns: string[]): Promise<string[]>;
 
   /** Create a new table */
   createTable(table: string, columns: ColumnDefinition[]): Promise<void>;

src/core/types.ts

@@ -250,8 +250,13 @@ export class HostBridge implements ToastService {
 
   /**
    * Delete columns.
+   *
+   * If columns have dependent indexes, shows a confirmation dialog to the user.
+   * User can choose to drop the indexes and continue, or cancel the operation.
+   *
+   * @returns Object with `cancelled: true` if user cancelled, otherwise undefined
    */
-  async deleteColumns(table: string, columns: string[]) {
+  async deleteColumns(table: string, columns: string[]): Promise<{ cancelled: boolean } | void> {
     const { document } = this;
     if (!document.databaseOperations) {
       throw new Error("Database not initialized");
@@ -261,6 +266,33 @@ export class HostBridge implements ToastService {
       throw new Error("Document is read-only");
     }
 
+    // Check for dependent indexes before deletion
+    let dependentIndexes: string[] = [];
+    if ('findDependentIndexes' in document.databaseOperations) {
+      dependentIndexes = await document.databaseOperations.findDependentIndexes(table, columns);
+    }
+
+    // If there are dependent indexes, ask the user for confirmation
+    if (dependentIndexes.length > 0) {
+      const indexList = dependentIndexes.join(', ');
+      const message = vsc.l10n.t(
+        'The following indexes depend on the selected column(s) and will be dropped: {0}',
+        indexList
+      );
+
+      const result = await vsc.window.showWarningMessage(
+        message,
+        { modal: true },
+        { title: vsc.l10n.t('Drop Indexes & Continue'), value: true },
+        { title: vsc.l10n.t('Cancel'), value: false, isCloseAffordance: true }
+      );
+
+      if (!result?.value) {
+        // User cancelled the operation - return cancelled flag
+        return { cancelled: true };
+      }
+    }
+
     // Capture column data before deletion for undo
     let deletedColumnsData: { name: string; type: string; data: { rowId: RecordId; value: CellValue }[] }[] = [];
     try {
@@ -303,7 +335,8 @@ export class HostBridge implements ToastService {
     }
 
     if ('deleteColumns' in document.databaseOperations) {
-      await document.databaseOperations.deleteColumns(table, columns);
+      // Pass dependent indexes to be dropped first if user confirmed
+      await document.databaseOperations.deleteColumns(table, columns, dependentIndexes.length > 0 ? dependentIndexes : undefined);
     } else {
       throw new Error("Backend does not support deleteColumns");
     }

src/hostBridge.ts

@@ -153,11 +153,21 @@ export class LoggingDatabaseOperations implements DatabaseOperations {
         return this.wrapped.deleteRows(table, rowIds);
     }
 
-    async deleteColumns(table: string, columns: string[]): Promise<void> {
+    async deleteColumns(table: string, columns: string[], dropDependentIndexes?: string[]): Promise<void> {
+        if (dropDependentIndexes && dropDependentIndexes.length > 0) {
+            for (const indexName of dropDependentIndexes) {
+                this.log(`DROP INDEX IF EXISTS ${escapeIdentifier(indexName)}`, true);
+            }
+        }
         for (const col of columns) {
             this.log(`ALTER TABLE ${escapeIdentifier(table)} DROP COLUMN ${escapeIdentifier(col)}`, true);
         }
-        return this.wrapped.deleteColumns(table, columns);
+        return this.wrapped.deleteColumns(table, columns, dropDependentIndexes);
+    }
+
+    async findDependentIndexes(table: string, columns: string[]): Promise<string[]> {
+        this.log(`Finding dependent indexes for ${escapeIdentifier(table)} columns: ${columns.join(', ')}`, false);
+        return this.wrapped.findDependentIndexes(table, columns);
     }
 
     async createTable(table: string, columns: ColumnDefinition[]): Promise<void> {

src/loggingDatabaseOperations.ts

@@ -732,14 +732,65 @@ export async function createNativeDatabaseConnection(
           await worker.call('run', [sql, validIds]);
         },
 
+        /**
+         * Find indexes that depend on specific columns.
+         */
+        findDependentIndexes: async (table: string, columns: string[]): Promise<string[]> => {
+          const dependentIndexes: string[] = [];
+
+          // Query sqlite_master for indexes on this table
+          const indexQuery = `
+            SELECT name, sql FROM sqlite_master
+            WHERE type = 'index'
+              AND tbl_name = ?
+              AND sql IS NOT NULL
+          `;
+          const indexResult = await worker.call<any>('query', [indexQuery, [table]]);
+
+          if (indexResult && indexResult.values) {
+            for (const row of indexResult.values) {
+              const indexName = row[0] as string;
+              const indexSql = row[1] as string;
+
+              // Check if this index references any of the columns
+              const referencesColumn = columns.some(col => {
+                const colLower = col.toLowerCase();
+                // Match column name in index definition (quoted or unquoted)
+                const patterns = [
+                  new RegExp(`[\\(,]\\s*${colLower}\\s*[\\),]`, 'i'),
+                  new RegExp(`[\\(,]\\s*"${colLower}"\\s*[\\),]`, 'i'),
+                  new RegExp(`[\\(,]\\s*\\[${colLower}\\]\\s*[\\),]`, 'i'),
+                  new RegExp(`[\\(,]\\s*\`${colLower}\`\\s*[\\),]`, 'i')
+                ];
+                return patterns.some(p => p.test(indexSql));
+              });
+
+              if (referencesColumn) {
+                dependentIndexes.push(indexName);
+              }
+            }
+          }
+
+          return dependentIndexes;
+        },
+
         /**
          * Delete columns by name.
+         * If dropDependentIndexes is provided, those indexes will be dropped first.
          */
-        deleteColumns: async (table: string, columns: string[]) => {
+        deleteColumns: async (table: string, columns: string[], dropDependentIndexes?: string[]) => {
           if (columns.length === 0) return;
 
           const escapedTable = escapeIdentifier(table);
 
+          // Drop specified dependent indexes first
+          if (dropDependentIndexes && dropDependentIndexes.length > 0) {
+            for (const indexName of dropDependentIndexes) {
+              await worker.call('run', [`DROP INDEX IF EXISTS ${escapeIdentifier(indexName)}`]);
+            }
+          }
+
+          // Now drop the columns
           for (const col of columns) {
             const sql = `ALTER TABLE ${escapedTable} DROP COLUMN ${escapeIdentifier(col)}`;
             await worker.call('run', [sql]);

src/nativeWorker.ts

@@ -95,7 +95,8 @@ interface WorkerMethods {
   updateCell(table: string, rowId: string | number, column: string, value: CellValue): Promise<void>;
   insertRow(table: string, data: Record<string, CellValue>): Promise<string | number | undefined>;
   deleteRows(table: string, rowIds: (string | number)[]): Promise<void>;
-  deleteColumns(table: string, columns: string[]): Promise<void>;
+  deleteColumns(table: string, columns: string[], dropDependentIndexes?: string[]): Promise<void>;
+  findDependentIndexes(table: string, columns: string[]): Promise<string[]>;
   createTable(table: string, columns: ColumnDefinition[]): Promise<void>;
   updateCellBatch(table: string, updates: CellUpdate[]): Promise<void>;
   addColumn(table: string, column: string, type: string, defaultValue?: string): Promise<void>;
@@ -228,7 +229,7 @@ async function createWasmDatabaseConnection(
         }
       }
     },
-    ['initializeDatabase', 'runQuery', 'exportDatabase', 'updateCell', 'insertRow', 'deleteRows', 'deleteColumns', 'createTable', 'updateCellBatch', 'addColumn', 'fetchTableData', 'fetchTableCount', 'fetchSchema', 'getTableInfo', 'getPragmas', 'setPragma', 'ping', 'writeToFile']
+    ['initializeDatabase', 'runQuery', 'exportDatabase', 'updateCell', 'insertRow', 'deleteRows', 'deleteColumns', 'findDependentIndexes', 'createTable', 'updateCellBatch', 'addColumn', 'fetchTableData', 'fetchTableCount', 'fetchSchema', 'getTableInfo', 'getPragmas', 'setPragma', 'ping', 'writeToFile']
   );
 
   // Termination handler
@@ -347,8 +348,10 @@ async function createWasmDatabaseConnection(
           },
           deleteRows: (table: string, rowIds: (string | number)[]) =>
             workerProxy.deleteRows(table, rowIds),
-          deleteColumns: (table: string, columns: string[]) =>
-            workerProxy.deleteColumns(table, columns),
+          deleteColumns: (table: string, columns: string[], dropDependentIndexes?: string[]) =>
+            workerProxy.deleteColumns(table, columns, dropDependentIndexes),
+          findDependentIndexes: (table: string, columns: string[]) =>
+            workerProxy.findDependentIndexes(table, columns),
           createTable: (table: string, columns: ColumnDefinition[]) =>
             workerProxy.createTable(table, columns),
           updateCellBatch: (table: string, updates: CellUpdate[]) => {