sqlsaber 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

sqlsaber/application/db_setup.py

@@ -1,7 +1,7 @@
 """Shared database setup logic for onboarding and CLI."""
 
 import getpass
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from sqlsaber.application.prompts import Prompter
@@ -11,6 +11,21 @@ from sqlsaber.theme.manager import create_console
 console = create_console()
 
 
+def _normalize_schemas(schemas: list[str]) -> list[str]:
+    """Deduplicate schema list while preserving order and case."""
+    normalized: list[str] = []
+    seen: set[str] = set()
+    for schema in schemas:
+        name = schema.strip()
+        if not name:
+            continue
+        if name in seen:
+            continue
+        seen.add(name)
+        normalized.append(name)
+    return normalized
+
+
 @dataclass
 class DatabaseInput:
     """Input data for database configuration."""
@@ -26,6 +41,7 @@ class DatabaseInput:
     ssl_ca: str | None = None
     ssl_cert: str | None = None
     ssl_key: str | None = None
+    exclude_schemas: list[str] = field(default_factory=list)
 
 
 async def collect_db_input(
@@ -69,11 +85,20 @@ async def collect_db_input(
         port = 0
         username = db_type
         password = ""
+        exclude_schemas: list[str] = []
         ssl_mode = None
         ssl_ca = None
         ssl_cert = None
         ssl_key = None
 
+        if db_type == "duckdb":
+            exclude_prompt = await prompter.text(
+                "Schemas to exclude (comma separated, optional):", default=""
+            )
+            if exclude_prompt is None:
+                return None
+            exclude_schemas = _normalize_schemas(exclude_prompt.split(","))
+
     else:
         # PostgreSQL/MySQL need connection details
         host = await prompter.text("Host:", default="localhost")
@@ -155,6 +180,13 @@ async def collect_db_input(
                                 "SSL client private key file:"
                             )
 
+        exclude_prompt = await prompter.text(
+            "Schemas to exclude (comma separated, optional):", default=""
+        )
+        if exclude_prompt is None:
+            return None
+        exclude_schemas = _normalize_schemas(exclude_prompt.split(","))
+
     return DatabaseInput(
         name=name,
         type=db_type,
@@ -167,6 +199,7 @@ async def collect_db_input(
         ssl_ca=ssl_ca,
         ssl_cert=ssl_cert,
         ssl_key=ssl_key,
+        exclude_schemas=exclude_schemas,
     )
 
 
@@ -183,6 +216,7 @@ def build_config(db_input: DatabaseInput) -> DatabaseConfig:
         ssl_ca=db_input.ssl_ca,
         ssl_cert=db_input.ssl_cert,
         ssl_key=db_input.ssl_key,
+        exclude_schemas=_normalize_schemas(db_input.exclude_schemas),
     )
 
 
@@ -200,7 +234,9 @@ async def test_connection(config: DatabaseConfig, password: str | None) -> bool:
 
     try:
         connection_string = config.to_connection_string()
-        db_conn = DatabaseConnection(connection_string)
+        db_conn = DatabaseConnection(
+            connection_string, excluded_schemas=config.exclude_schemas
+        )
         await db_conn.execute_query("SELECT 1 as test")
         await db_conn.close()
         return True

sqlsaber/cli/commands.py

@@ -214,7 +214,9 @@ def query(
 
         # Create database connection
         try:
-            db_conn = DatabaseConnection(connection_string)
+            db_conn = DatabaseConnection(
+                connection_string, excluded_schemas=resolved.excluded_schemas
+            )
             log.info("db.connection.created", db_type=type(db_conn).__name__)
         except Exception as e:
             log.exception("db.connection.error", error=str(e))
@@ -229,8 +231,10 @@ def query(
                 # Single query mode with streaming
                 streaming_handler = StreamingQueryHandler(console)
                 db_type = sqlsaber_agent.db_type
+                model_name = sqlsaber_agent.agent.model.model_name
                 console.print(
                     f"[primary]Connected to:[/primary] {db_name} ({db_type})\n"
+                    f"[primary]Model:[/primary] {model_name}\n"
                 )
                 log.info("query.execute.start", db_name=db_name, db_type=db_type)
                 run = await streaming_handler.execute_streaming_query(

sqlsaber/cli/database.py

@@ -26,6 +26,28 @@ db_app = cyclopts.App(
 )
 
 
+def _normalize_schema_list(raw_schemas: list[str]) -> list[str]:
+    """Deduplicate schemas while preserving order and case."""
+    schemas: list[str] = []
+    seen: set[str] = set()
+    for schema in raw_schemas:
+        item = schema.strip()
+        if not item:
+            continue
+        if item in seen:
+            continue
+        seen.add(item)
+        schemas.append(item)
+    return schemas
+
+
+def _parse_schema_list(raw: str | None) -> list[str]:
+    """Parse comma-separated schema list into cleaned list."""
+    if not raw:
+        return []
+    return _normalize_schema_list(raw.split(","))
+
+
 @db_app.command
 def add(
     name: Annotated[str, cyclopts.Parameter(help="Name for the database connection")],
@@ -71,6 +93,13 @@ def add(
         str | None,
         cyclopts.Parameter(["--ssl-key"], help="SSL client private key file path"),
     ] = None,
+    exclude_schemas: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            ["--exclude-schemas"],
+            help="Comma-separated list of schemas to exclude from introspection",
+        ),
+    ] = None,
     interactive: Annotated[
         bool,
         cyclopts.Parameter(
@@ -119,6 +148,7 @@ def add(
         ssl_ca = db_input.ssl_ca
         ssl_cert = db_input.ssl_cert
         ssl_key = db_input.ssl_key
+        exclude_schema_list = _normalize_schema_list(db_input.exclude_schemas)
     else:
         # Non-interactive mode - use provided values or defaults
         if type == "sqlite":
@@ -160,6 +190,7 @@ def add(
                 if questionary.confirm("Enter password?").ask()
                 else ""
             )
+        exclude_schema_list = _parse_schema_list(exclude_schemas)
 
     # Create database config
     # At this point, all required values should be set
@@ -180,6 +211,7 @@ def add(
         ssl_ca=ssl_ca,
         ssl_cert=ssl_cert,
         ssl_key=ssl_key,
+        exclude_schemas=exclude_schema_list,
     )
 
     try:
@@ -219,6 +251,7 @@ def list():
     table.add_column("Port", style="warning")
     table.add_column("Database", style="info")
     table.add_column("Username", style="info")
+    table.add_column("Excluded Schemas", style="muted")
     table.add_column("SSL", style="success")
     table.add_column("Default", style="error")
 
@@ -241,6 +274,7 @@ def list():
             str(db.port) if db.port else "",
             db.database,
             db.username,
+            ", ".join(db.exclude_schemas) if db.exclude_schemas else "",
             ssl_status,
             is_default,
         )
@@ -249,6 +283,116 @@ def list():
     logger.info("db.list.complete", count=len(databases))
 
 
+@db_app.command
+def exclude(
+    name: Annotated[
+        str,
+        cyclopts.Parameter(help="Name of the database connection to update"),
+    ],
+    set_schemas: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            ["--set"],
+            help="Replace excluded schemas with this comma-separated list",
+        ),
+    ] = None,
+    add_schemas: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            ["--add"],
+            help="Add comma-separated schemas to the existing exclude list",
+        ),
+    ] = None,
+    remove_schemas: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            ["--remove"],
+            help="Remove comma-separated schemas from the existing exclude list",
+        ),
+    ] = None,
+    clear: Annotated[
+        bool,
+        cyclopts.Parameter(
+            ["--clear", "--no-clear"],
+            help="Clear all excluded schemas",
+        ),
+    ] = False,
+):
+    """Update excluded schemas for a database connection."""
+    logger.info(
+        "db.exclude.start",
+        name=name,
+        set=bool(set_schemas),
+        add=bool(add_schemas),
+        remove=bool(remove_schemas),
+        clear=clear,
+    )
+    db_config = config_manager.get_database(name)
+    if not db_config:
+        console.print(
+            f"[bold error]Error: Database connection '{name}' not found[/bold error]"
+        )
+        logger.error("db.exclude.not_found", name=name)
+        sys.exit(1)
+
+    actions_selected = sum(
+        bool(flag)
+        for flag in [
+            set_schemas is not None,
+            add_schemas is not None,
+            remove_schemas is not None,
+            clear,
+        ]
+    )
+    if actions_selected > 1:
+        console.print(
+            "[bold error]Error: Specify only one of --set, --add, --remove, or --clear[/bold error]"
+        )
+        logger.error("db.exclude.multiple_actions", name=name)
+        sys.exit(1)
+
+    current = [*(db_config.exclude_schemas or [])]
+
+    if clear:
+        updated = []
+    elif set_schemas is not None:
+        updated = _parse_schema_list(set_schemas)
+    elif add_schemas is not None:
+        additions = _parse_schema_list(add_schemas)
+        updated = [*current]
+        current_set = set(current)
+        for schema in additions:
+            if schema not in current_set:
+                updated.append(schema)
+                current_set.add(schema)
+    elif remove_schemas is not None:
+        removals = set(_parse_schema_list(remove_schemas))
+        updated = [schema for schema in current if schema not in removals]
+    else:
+        console.print(
+            "[info]Update excluded schemas for "
+            f"[primary]{name}[/primary] (leave blank to clear)[/info]"
+        )
+        default_value = ", ".join(current)
+        response = questionary.text(
+            "Schemas to exclude (comma separated):", default=default_value
+        ).ask()
+        if response is None:
+            console.print("[warning]Operation cancelled[/warning]")
+            logger.info("db.exclude.cancelled", name=name)
+            return
+        updated = _parse_schema_list(response)
+
+    db_config.exclude_schemas = _normalize_schema_list(updated)
+    config_manager.update_database(db_config)
+
+    console.print(
+        f"[success]Updated excluded schemas for '{name}':[/success] "
+        f"{', '.join(db_config.exclude_schemas) if db_config.exclude_schemas else '(none)'}"
+    )
+    logger.info("db.exclude.success", name=name, count=len(db_config.exclude_schemas))
+
+
 @db_app.command
 def remove(
     name: Annotated[
@@ -259,7 +403,7 @@ def remove(
     logger.info("db.remove.start", name=name)
     if not config_manager.get_database(name):
         console.print(
-            f"[bold error]Error:[/bold error] Database connection '{name}' not found"
+            f"[bold error]Error: Database connection '{name}' not found[/bold error]"
         )
         logger.error("db.remove.not_found", name=name)
         sys.exit(1)
@@ -269,17 +413,17 @@ def remove(
     ).ask():
         if config_manager.remove_database(name):
             console.print(
-                f"[green]Successfully removed database connection '{name}'[/green]"
+                f"[success]Successfully removed database connection '{name}'[/success]"
             )
             logger.info("db.remove.success", name=name)
         else:
             console.print(
-                f"[bold error]Error:[/bold error] Failed to remove database connection '{name}'"
+                f"[bold error]Error: Failed to remove database connection '{name}'[/bold error]"
             )
             logger.error("db.remove.failed", name=name)
             sys.exit(1)
     else:
-        console.print("Operation cancelled")
+        console.print("[warning]Operation cancelled[/warning]")
         logger.info("db.remove.cancelled", name=name)
 
 
@@ -294,17 +438,19 @@ def set_default(
     logger.info("db.default.start", name=name)
     if not config_manager.get_database(name):
         console.print(
-            f"[bold error]Error:[/bold error] Database connection '{name}' not found"
+            f"[bold error]Error: Database connection '{name}' not found[/bold error]"
         )
         logger.error("db.default.not_found", name=name)
         sys.exit(1)
 
     if config_manager.set_default_database(name):
-        console.print(f"[green]Successfully set '{name}' as default database[/green]")
+        console.print(
+            f"[success]Successfully set '{name}' as default database[/success]"
+        )
         logger.info("db.default.success", name=name)
     else:
         console.print(
-            f"[bold error]Error:[/bold error] Failed to set '{name}' as default"
+            f"[bold error]Error: Failed to set '{name}' as default[/bold error]"
         )
         logger.error("db.default.failed", name=name)
         sys.exit(1)
@@ -330,7 +476,7 @@ def test(
             db_config = config_manager.get_database(name)
             if not db_config:
                 console.print(
-                    f"[bold error]Error:[/bold error] Database connection '{name}' not found"
+                    f"[bold error]Error: Database connection '{name}' not found[/bold error]"
                 )
                 logger.error("db.test.not_found", name=name)
                 sys.exit(1)
@@ -338,7 +484,7 @@ def test(
             db_config = config_manager.get_default_database()
             if not db_config:
                 console.print(
-                    "[bold error]Error:[/bold error] No default database configured"
+                    "[bold error]Error: No default database configured[/bold error]"
                 )
                 console.print(
                     "Use 'sqlsaber db add <name>' to add a database connection"
@@ -350,14 +496,16 @@ def test(
 
         try:
             connection_string = db_config.to_connection_string()
-            db_conn = DatabaseConnection(connection_string)
+            db_conn = DatabaseConnection(
+                connection_string, excluded_schemas=db_config.exclude_schemas
+            )
 
             # Try to connect and run a simple query
             await db_conn.execute_query("SELECT 1 as test")
             await db_conn.close()
 
             console.print(
-                f"[green]✓ Connection to '{db_config.name}' successful[/green]"
+                f"[success]✓ Connection to '{db_config.name}' successful[/success]"
             )
             logger.info("db.test.success", name=db_config.name)
 
@@ -369,7 +517,7 @@ def test(
                 ),
                 error=str(e),
             )
-            console.print(f"[bold error]✗ Connection failed:[/bold error] {e}")
+            console.print(f"[bold error]✗ Connection failed: {e}[/bold error]")
             sys.exit(1)
 
     asyncio.run(test_connection())

sqlsaber/cli/interactive.py

@@ -135,8 +135,10 @@ class InteractiveSession:
             )
 
         db_name = self.database_name or "Unknown"
+        model_name = self.sqlsaber_agent.agent.model.model_name
         self.console.print(
             f"[heading]\nConnected to {db_name} ({self._db_type_name()})[/heading]\n"
+            f"[heading]Model: {model_name}[/heading]\n"
         )
 
         if self._thread_id:

sqlsaber/cli/threads.py

@@ -229,7 +229,7 @@ def list_threads(
         logger.info("threads.cli.list.empty")
         return
     table = Table(title="Threads")
-    table.add_column("ID", style=tm.style("info"))
+    table.add_column("ID", style=tm.style("info"), no_wrap=True, min_width=36)
     table.add_column("Database", style=tm.style("accent"))
     table.add_column("Title", style=tm.style("success"))
     table.add_column("Last Activity", style=tm.style("muted"))
@@ -318,7 +318,9 @@ def resume(
             )
             return
 
-        db_conn = DatabaseConnection(connection_string)
+        db_conn = DatabaseConnection(
+            connection_string, excluded_schemas=resolved.excluded_schemas
+        )
         try:
             sqlsaber_agent = SQLSaberAgent(db_conn, db_name)
             history = await store.get_thread_messages(thread_id)

sqlsaber/config/database.py

@@ -4,7 +4,7 @@ import json
 import os
 import platform
 import stat
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 from urllib.parse import quote_plus
@@ -29,6 +29,7 @@ class DatabaseConfig:
     ssl_cert: str | None = None
     ssl_key: str | None = None
     schema: str | None = None
+    exclude_schemas: list[str] = field(default_factory=list)
 
     def to_connection_string(self) -> str:
         """Convert config to database connection string."""
@@ -149,6 +150,7 @@ class DatabaseConfig:
             "ssl_cert": self.ssl_cert,
             "ssl_key": self.ssl_key,
             "schema": self.schema,
+            "exclude_schemas": self.exclude_schemas,
         }
 
     @classmethod
@@ -166,6 +168,7 @@ class DatabaseConfig:
             ssl_cert=data.get("ssl_cert"),
             ssl_key=data.get("ssl_key"),
             schema=data.get("schema"),
+            exclude_schemas=list(data.get("exclude_schemas", [])),
         )
 
 
@@ -246,6 +249,16 @@ class DatabaseConfigManager:
 
         self._save_config(config)
 
+    def update_database(self, db_config: DatabaseConfig) -> None:
+        """Update an existing database configuration."""
+        config = self._load_config()
+
+        if db_config.name not in config["connections"]:
+            raise ValueError(f"Database '{db_config.name}' does not exist")
+
+        config["connections"][db_config.name] = db_config.to_dict()
+        self._save_config(config)
+
     def get_database(self, name: str) -> DatabaseConfig | None:
         """Get a database configuration by name."""
         config = self._load_config()

sqlsaber/database/__init__.py

@@ -1,5 +1,7 @@
 """Database module for SQLSaber."""
 
+from collections.abc import Iterable
+
 from .base import (
     DEFAULT_QUERY_TIMEOUT,
     BaseDatabaseConnection,
@@ -18,23 +20,28 @@ from .schema import SchemaManager
 from .sqlite import SQLiteConnection, SQLiteSchemaIntrospector
 
 
-def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
+def DatabaseConnection(
+    connection_string: str, *, excluded_schemas: Iterable[str] | None = None
+) -> BaseDatabaseConnection:
     """Factory function to create appropriate database connection based on connection string."""
     if connection_string.startswith("postgresql://"):
-        return PostgreSQLConnection(connection_string)
+        conn = PostgreSQLConnection(connection_string)
     elif connection_string.startswith("mysql://"):
-        return MySQLConnection(connection_string)
+        conn = MySQLConnection(connection_string)
     elif connection_string.startswith("sqlite:///"):
-        return SQLiteConnection(connection_string)
+        conn = SQLiteConnection(connection_string)
     elif connection_string.startswith("duckdb://"):
-        return DuckDBConnection(connection_string)
+        conn = DuckDBConnection(connection_string)
     elif connection_string.startswith("csv:///"):
-        return CSVConnection(connection_string)
+        conn = CSVConnection(connection_string)
     else:
         raise ValueError(
             f"Unsupported database type in connection string: {connection_string}"
         )
 
+    conn.set_excluded_schemas(excluded_schemas)
+    return conn
+
 
 __all__ = [
     # Base classes and types

sqlsaber/database/base.py

@@ -1,6 +1,8 @@
 """Base classes and type definitions for database connections and schema introspection."""
 
+import os
 from abc import ABC, abstractmethod
+from collections.abc import Iterable
 from typing import Any, TypedDict
 
 # Default query timeout to prevent runaway queries
@@ -62,6 +64,7 @@ class BaseDatabaseConnection(ABC):
     def __init__(self, connection_string: str):
         self.connection_string = connection_string
         self._pool = None
+        self._excluded_schemas: list[str] = []
 
     @property
     @abstractmethod
@@ -95,6 +98,27 @@ class BaseDatabaseConnection(ABC):
         """
         pass
 
+    def set_excluded_schemas(self, schemas: Iterable[str] | None) -> None:
+        """Set schemas to exclude from introspection for this connection."""
+        self._excluded_schemas = []
+        if not schemas:
+            return
+
+        seen: set[str] = set()
+        for schema in schemas:
+            clean = schema.strip()
+            if not clean:
+                continue
+            if clean in seen:
+                continue
+            seen.add(clean)
+            self._excluded_schemas.append(clean)
+
+    @property
+    def excluded_schemas(self) -> list[str]:
+        """Return list of excluded schemas for this connection."""
+        return list(self._excluded_schemas)
+
 
 class BaseSchemaIntrospector(ABC):
     """Abstract base class for database-specific schema introspection."""
@@ -130,3 +154,36 @@ class BaseSchemaIntrospector(ABC):
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information."""
         pass
+
+    @staticmethod
+    def _merge_excluded_schemas(
+        connection: BaseDatabaseConnection,
+        defaults: Iterable[str],
+        env_var: str | None = None,
+    ) -> list[str]:
+        """Combine default, connection, and environment schema exclusions."""
+
+        combined: list[str] = []
+        seen: set[str] = set()
+
+        def _add(items: Iterable[str]) -> None:
+            for item in items:
+                name = item.strip()
+                if not name:
+                    continue
+                if name in seen:
+                    continue
+                seen.add(name)
+                combined.append(name)
+
+        _add(defaults)
+        _add(getattr(connection, "excluded_schemas", []) or [])
+
+        if env_var:
+            raw = os.getenv(env_var, "")
+            if raw:
+                # Support comma-separated values
+                values = [part.strip() for part in raw.split(",")]
+                _add(values)
+
+        return combined

sqlsaber/database/duckdb.py

@@ -95,6 +95,13 @@ class DuckDBConnection(BaseDatabaseConnection):
 class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
     """DuckDB-specific schema introspection."""
 
+    def _get_excluded_schemas(self, connection) -> list[str]:
+        """Return schemas to exclude during introspection."""
+        defaults = ["information_schema", "pg_catalog", "duckdb_catalog"]
+        return self._merge_excluded_schemas(
+            connection, defaults, env_var="SQLSABER_DUCKDB_EXCLUDE_SCHEMAS"
+        )
+
     async def _execute_query(
         self,
         connection,
@@ -131,11 +138,15 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
         self, connection, table_pattern: str | None = None
     ) -> list[dict[str, Any]]:
         """Get tables information for DuckDB."""
-        where_conditions = [
-            "t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')"
-        ]
+        excluded = self._get_excluded_schemas(connection)
+        where_conditions: list[str] = []
         params: list[Any] = []
 
+        if excluded:
+            placeholders = ", ".join(["?"] * len(excluded))
+            where_conditions.append(f"t.table_schema NOT IN ({placeholders})")
+            params.extend(excluded)
+
         if table_pattern:
             if "." in table_pattern:
                 schema_pattern, table_name_pattern = table_pattern.split(".", 1)
@@ -149,6 +160,9 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
                 )
                 params.extend([table_pattern, table_pattern])
 
+        if not where_conditions:
+            where_conditions.append("1=1")
+
         query = f"""
             SELECT
                 t.table_schema,
@@ -316,7 +330,16 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
 
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for DuckDB."""
-        query = """
+        excluded = self._get_excluded_schemas(connection)
+        params: list[Any] = []
+        if excluded:
+            placeholders = ", ".join(["?"] * len(excluded))
+            where_clause = f"WHERE t.table_schema NOT IN ({placeholders})"
+            params.extend(excluded)
+        else:
+            where_clause = ""
+
+        query = f"""
             SELECT
                 t.table_schema,
                 t.table_name,
@@ -326,8 +349,8 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
             LEFT JOIN duckdb_tables() dt
                 ON t.table_schema = dt.schema_name
                 AND t.table_name = dt.table_name
-            WHERE t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')
+            {where_clause}
             ORDER BY t.table_schema, t.table_name;
         """
 
-        return await self._execute_query(connection, query)
+        return await self._execute_query(connection, query, tuple(params))

sqlsaber/database/mysql.py

@@ -153,6 +153,13 @@ class MySQLConnection(BaseDatabaseConnection):
 class MySQLSchemaIntrospector(BaseSchemaIntrospector):
     """MySQL-specific schema introspection."""
 
+    def _get_excluded_schemas(self, connection) -> list[str]:
+        """Return schemas to exclude during introspection."""
+        defaults = ["information_schema", "performance_schema", "mysql", "sys"]
+        return self._merge_excluded_schemas(
+            connection, defaults, env_var="SQLSABER_MYSQL_EXCLUDE_SCHEMAS"
+        )
+
     def _build_table_filter_clause(self, tables: list) -> tuple[str, list]:
         """Build row constructor with bind parameters for table filtering.
 
@@ -178,10 +185,14 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
         async with pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # Build WHERE clause for filtering
-                where_conditions = [
-                    "table_schema NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')"
-                ]
-                params = []
+                excluded = self._get_excluded_schemas(connection)
+                where_conditions = []
+                params: list[Any] = []
+
+                if excluded:
+                    placeholders = ", ".join(["%s"] * len(excluded))
+                    where_conditions.append(f"table_schema NOT IN ({placeholders})")
+                    params.extend(excluded)
 
                 if table_pattern:
                     # Support patterns like 'schema.table' or just 'table'
@@ -197,6 +208,9 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         )
                         params.extend([table_pattern, table_pattern])
 
+                if not where_conditions:
+                    where_conditions.append("1=1")
+
                 # Get tables
                 tables_query = f"""
                     SELECT
@@ -329,17 +343,26 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
         async with pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # Get tables without row counts for better performance
-                tables_query = """
+                excluded = self._get_excluded_schemas(connection)
+                params: list[Any] = []
+                if excluded:
+                    placeholders = ", ".join(["%s"] * len(excluded))
+                    where_clause = f"WHERE t.table_schema NOT IN ({placeholders})"
+                    params.extend(excluded)
+                else:
+                    where_clause = ""
+
+                tables_query = f"""
                     SELECT
                         t.table_schema,
                         t.table_name,
                         t.table_type,
                         t.table_comment
                     FROM information_schema.tables t
-                    WHERE t.table_schema NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')
+                    {where_clause}
                     ORDER BY t.table_schema, t.table_name;
                 """
-                await cursor.execute(tables_query)
+                await cursor.execute(tables_query, params if params else None)
                 rows = await cursor.fetchall()
 
                 # Convert rows to dictionaries

sqlsaber/database/postgresql.py

@@ -135,7 +135,7 @@ class PostgreSQLConnection(BaseDatabaseConnection):
 class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
     """PostgreSQL-specific schema introspection."""
 
-    def _get_excluded_schemas(self) -> list[str]:
+    def _get_excluded_schemas(self, connection) -> list[str]:
         """Return schemas to exclude during introspection.
 
         Defaults include PostgreSQL system schemas and TimescaleDB internal
@@ -143,10 +143,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         environment variable `SQLSABER_PG_EXCLUDE_SCHEMAS` to a comma-separated
         list of schema names.
         """
-        import os
-
-        # Base exclusions: system schemas and TimescaleDB internal partitions
-        excluded = [
+        defaults = [
             "pg_catalog",
             "information_schema",
             "_timescaledb_internal",
@@ -155,14 +152,9 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             "_timescaledb_catalog",
         ]
 
-        extra = os.getenv("SQLSABER_PG_EXCLUDE_SCHEMAS", "")
-        if extra:
-            for item in extra.split(","):
-                name = item.strip()
-                if name and name not in excluded:
-                    excluded.append(name)
-
-        return excluded
+        return self._merge_excluded_schemas(
+            connection, defaults, env_var="SQLSABER_PG_EXCLUDE_SCHEMAS"
+        )
 
     def _build_table_filter_clause(self, tables: list) -> tuple[str, list]:
         """Build VALUES clause with bind parameters for table filtering.
@@ -193,7 +185,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             where_conditions: list[str] = []
             params: list[Any] = []
 
-            excluded = self._get_excluded_schemas()
+            excluded = self._get_excluded_schemas(connection)
             if excluded:
                 placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))
                 where_conditions.append(f"table_schema NOT IN ({placeholders})")
@@ -354,7 +346,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
             # Exclude system schemas (and TimescaleDB internals) for performance
-            excluded = self._get_excluded_schemas()
+            excluded = self._get_excluded_schemas(connection)
             params: list[Any] = []
             if excluded:
                 placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))

sqlsaber/database/resolver.py

@@ -1,7 +1,5 @@
 """Database connection resolution from CLI input."""
 
-from __future__ import annotations
-
 from dataclasses import dataclass
 from pathlib import Path
 from urllib.parse import urlparse
@@ -21,6 +19,7 @@ class ResolvedDatabase:
 
     name: str  # Human-readable name for display/logging
     connection_string: str  # Canonical connection string for DatabaseConnection factory
+    excluded_schemas: list[str]
 
 
 SUPPORTED_SCHEMES = {"postgresql", "mysql", "sqlite", "duckdb", "csv"}
@@ -60,6 +59,7 @@ def resolve_database(
         return ResolvedDatabase(
             name=db_cfg.name,
             connection_string=db_cfg.to_connection_string(),
+            excluded_schemas=list(db_cfg.exclude_schemas),
         )
 
     # 1. Connection string?
@@ -71,22 +71,30 @@ def resolve_database(
             db_name = Path(urlparse(spec).path).stem or "database"
         else:  # should not happen because of SUPPORTED_SCHEMES
             db_name = "database"
-        return ResolvedDatabase(name=db_name, connection_string=spec)
+        return ResolvedDatabase(
+            name=db_name, connection_string=spec, excluded_schemas=[]
+        )
 
     # 2. Raw file path?
     path = Path(spec).expanduser().resolve()
     if path.suffix.lower() == ".csv":
         if not path.exists():
             raise DatabaseResolutionError(f"CSV file '{spec}' not found.")
-        return ResolvedDatabase(name=path.stem, connection_string=f"csv:///{path}")
+        return ResolvedDatabase(
+            name=path.stem, connection_string=f"csv:///{path}", excluded_schemas=[]
+        )
     if path.suffix.lower() in {".db", ".sqlite", ".sqlite3"}:
         if not path.exists():
             raise DatabaseResolutionError(f"SQLite file '{spec}' not found.")
-        return ResolvedDatabase(name=path.stem, connection_string=f"sqlite:///{path}")
+        return ResolvedDatabase(
+            name=path.stem, connection_string=f"sqlite:///{path}", excluded_schemas=[]
+        )
     if path.suffix.lower() in {".duckdb", ".ddb"}:
         if not path.exists():
             raise DatabaseResolutionError(f"DuckDB file '{spec}' not found.")
-        return ResolvedDatabase(name=path.stem, connection_string=f"duckdb:///{path}")
+        return ResolvedDatabase(
+            name=path.stem, connection_string=f"duckdb:///{path}", excluded_schemas=[]
+        )
 
     # 3. Must be a configured name
     db_cfg: DatabaseConfig | None = config_mgr.get_database(spec)
@@ -96,5 +104,7 @@ def resolve_database(
             "Use 'sqlsaber db list' to see available connections."
         )
     return ResolvedDatabase(
-        name=db_cfg.name, connection_string=db_cfg.to_connection_string()
+        name=db_cfg.name,
+        connection_string=db_cfg.to_connection_string(),
+        excluded_schemas=list(db_cfg.exclude_schemas),
     )

{sqlsaber-0.35.0.dist-info → sqlsaber-0.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.35.0
+Version: 0.36.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlsaber-0.35.0.dist-info → sqlsaber-0.36.0.dist-info}/RECORD

@@ -5,38 +5,38 @@ sqlsaber/agents/base.py,sha256=T05UsMZPwAlMhsJFpuuVI1RNDhdiwiEsgCWr9MbPoAU,2654
 sqlsaber/agents/pydantic_ai_agent.py,sha256=6_KppII8YcMw74KOGsYI5Dt6AP8WSduK3yAXCawVex4,10643
 sqlsaber/application/__init__.py,sha256=KY_-d5nEdQyAwNOsK5r-f7Tb69c63XbuEkHPeLpJal8,84
 sqlsaber/application/auth_setup.py,sha256=wbi9MaYl6q27LjcSBZmqFC12JtE5hrUHEX1NmD-7UVc,7778
-sqlsaber/application/db_setup.py,sha256=ZSgR9rJJVHttIjsbYQS9GEIyzkM09k5RLrVGdegrfYc,6859
+sqlsaber/application/db_setup.py,sha256=QX4VX8X9BiCBS3kFDd1-cPcEsCX0NwqNAOhX44pPtC4,8127
 sqlsaber/application/model_selection.py,sha256=fSC06MZNKinHDR-csMFVYYJFyK8MydKf6pStof74Jp0,3191
 sqlsaber/application/prompts.py,sha256=4rMGcWpYJbNWPMzqVWseUMx0nwvXOkWS6GaTAJ5mhfc,3473
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/auth.py,sha256=TmAD4BJr2gIjPeW2LA1QkKK5gUZ2OOS6vOmBvB6PC0M,7051
-sqlsaber/cli/commands.py,sha256=WocWlLrxA5kM8URfvIvWFtc0ocfgKWAwoYTxVNZhmM4,10962
+sqlsaber/cli/commands.py,sha256=P49Qylnk_kEmGCP5fHY5YrNyDhhL_GU20qcXBAv_QLI,11167
 sqlsaber/cli/completers.py,sha256=g-hLDq5fiBx7gg8Bte1Lq8GU-ZxCYVs4dcPsmHPIcK4,6574
-sqlsaber/cli/database.py,sha256=BBGj0eyduh5DDXNLZLDtWfY9kWpeT_ZX0J9R9INZyyU,12421
+sqlsaber/cli/database.py,sha256=RIBPFoLqXT5_RQ2rp-vYDh6wXqR6RAgbYTqZRrA9GkU,17212
 sqlsaber/cli/display.py,sha256=wxkEFceyyUloDUB49Gzqhl6JGRGq2cQdmJ3XQeYd6ok,18599
-sqlsaber/cli/interactive.py,sha256=bqeQVUgghKeZdsZ31LTcUTNt_jYyc2ujnAlUNRpxF5c,14181
+sqlsaber/cli/interactive.py,sha256=K2SwD1uY19ZK_X9MMNLJk1K7BVhDT95if8WJDvsLF0g,14301
 sqlsaber/cli/memory.py,sha256=kAY5LLFueIF30gJ8ibfrFw42rOyy5wajeJGS4h5XQw4,9475
 sqlsaber/cli/models.py,sha256=aVHazP_fiT-Mj9AtCdjliDtq3E3fJrhgP4oF5p4CuwI,9593
 sqlsaber/cli/onboarding.py,sha256=iBGT-W-OJFRvQoEpuHYyO1c9Mym5c97eIefRvxGHtTg,11265
 sqlsaber/cli/streaming.py,sha256=jicSDLWQ3efitpdc2y4QsasHcEW8ogZ4lHcWmftq9Ao,6763
 sqlsaber/cli/theme.py,sha256=D6HIt7rmF00B5ZOCV5lXKzPICE4uppHdraOdVs7k5Nw,4672
-sqlsaber/cli/threads.py,sha256=zYvs1epmRRuQxOofF85eXk1_YHS6co7oq_F33DdNdf0,14643
+sqlsaber/cli/threads.py,sha256=4pCpnEwkAW3TIaLaDfn0oixhW18LUjHvf14GuUX9ZWk,14737
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=H7xBU1mflngXIlnaDjbTvuNqZsW_92AIve31eDLij34,4513
 sqlsaber/config/auth.py,sha256=G1uulySUclWSId8EIt1hPNmsUNhbfRzfp8VVQftYyG8,2964
-sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
+sqlsaber/config/database.py,sha256=Mu92aYjc2ONNA4xbnDcEuq3A4yDFpsp8RY5aOjX7Fs0,12034
 sqlsaber/config/logging.py,sha256=vv4oCuQePeYQ7bMs0OLKj8ZSiNcFWbHmWtdC0lTsUyc,6173
 sqlsaber/config/oauth_flow.py,sha256=cDfaJjqr4spNuzxbAlzuJfk6SEe1ojSRAkoOWlvQYy0,11037
 sqlsaber/config/oauth_tokens.py,sha256=KCC2u3lOjdh0M-rd0K1rW0PWk58w7mqpodAhlPVp9NE,6424
 sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
 sqlsaber/config/settings.py,sha256=-nIBNt9E0tCRGd14bk4x-bNAwO12sbsjRsN8fFannK4,6449
-sqlsaber/database/__init__.py,sha256=Gi9N_NOkD459WRWXDg3hSuGoBs3xWbMDRBvsTVmnGAg,2025
-sqlsaber/database/base.py,sha256=ZxbDuk0W-3edo6aN2EZ65SMQ3Oxiud_jygc4ZWi2CmI,3751
+sqlsaber/database/__init__.py,sha256=s1NgBAuLfWVDDXut4Mcm4wqbiC6jPQzNP4tVfm6pI-A,2184
+sqlsaber/database/base.py,sha256=VFPlOx0_pfAj4-V8oe_r4cbnwh_B-amL48E6W_H8U-c,5502
 sqlsaber/database/csv.py,sha256=41wuP40FaGPfj28HMiD0I69uG0JbUxArpoTLC3MG2uc,4464
-sqlsaber/database/duckdb.py,sha256=zGa1akNzG1Jreyhq6jm93iFzmPtOC8WcS-7TtQxzxME,11961
-sqlsaber/database/mysql.py,sha256=wZ98wrA9E7hljGAcz5h4zBJdRJ0uPdvTZQmFqQVXDBk,14657
-sqlsaber/database/postgresql.py,sha256=0fyko76pEdn5GxtaW75lwf8OIKnj2NnaY7Z1j_heUNs,15685
-sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
+sqlsaber/database/duckdb.py,sha256=s3dpGKXac-WsPSHzh_Y6TDcz7Lne_0FnOf38l52snWQ,12808
+sqlsaber/database/mysql.py,sha256=sqeuJZTXrKIk06hqI6qe3uaSPbrkfz-DbV2OQjn1sZc,15616
+sqlsaber/database/postgresql.py,sha256=mfk3_JOzJBR9wc1opjhZ5bvTk2Cq3YhFJGooZU9S0to,15473
+sqlsaber/database/resolver.py,sha256=ENuXUPwfeDweHq7rrdL9eJAHS5UkSO_btAsW3onp_DY,3919
 sqlsaber/database/schema.py,sha256=T4dEYOk-Cy5XkhvvQ3GqAU2w584eRivbiu9UZ0nHTBo,7138
 sqlsaber/database/sqlite.py,sha256=juEVIhSwbeT0gMkEhkjwNUJn-Mif_IIDmXVqostNT-o,9918
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
@@ -55,8 +55,8 @@ sqlsaber/tools/base.py,sha256=NKEEooliPKTJj_Pomwte_wW0Xd9Z5kXNfVdCRfTppuw,883
 sqlsaber/tools/registry.py,sha256=XmBzERq0LJXtg3BZ-r8cEyt8J54NUekgUlTJ_EdSYMk,2204
 sqlsaber/tools/sql_guard.py,sha256=dTDwcZP-N4xPGzcr7MQtKUxKrlDzlc1irr9aH5a4wvk,6182
 sqlsaber/tools/sql_tools.py,sha256=q479PNneuAlpaDCp2cyw1MFhLUY4vcUHV_ZyIuSMHK0,7796
-sqlsaber-0.35.0.dist-info/METADATA,sha256=2TaG6of-RcfHsYWODoipU909C40Kfq2qaWRE71sI85M,5915
-sqlsaber-0.35.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.35.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
-sqlsaber-0.35.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.35.0.dist-info/RECORD,,
+sqlsaber-0.36.0.dist-info/METADATA,sha256=55XqjlW56tN7F_jTMcrRpyPEBmmNLWiHjtQnNjbXzf8,5915
+sqlsaber-0.36.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.36.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
+sqlsaber-0.36.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.36.0.dist-info/RECORD,,