sqlit-tui 1.5.0__tar.gz → 1.5.2__tar.gz

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlit-tui
-Version: 1.5.0
+Version: 1.5.2
 Summary: A terminal UI for SQL Server, PostgreSQL, MySQL, SQLite, Oracle, and more
 Project-URL: Homepage, https://github.com/Maxteabag/sqlit
 Project-URL: Repository, https://github.com/Maxteabag/sqlit
@@ -349,8 +349,6 @@ Autocomplete triggers automatically in INSERT mode. Use `Tab` to accept.
 
 Connections and settings are stored in `$XDG_CONFIG_HOME/sqlit/` (default: `~/.config/sqlit/`). Override the location by setting `SQLIT_CONFIG_DIR`.
 
-If an older install left files in `~/.sqlit/`, they are moved to the new location automatically on first run.
-
 ### Custom keybindings
 
 Edit the `keymap.json` file in your sqlit config dir. See [`config/keymap.template.json`](config/keymap.template.json) for the full default keymap. Keymap.json need to only contain the overriding keymaps.

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/README.md

@@ -239,8 +239,6 @@ Autocomplete triggers automatically in INSERT mode. Use `Tab` to accept.
 
 Connections and settings are stored in `$XDG_CONFIG_HOME/sqlit/` (default: `~/.config/sqlit/`). Override the location by setting `SQLIT_CONFIG_DIR`.
 
-If an older install left files in `~/.sqlit/`, they are moved to the new location automatically on first run.
-
 ### Custom keybindings
 
 Edit the `keymap.json` file in your sqlit config dir. See [`config/keymap.template.json`](config/keymap.template.json) for the full default keymap. Keymap.json need to only contain the overriding keymaps.

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/pyproject.toml

@@ -169,6 +169,7 @@ max-complexity = 25  # complex domain logic in cloud providers and TUI screens
 
 [project.scripts]
 sqlit = "sqlit.cli:main"
+sqlit-tui = "sqlit.cli:main"
 
 [project.urls]
 Homepage = "https://github.com/Maxteabag/sqlit"

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0'
-__version_tuple__ = version_tuple = (1, 5, 0)
+__version__ = version = '1.5.2'
+__version_tuple__ = version_tuple = (1, 5, 2)
 
 __commit_id__ = commit_id = None

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/cli.py

@@ -177,6 +177,32 @@ def _sane_tty() -> None:
         pass
 
 
+def _prewarm_process_worker(runtime: RuntimeConfig) -> Any | None:
+    """Spawn the process worker before the Textual App is constructed.
+
+    `multiprocessing.spawn` collects the parent's open file descriptors at
+    spawn time. Textual's `App.__init__` registers signal-handler pipes
+    and other non-inheritable FDs, which cause spawn to abort with
+    `ValueError: bad value(s) in fds_to_keep` (see issue #189). Spawning
+    here — before the App is constructed — is the latest point at which
+    the FD set is still clean.
+
+    Returns the live client, or None if spawn fails or the worker is
+    disabled. On failure we fall through to the lazy path inside the UI;
+    on macOS that path raises and the in-process executor takes over.
+    """
+    if not runtime.process_worker:
+        return None
+    if runtime.mock.enabled:
+        return None
+    try:
+        from sqlit.domains.process_worker.app.process_worker_client import ProcessWorkerClient
+
+        return ProcessWorkerClient()
+    except Exception:
+        return None
+
+
 def _run_app(app: Any) -> int:
     exit_code: int | None = None
     handled_signals = [signal.SIGINT, signal.SIGTERM]
@@ -464,6 +490,7 @@ def main() -> int:
         connection_url, filtered_argv = _extract_connection_url(filtered_argv)
 
     log_startup_step("cli_parser_start")
