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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlit-tui
-Version: 1.5.1
+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

{sqlit_tui-1.5.1 → 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.1'
-__version_tuple__ = version_tuple = (1, 5, 1)
+__version__ = version = '1.5.2'
+__version_tuple__ = version_tuple = (1, 5, 2)
 
 __commit_id__ = commit_id = None

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

@@ -490,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",
@@ -502,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",

{sqlit_tui-1.5.1 → 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.1 → 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.1 → sqlit_tui-1.5.2}/sqlit/domains/process_worker/app/process_worker.py

@@ -140,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",

{sqlit_tui-1.5.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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)

{sqlit_tui-1.5.1 → sqlit_tui-1.5.2}/sqlit/domains/results/ui/mixins/results.py

@@ -1050,11 +1050,14 @@ class ResultsMixin:
             return "'" + str(v).replace("'", "''") + "'"
 
         # Get table name and primary key columns
-        table_name = "<table>"
+        qualified_name = "<table>"
         pk_column_names: set[str] = set()
         table_info = self._get_active_results_table_info(table, _stacked)
         if table_info:
-            table_name = table_info.get("name", table_name)
+            database_name = table_info.get("database")
+            schema_name = table_info.get("schema")
+            table_name = table_info.get("name")
+            qualified_name = self.current_provider.dialect.qualified_name(database_name, schema_name, table_name)
             # Get PK columns from column info
             for col in table_info.get("columns", []):
                 if col.is_primary_key:
@@ -1090,7 +1093,7 @@ class ResultsMixin:
         where_clause = " AND ".join(where_parts)
 
         # Generate DELETE query for the row
-        query = f"DELETE FROM {table_name} WHERE {where_clause};"
+        query = f"DELETE FROM {qualified_name} WHERE {where_clause};"
 
         # Set query and switch to insert mode
         self._suppress_autocomplete_once = True
@@ -1147,10 +1150,14 @@ class ResultsMixin:
             return "'" + str(v).replace("'", "''") + "'"
 
         # Get table name and primary key columns
-        table_name = "<table>"
+        qualified_name = "<table>"
         pk_column_names: set[str] = set()
         if table_info:
-            table_name = table_info.get("name", table_name)
+            database_name = table_info.get("database")
+            schema_name = table_info.get("schema")
+            table_name = table_info.get("name")
+            qualified_name = self.current_provider.dialect.qualified_name(database_name, schema_name, table_name)
+
             # Get PK columns from column info
             for col in table_info.get("columns", []):
                 if col.is_primary_key:
@@ -1182,7 +1189,7 @@ class ResultsMixin:
         where_clause = " AND ".join(where_parts)
 
         # Generate UPDATE query with empty placeholder for the new value
-        query = f"UPDATE {table_name} SET {column_name} = '' WHERE {where_clause};"
+        query = f"UPDATE {qualified_name} SET {column_name} = '' WHERE {where_clause};"
 
         # Find position inside the empty quotes (after "SET column = '")
         set_prefix = f"SET {column_name} = '"

{sqlit_tui-1.5.1 → sqlit_tui-1.5.2}/tests/cli/test_cli_main.py

@@ -15,7 +15,12 @@ def _run_cli_with_stdin(*args: str, stdin: str, env_config_dir: Path) -> subproc
         input=stdin,
         capture_output=True,
         text=True,
-        env={"SQLIT_CONFIG_DIR": str(env_config_dir), "PATH": __import__("os").environ.get("PATH", "")},
+        cwd=str(env_config_dir),
+        env={
+            "SQLIT_CONFIG_DIR": str(env_config_dir),
+            "PATH": __import__("os").environ.get("PATH", ""),
+            "PYTHONPATH": __import__("os").environ.get("PYTHONPATH", ""),
+        },
     )
 
 
@@ -118,3 +123,23 @@ def test_password_stdin_eof_errors_cleanly(tmp_path: Path):
 
     assert result.returncode != 0
     assert "EOF" in (result.stderr + result.stdout)
+
+
+def test_cli_version_option(tmp_path: Path):
+    result = _run_cli_with_stdin(
+        "--version",
+        stdin="",
+        env_config_dir=tmp_path,
+    )
+    assert result.returncode == 0
+    assert "sqlit" in result.stdout
+
+
+def test_cli_version_short_option(tmp_path: Path):
+    result = _run_cli_with_stdin(
+        "-v",
+        stdin="",
+        env_config_dir=tmp_path,
+    )
+    assert result.returncode == 0
+    assert "sqlit" in result.stdout