Fix/postgres alias column autocomplete

src/components/notebook/NotebookView.tsx

@@ -44,6 +44,7 @@ import {
   createNotebookFromState,
 } from "../../utils/notebookStore";
 import { useDatabase } from "../../hooks/useDatabase";
+import { useSqlAutocompleteRegistration } from "../../hooks/useSqlAutocompleteRegistration";
 import { isMultiDatabaseCapable } from "../../utils/database";
 import { useSettings } from "../../hooks/useSettings";
 import { useAlert } from "../../hooks/useAlert";
@@ -59,19 +60,25 @@ interface NotebookViewProps {
   tab: Tab;
   updateTab: (id: string, partial: Partial<Tab>) => void;
   connectionId: string;
+  isActive: boolean;
 }
 
 export function NotebookView({
   tab,
   updateTab,
   connectionId,
+  isActive,
 }: NotebookViewProps) {
   const { t } = useTranslation();
   const { activeSchema, activeCapabilities, selectedDatabases } = useDatabase();
   const isMultiDb =
     isMultiDatabaseCapable(activeCapabilities) && selectedDatabases.length > 1;
   const effectiveSchema =
     tab.schema || activeSchema || (isMultiDb ? selectedDatabases[0] : null);
+  useSqlAutocompleteRegistration(connectionId, {
+    schema: effectiveSchema,
+    enabled: isActive,
+  });
   const { settings } = useSettings();
   const { showAlert } = useAlert();
   const { matchesShortcut } = useKeybindings();

src/contexts/DatabaseProvider.tsx

@@ -14,7 +14,7 @@ import {
 } from './DatabaseContext';
 import type { ReactNode } from 'react';
 import type { PluginManifest } from '../types/plugins';
-import { clearAutocompleteCache } from '../utils/autocomplete';
+import { clearAutocompleteCache, disposeSqlAutocomplete } from '../utils/autocomplete';
 import { toErrorMessage } from '../utils/errors';
 import { useSettings } from '../hooks/useSettings';
 import { findConnectionsForDrivers } from '../utils/connectionManager';
@@ -691,6 +691,7 @@ export const DatabaseProvider = ({ children }: { children: ReactNode }) => {
     if (!targetId) return;
 
     clearAutocompleteCache(targetId);
+    disposeSqlAutocomplete();
 
     try {
       await invoke('disconnect_connection', { connectionId: targetId });
@@ -782,6 +783,7 @@ export const DatabaseProvider = ({ children }: { children: ReactNode }) => {
         console.warn(`[DatabaseProvider] Connection health check failed for ${connectionId}: ${event.payload.error}`);
 
         clearAutocompleteCache(connectionId);
+        disposeSqlAutocomplete();
 
         setOpenConnectionIds(prev => prev.filter(id => id !== connectionId));
         setConnectionDataMap(prev => {

src/hooks/useSqlAutocompleteRegistration.ts

@@ -0,0 +1,89 @@
+import { useEffect } from "react";
+import type { Monaco } from "@monaco-editor/react";
+import { loader } from "@monaco-editor/react";
+import { useDatabase } from "./useDatabase";
+import { isMultiDatabaseCapable } from "../utils/database";
+import { registerSqlAutocomplete } from "../utils/autocomplete";
+
+type Options = {
+  monaco?: Monaco | null;
+  schema?: string | null;
+  /** When false, skips registration (e.g. inactive notebook tabs). Defaults to true. */
+  enabled?: boolean;
+};
+
+/**
+ * Keeps the global SQL completion provider in sync with the active connection.
+ * Pass `monaco` from the main editor when available; otherwise Monaco is loaded via loader.init (notebook).
+ */
+export function useSqlAutocompleteRegistration(
+  connectionId: string | null,
+  options?: Options,
+) {
+  const {
+    tables,
+    activeDriver,
+    activeSchema,
+    activeCapabilities,
+    schemaDataMap,
+    databaseDataMap,
+    selectedDatabases,
+  } = useDatabase();
+
+  const schema = options?.schema ?? activeSchema;
+  const isMultiDb =
+    isMultiDatabaseCapable(activeCapabilities) && selectedDatabases.length > 1;
+
+  const enabled = options?.enabled ?? true;
+
+  useEffect(() => {
+    if (!connectionId || !enabled) return;
+
+    let cancelled = false;
+
+    const register = (monaco: Monaco) => {
+      if (cancelled) return;
+
+      let effectiveTables = tables;
+      if (activeCapabilities?.schemas && schema) {
+        effectiveTables = schemaDataMap[schema]?.tables ?? tables;
+      } else if (isMultiDb) {
+        effectiveTables = selectedDatabases.flatMap(
+          (db) => databaseDataMap[db]?.tables ?? [],
+        );
+      }
+
+      registerSqlAutocomplete(
+        monaco,
+        connectionId,
+        effectiveTables,
+        schema,
+        activeDriver ?? null,
+      );
+    };
+
+    if (options?.monaco) {
+      register(options.monaco);
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    loader.init().then((monaco) => register(monaco));
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    connectionId,
+    enabled,
+    options?.monaco,
+    schema,
+    tables,
+    activeDriver,
+    activeCapabilities,
+    schemaDataMap,
+    databaseDataMap,
+    isMultiDb,
+    selectedDatabases,
+  ]);
+}

src/pages/Editor.tsx

@@ -82,7 +82,7 @@ import { SqlEditorWrapper } from "../components/ui/SqlEditorWrapper";
 import { NotebookView } from "../components/notebook/NotebookView";
 import { extractSqlFromCells } from "../utils/notebook";
 import { createNotebook } from "../utils/notebookStore";
-import { registerSqlAutocomplete } from "../utils/autocomplete";
+import { useSqlAutocompleteRegistration } from "../hooks/useSqlAutocompleteRegistration";
 import { type OnMount, type Monaco } from "@monaco-editor/react";
 import { save } from "@tauri-apps/plugin-dialog";
 import { useAlert } from "../hooks/useAlert";
@@ -137,16 +137,13 @@ export const Editor = () => {
   const { t } = useTranslation();
   const {
     activeConnectionId,
-    tables,
     views,
     activeDriver,
     activeSchema,
     activeCapabilities,
     selectedDatabases,
     activeConnectionName,
     activeDatabaseName,
-    schemaDataMap,
-    databaseDataMap,
   } = useDatabase();
   const { explorerConnectionId } = useConnectionLayoutContext();
   const { settings } = useSettings();
@@ -2136,23 +2133,11 @@ export const Editor = () => {
     });
   };
 
-  useEffect(() => {
-    if (monacoInstance && activeConnectionId) {
-      let effectiveTables = tables;
-      if (activeCapabilities?.schemas && activeSchema) {
-        effectiveTables = schemaDataMap[activeSchema]?.tables ?? tables;
-      } else if (isMultiDb) {
-        effectiveTables = selectedDatabases.flatMap(db => databaseDataMap[db]?.tables ?? []);
-      }
-      const disposable = registerSqlAutocomplete(
-        monacoInstance,
-        activeConnectionId,
-        effectiveTables,
-        activeSchema,
-      );
-      return () => disposable.dispose();
-    }
-  }, [monacoInstance, activeConnectionId, tables, activeSchema, activeCapabilities, schemaDataMap, databaseDataMap, isMultiDb, selectedDatabases]);
+  useSqlAutocompleteRegistration(activeConnectionId, {
+    monaco: monacoInstance,
+    schema: activeSchema,
+    enabled: !isNotebookTab,
+  });
 
   useEffect(() => {
     const state = location.state as EditorState;
@@ -2742,6 +2727,7 @@ export const Editor = () => {
                 tab={tab}
                 updateTab={updateTab}
                 connectionId={activeConnectionId || ""}
+                isActive={isActive}
               />
             </div>
           );

src/utils/autocomplete.ts

@@ -1,6 +1,7 @@
 import type { Monaco } from "@monaco-editor/react";
 import { invoke } from "@tauri-apps/api/core";
 import type { TableInfo } from "../contexts/DatabaseContext";
+import { formatSqlIdentifier, quoteTableRef } from "./identifiers";
 import { getCurrentStatement, parseTablesFromQuery } from "./sqlAnalysis";
 
 // Lightweight column cache with TTL and size limits
@@ -98,11 +99,32 @@ export const clearAutocompleteCache = (connectionId?: string) => {
   }
 };
 
+// Find a table by name in the list of tables
+const findTableByName = (name: string, tables: TableInfo[]) =>
+  tables.find((t) => t.name.toLowerCase() === name.toLowerCase())?.name;
+
+const tableInsertText = (
+  tableName: string,
+  driver?: string | null,
+  schema?: string | null,
+) =>
+  schema
+    ? quoteTableRef(tableName, driver, schema)
+    : formatSqlIdentifier(tableName, driver);
+
+let sqlCompletionProvider: { dispose: () => void } | null = null;
+
+export const disposeSqlAutocomplete = (): void => {
+  sqlCompletionProvider?.dispose();
+  sqlCompletionProvider = null;
+};
+
 export const registerSqlAutocomplete = (
   monaco: Monaco,
   connectionId: string | null,
   tables: TableInfo[],
   schema?: string | null,
+  driver?: string | null,
 ) => {
   const provider = monaco.languages.registerCompletionItemProvider("sql", {
     triggerCharacters: [".", " "],
@@ -141,13 +163,13 @@ export const registerSqlAutocomplete = (
 
         // Check if it's an alias or table name
         let actualTableName = tableAliases?.get(typedName);
-        
+
         if (!actualTableName) {
-          // Try direct table name match
-          const foundTable = tables.find(t => t.name.toLowerCase() === typedName);
-          actualTableName = foundTable?.name;
+          actualTableName = findTableByName(typedName, tables);
+        } else {
+          actualTableName = findTableByName(actualTableName, tables) ?? actualTableName;
         }
-        
+
         if (actualTableName) {
           const columns = await getTableColumns(connectionId, actualTableName, schema);
 
@@ -163,13 +185,15 @@ export const registerSqlAutocomplete = (
             label: c.label,
             kind: monaco.languages.CompletionItemKind.Field,
             detail: c.detail,
-            insertText: c.label,
+            insertText: formatSqlIdentifier(c.label, driver),
             range: columnRange,
             sortText: `0_${c.label}`,
           }));
 
           return { suggestions };
         }
+
+        return { suggestions: [] };
       }
 
       // ============================================
@@ -188,7 +212,7 @@ export const registerSqlAutocomplete = (
         // User is inside a query with FROM/JOIN - suggest columns from those tables
         const tableNames = Array.from(new Set(tableAliases.values()));
         const matchingTables = tableNames
-          .map(name => tables.find(t => t.name.toLowerCase() === name.toLowerCase()))
+          .map((name) => tables.find((t) => t.name.toLowerCase() === name.toLowerCase()))
           .filter(Boolean) as TableInfo[];
 
         // Limit parallel fetches to prevent memory spikes
@@ -223,7 +247,7 @@ export const registerSqlAutocomplete = (
                 label: col.label,
                 kind: monaco.languages.CompletionItemKind.Field,
                 detail: `${col.detail} — ${table.name}${aliasHint}`,
-                insertText: col.label,
+                insertText: formatSqlIdentifier(col.label, driver),
                 range,
                 sortText: `0_${col.label}`,
               });
@@ -259,7 +283,7 @@ export const registerSqlAutocomplete = (
         label: t.name,
         kind: monaco.languages.CompletionItemKind.Class,
         detail: "Table",
-        insertText: t.name,
+        insertText: tableInsertText(t.name, driver, schema),
         range,
         sortText: `1_${t.name}`
       }));
@@ -274,5 +298,7 @@ export const registerSqlAutocomplete = (
     },
   });
 
+  sqlCompletionProvider?.dispose();
+  sqlCompletionProvider = provider;
   return provider;
 };