+    from sqlit import __version__
     parser = argparse.ArgumentParser(
         prog="sqlit",
         description="A terminal UI for SQL databases",
@@ -476,6 +503,12 @@ def main() -> int:
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
 
     parser.add_argument(
         "--mock",
@@ -843,10 +876,14 @@ def main() -> int:
             print(f"Error: {exc}")
             return 1
 
+        # Spawn the worker before the Textual App is constructed; see
+        # _prewarm_process_worker for why this matters on macOS.
+        process_worker_client = _prewarm_process_worker(runtime)
         app = SSMSTUI(
             services=services,
             startup_connection=startup_config,
             exclusive_connection=exclusive_connection,
+            process_worker_client=process_worker_client,
         )
         exit_code = _run_app(app)
         if exit_code != 0:
@@ -907,7 +944,12 @@ def main() -> int:
             print(f"Error: {alert_error}")
             return 1
 
-        app = SSMSTUI(services=services, startup_connection=temp_config)
+        process_worker_client = _prewarm_process_worker(runtime)
+        app = SSMSTUI(
+            services=services,
+            startup_connection=temp_config,
+            process_worker_client=process_worker_client,
+        )
         return _run_app(app)
 
     if args.command in {"connections", "connection"}:

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/connections/providers/adapters/base.py

@@ -417,18 +417,29 @@ class DatabaseAdapter(ABC):
         """Quote an identifier (table name, column name, etc.)."""
         pass
 
+    def format_autocomplete_identifier(self, name: str) -> str:
+        """Format an identifier for insertion from autocomplete.
+
+        Most dialects keep the raw name for backwards-compatible suggestions.
+        Dialects with case-sensitive quoted identifiers can override this to
+        return executable SQL for names that need quoting.
+        """
+        return name
+
     def qualified_name(self, database: str | None, schema: str | None, name: str) -> str:
         """Build a quoted qualified identifier, skipping empty segments.
 
         Default handles SQL Server-style `[db].[schema].[name]`, PostgreSQL-
         style `"schema"."name"`, and single-part `"name"` by omitting any
-        empty/None component. Dialects that want different composition
-        (e.g. MySQL, which has no schemas within databases) can override.
+        empty/None component, removing database component if provider
+        doesn't support cross-database queries and remove default schema name.
+        Dialects that want different composition (e.g. MySQL, which has
+        no schemas within databases) can override.
         """
         parts: list[str] = []
-        if database:
+        if database and self.supports_cross_database_queries:
             parts.append(self.quote_identifier(database))
-        if schema:
+        if schema and (schema != self.default_schema or parts):
             parts.append(self.quote_identifier(schema))
         parts.append(self.quote_identifier(name))
         return ".".join(parts)

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/connections/providers/postgresql/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import replace
 from typing import TYPE_CHECKING, Any
 
@@ -17,6 +18,8 @@ from sqlit.domains.connections.providers.adapters.base import (
 if TYPE_CHECKING:
     from sqlit.domains.connections.domain.config import ConnectionConfig
 
+_POSTGRES_SAFE_UNQUOTED_IDENTIFIER = re.compile(r"^[a-z_][a-z0-9_]*$")
+
 
 class PostgresBaseAdapter(CursorBasedAdapter):
     """Base class for PostgreSQL-compatible databases (PostgreSQL, CockroachDB).
@@ -119,6 +122,12 @@ class PostgresBaseAdapter(CursorBasedAdapter):
         escaped = name.replace('"', '""')
         return f'"{escaped}"'
 
+    def format_autocomplete_identifier(self, name: str) -> str:
+        """Quote autocomplete identifiers that PostgreSQL would otherwise fold."""
+        if _POSTGRES_SAFE_UNQUOTED_IDENTIFIER.fullmatch(name):
+            return name
+        return self.quote_identifier(name)
+
     def build_select_query(self, table: str, limit: int, database: str | None = None, schema: str | None = None) -> str:
         """Build SELECT LIMIT query for PostgreSQL."""
         schema = schema or "public"

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/process_worker/app/process_worker.py

@@ -2,14 +2,39 @@
 
 from __future__ import annotations
 
+import faulthandler
+import os
 import pickle
+import sys
+import tempfile
 import threading
 import time
 from collections import deque
 from dataclasses import dataclass, field
 from multiprocessing.connection import Connection
+from pathlib import Path
 from typing import Any
 
+
+def _open_worker_log() -> Any | None:
+    """Open the worker log file, honoring SQLIT_WORKER_LOG when set.
+
+    The parent process may attach this worker to a Textual-managed pipe;
+    libpq notice writes or unexpected stderr output would then SIGPIPE the
+    child. Redirecting both streams to a real file avoids that and gives a
+    place to land C-level fault tracebacks for future diagnosis.
+    """
+    override = os.environ.get("SQLIT_WORKER_LOG")
+    if override:
+        path = Path(override).expanduser()
+    else:
+        path = Path(tempfile.gettempdir()) / "sqlit-worker.log"
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path.open("a", buffering=1)
+    except OSError:
+        return None
+
 from sqlit.domains.connections.domain.config import ConnectionConfig
 from sqlit.domains.connections.providers.catalog import get_provider
 from sqlit.domains.connections.providers.config_service import normalize_connection_config
@@ -115,7 +140,14 @@ class _WorkerState:
             )
             return
 
-        if len(split_statements(query)) > 1:
+        from sqlit.domains.query.editing.comments import is_comment_only_statement
+
+        executable_statements = [
+            statement
+            for statement in split_statements(query)
+            if not is_comment_only_statement(statement)
+        ]
+        if len(executable_statements) > 1:
             self.send(
                 {
                     "type": "error",
@@ -493,6 +525,14 @@ class _WorkerState:
 
 def run_process_worker(conn: Connection) -> None:
     """Process entrypoint for query execution."""
+    log_file = _open_worker_log()
+    if log_file is not None:
+        sys.stdout = log_file
+        sys.stderr = log_file
+        try:
+            faulthandler.enable(file=log_file)
+        except (RuntimeError, ValueError):
+            pass
     state = _WorkerState(conn=conn)
     try:
         while True:

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/process_worker/app/process_worker_client.py

@@ -63,6 +63,14 @@ class ProcessWorkerClient:
             raise error
         if os.name != "posix" or sys.platform.startswith("win"):
             raise error
+        # macOS (especially Tahoe 26+) aborts in the child whenever a forked
+        # process touches CoreFoundation / Security.framework / os_log —
+        # which happens inside psycopg, getaddrinfo, and many other stdlib
+        # paths. Forking here causes hard segfaults (issue #189), so we
+        # surface the spawn failure and let the caller fall back to
+        # in-process execution.
+        if sys.platform == "darwin":
+            raise error
         try:
             self._start_with_context(get_context("fork"))
         except Exception:

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/query/app/multi_statement.py

@@ -19,7 +19,8 @@ if TYPE_CHECKING:
 def _iter_sql_chars(sql: str) -> Iterator[tuple[int, str, bool]]:
     """Iterate through SQL characters, tracking string literal context.
 
-    Handles escape sequences (backslash) and SQL-style doubled quotes.
+    Handles escape sequences (backslash), SQL-style doubled quotes,
+    and PostgreSQL dollar-quoted strings ($$ or $tag$).
 
     Yields:
         (index, char, outside_string) tuples where outside_string is True
@@ -27,9 +28,24 @@ def _iter_sql_chars(sql: str) -> Iterator[tuple[int, str, bool]]:
     """
     in_single_quote = False
     in_double_quote = False
+    in_dollar_tag: str | None = None
     i = 0
 
     while i < len(sql):
+        # If inside a dollar-quoted string, check for the closing tag
+        if in_dollar_tag is not None:
+            if sql[i:].startswith(in_dollar_tag):
+                # Yield the characters of the closing tag as inside string
+                for offset in range(len(in_dollar_tag)):
+                    yield (i + offset, sql[i + offset], False)
+                i += len(in_dollar_tag)
+                in_dollar_tag = None
+                continue
+            else:
+                yield (i, sql[i], False)
+                i += 1
+                continue
+
         char = sql[i]
 
         # Handle escape sequences in strings
@@ -51,6 +67,18 @@ def _iter_sql_chars(sql: str) -> Iterator[tuple[int, str, bool]]:
             i += 2
             continue
 
+        # Check for PostgreSQL dollar-quoted string start
+        if char == "$" and not in_single_quote and not in_double_quote:
+            # Match $[a-zA-Z_][a-zA-Z0-9_]*$ or $$
+            match = re.match(r"^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$", sql[i:])
+            if match:
+                delimiter = match.group(0)
+                in_dollar_tag = delimiter
+                for offset in range(len(delimiter)):
+                    yield (i + offset, sql[i + offset], False)
+                i += len(delimiter)
+                continue
+
         # Toggle quote state and yield
         if char == "'" and not in_double_quote:
             in_single_quote = not in_single_quote

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/query/completion/completion.py

@@ -21,7 +21,9 @@ from .core import (
     get_all_functions,
     get_all_keywords,
     get_current_word,
+    get_identifier_namespaces,
     get_last_token_info,
+    get_names_for_namespace,
     is_inside_string,
     remove_comments,
     remove_string_literals,
@@ -256,8 +258,11 @@ def get_completions(
 
     # Schema.table prefix → suggest tables after schema name
     # Pattern: FROM/JOIN schema. or schema.partial
-    if re.search(r"\b(FROM|JOIN)\s+\w+\.\w*$", clean_before, re.IGNORECASE):
-        return fuzzy_match(current_word, tables)
+    namespace_match = re.search(r"\b(?:FROM|JOIN)\s+(\w+)\.\w*$", clean_before, re.IGNORECASE)
+    if namespace_match:
+        namespace = namespace_match.group(1)
+        names = get_names_for_namespace(namespace, tables)
+        return fuzzy_match(current_word, names if names else tables)
 
     # ANY/ALL/SOME ( → suggest SELECT for subquery
     if re.search(r"\b(ANY|ALL|SOME)\s*\(\s*\w*$", clean_before, re.IGNORECASE):
@@ -326,6 +331,7 @@ def get_completions(
 
     for suggestion in suggestions:
         if suggestion.type == SuggestionType.TABLE:
+            results.extend(get_identifier_namespaces(tables))
             results.extend(tables)
             results.extend(cte_names)
 

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/query/completion/core.py

@@ -171,6 +171,84 @@ def fuzzy_match(text: str, candidates: list[str], max_results: int = 50) -> list
     return [r[2] for r in results[:max_results]]
 
 
+def split_identifier_parts(identifier: str) -> list[str]:
+    """Split a possibly quoted qualified identifier into unquoted parts."""
+    parts: list[str] = []
+    current: list[str] = []
+    quote: str | None = None
+    bracketed = False
+
+    for char in identifier:
+        if bracketed:
+            if char == "]":
+                bracketed = False
+            else:
+                current.append(char)
+            continue
+
+        if quote:
+            if char == quote:
+                quote = None
+            else:
+                current.append(char)
+            continue
+
+        if char == "[":
+            bracketed = True
+            continue
+        if char in {'"', "`"}:
+            quote = char
+            continue
+        if char == ".":
+            part = "".join(current).strip()
+            if part:
+                parts.append(part)
+            current = []
+            continue
+
+        current.append(char)
+
+    part = "".join(current).strip()
+    if part:
+        parts.append(part)
+    return parts
+
+
+def get_identifier_namespaces(identifiers: list[str]) -> list[str]:
+    """Return first qualifier parts from schema/database-qualified names."""
+    namespaces: list[str] = []
+    seen: set[str] = set()
+    for identifier in identifiers:
+        parts = split_identifier_parts(identifier)
+        if len(parts) < 2:
+            continue
+        namespace = parts[0]
+        key = namespace.lower()
+        if key not in seen:
+            seen.add(key)
+            namespaces.append(namespace)
+    return namespaces
+
+
+def get_names_for_namespace(namespace: str, identifiers: list[str]) -> list[str]:
+    """Return final identifier parts that belong to the requested namespace."""
+    namespace_lower = namespace.lower()
+    names: list[str] = []
+    seen: set[str] = set()
+
+    for identifier in identifiers:
+        parts = split_identifier_parts(identifier)
+        if len(parts) < 2 or parts[0].lower() != namespace_lower:
+            continue
+        name = parts[-1]
+        key = name.lower()
+        if key not in seen:
+            seen.add(key)
+            names.append(name)
+
+    return names
+
+
 def extract_table_refs(sql: str) -> list[TableRef]:
     """Extract table references and aliases from SQL.
 

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/query/ui/mixins/autocomplete_schema.py

@@ -403,12 +403,12 @@ class AutocompleteSchemaMixin:
             try:
                 entries: list[tuple[str, list[tuple[str, tuple[str, str, str | None]]]]] = []
                 for schema_name, table_name in tables:
+                    display_name = dialect.format_table_name(schema_name, table_name)
                     if single_db:
-                        full_name = table_name
+                        full_name = display_name
                     else:
                         full_name = dialect.qualified_name(database, schema_name, table_name)
 
-                    display_name = dialect.format_table_name(schema_name, table_name)
                     metadata = [
                         (display_name.lower(), (schema_name, table_name, database)),
                         (table_name.lower(), (schema_name, table_name, database)),
@@ -486,12 +486,12 @@ class AutocompleteSchemaMixin:
             try:
                 entries: list[tuple[str, list[tuple[str, tuple[str, str, str | None]]]]] = []
                 for schema_name, view_name in views:
+                    display_name = dialect.format_table_name(schema_name, view_name)
                     if single_db:
-                        full_name = view_name
+                        full_name = display_name
                     else:
                         full_name = dialect.qualified_name(database, schema_name, view_name)
 
-                    display_name = dialect.format_table_name(schema_name, view_name)
                     metadata = [
                         (display_name.lower(), (schema_name, view_name, database)),
                         (view_name.lower(), (schema_name, view_name, database)),
@@ -799,16 +799,16 @@ class AutocompleteSchemaMixin:
                         db_arg = self._get_metadata_db_arg(database)
                     tables = await run_db_call(inspector.get_tables, connection, db_arg)
                     for schema_name, table_name in tables:
+                        display_name = dialect.format_table_name(schema_name, table_name)
                         # Use simple name if we have a default database, full qualifier otherwise
                         if len(databases) == 1:
-                            # Single database - use simple table name
-                            schema_cache["tables"].append(table_name)
+                            # Single database - omit only the provider's default schema
+                            schema_cache["tables"].append(display_name)
                         else:
                             # Multiple databases - use qualified identifier
                             full_name = dialect.qualified_name(database, schema_name, table_name)
                             schema_cache["tables"].append(full_name)
                         # Keep metadata for column loading (multiple keys for flexible lookup)
-                        display_name = dialect.format_table_name(schema_name, table_name)
                         table_metadata[display_name.lower()] = (schema_name, table_name, database)
                         table_metadata[table_name.lower()] = (schema_name, table_name, database)
                         if database:
@@ -820,16 +820,16 @@ class AutocompleteSchemaMixin:
                     # Get views
                     views = await run_db_call(inspector.get_views, connection, db_arg)
                     for schema_name, view_name in views:
+                        display_name = dialect.format_table_name(schema_name, view_name)
                         # Use simple name if we have a default database, full qualifier otherwise
                         if len(databases) == 1:
-                            # Single database - use simple view name
-                            schema_cache["views"].append(view_name)
+                            # Single database - omit only the provider's default schema
+                            schema_cache["views"].append(display_name)
                         else:
                             # Multiple databases - use qualified identifier
                             full_name = dialect.qualified_name(database, schema_name, view_name)
                             schema_cache["views"].append(full_name)
                         # Keep metadata for column loading (multiple keys for flexible lookup)
-                        display_name = dialect.format_table_name(schema_name, view_name)
                         table_metadata[display_name.lower()] = (schema_name, view_name, database)
                         table_metadata[view_name.lower()] = (schema_name, view_name, database)
                         if database:

{sqlit_tui-1.5.0 → sqlit_tui-1.5.2}/sqlit/domains/query/ui/mixins/autocomplete_suggestions.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from typing import cast
 
 from sqlit.domains.query.completion import (
     SuggestionType,
@@ -16,6 +17,46 @@ from sqlit.shared.ui.protocols import AutocompleteMixinHost
 class AutocompleteSuggestionsMixin:
     """Mixin providing SQL autocomplete suggestion logic."""
 
+    def _format_autocomplete_identifier(self: AutocompleteMixinHost, name: str) -> str:
+        provider = getattr(self, "current_provider", None)
+        formatter = getattr(getattr(provider, "dialect", None), "format_autocomplete_identifier", None)
+        if callable(formatter):
+            return cast(str, formatter(name))
+        return name
+
+    def _format_autocomplete_name(self: AutocompleteMixinHost, name: str) -> str:
+        if any(marker in name for marker in ('"', "`", "[", "]")):
+            return name
+        table_metadata = getattr(self, "_table_metadata", {}) or {}
+        metadata = table_metadata.get(name.lower())
+        if metadata:
+            schema_name, object_name, _database = metadata
+            provider = getattr(self, "current_provider", None)
+            default_schema = getattr(getattr(provider, "capabilities", None), "default_schema", None)
+            formatted_object = AutocompleteSuggestionsMixin._format_autocomplete_identifier(self, object_name)
+            if schema_name and schema_name != default_schema and name.lower().startswith(f"{schema_name.lower()}."):
+                formatted_schema = AutocompleteSuggestionsMixin._format_autocomplete_identifier(self, schema_name)
+                return f"{formatted_schema}.{formatted_object}"
+            return formatted_object
+        if "." not in name:
+            return AutocompleteSuggestionsMixin._format_autocomplete_identifier(self, name)
+        return ".".join(
+            AutocompleteSuggestionsMixin._format_autocomplete_identifier(self, part)
+            for part in name.split(".")
+        )
+
+    def _format_autocomplete_columns(
+        self: AutocompleteMixinHost,
+        columns: dict[str, list[str]],
+    ) -> dict[str, list[str]]:
+        return {
+            table_key: [
+                AutocompleteSuggestionsMixin._format_autocomplete_identifier(self, column)
+                for column in column_names
+            ]
+            for table_key, column_names in columns.items()
+        }
+
     def _get_current_word(self: AutocompleteMixinHost, text: str, cursor_pos: int) -> str:
         """Get the word currently being typed at cursor position."""
         before_cursor = text[:cursor_pos]
@@ -64,8 +105,13 @@ class AutocompleteSuggestionsMixin:
     def _get_autocomplete_suggestions(self: AutocompleteMixinHost, text: str, cursor_pos: int) -> list[str]:
         """Get autocomplete suggestions using the SQL completion engine."""
         # Build schema data for get_completions
-        tables = self._schema_cache.get("tables", []) + self._schema_cache.get("views", [])
-        columns = self._schema_cache.get("columns", {})
+        raw_tables = self._schema_cache.get("tables", []) + self._schema_cache.get("views", [])
+        raw_columns = self._schema_cache.get("columns", {})
+        tables = [
+            AutocompleteSuggestionsMixin._format_autocomplete_name(self, table)
+            for table in raw_tables
+        ]
+        columns = AutocompleteSuggestionsMixin._format_autocomplete_columns(self, raw_columns)
         procedures = self._schema_cache.get("procedures", [])
 
         # First check if we need to lazy-load columns before calling get_completions
@@ -81,7 +127,7 @@ class AutocompleteSuggestionsMixin:
                 been loaded yet. Returning Loading... for an unknown key would
                 wedge forever because the loader skips unknown tables silently.
                 """
-                if key in columns:
+                if key in raw_columns:
                     return False
                 if key not in table_metadata:
                     return False
@@ -102,7 +148,7 @@ class AutocompleteSuggestionsMixin:
                     scope = suggestion.table_scope
                     if scope:
                         scope_lower = scope.lower()
-                        table_key = alias_map.get(scope_lower, scope_lower)
+                        table_key = alias_map.get(scope_lower, scope_lower).lower()
 
                         if needs_column_load(table_key) and table_key not in loading:
                             self._load_columns_for_table(table_key)