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

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
@@ -24,6 +26,7 @@ class ColumnInfo(TypedDict):
     max_length: int | None
     precision: int | None
     scale: int | None
+    comment: str | None
 
 
 class ForeignKeyInfo(TypedDict):
@@ -48,6 +51,7 @@ class SchemaInfo(TypedDict):
     schema: str
     name: str
     type: str
+    comment: str | None
     columns: dict[str, ColumnInfo]
     primary_keys: list[str]
     foreign_keys: list[ForeignKeyInfo]
@@ -60,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
@@ -93,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."""
@@ -128,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,30 +138,43 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
         self, connection, table_pattern: str | None = None
     ) -> list[dict[str, Any]]:
         """Get tables information for DuckDB."""
-        where_conditions = [
-            "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)
-                where_conditions.append("(table_schema LIKE ? AND table_name LIKE ?)")
+                where_conditions.append(
+                    "(t.table_schema LIKE ? AND t.table_name LIKE ?)"
+                )
                 params.extend([schema_pattern, table_name_pattern])
             else:
                 where_conditions.append(
-                    "(table_name LIKE ? OR table_schema || '.' || table_name LIKE ?)"
+                    "(t.table_name LIKE ? OR t.table_schema || '.' || t.table_name LIKE ?)"
                 )
                 params.extend([table_pattern, table_pattern])
 
+        if not where_conditions:
+            where_conditions.append("1=1")
+
         query = f"""
             SELECT
-                table_schema,
-                table_name,
-                table_type
-            FROM information_schema.tables
+                t.table_schema,
+                t.table_name,
+                t.table_type,
+                dt.comment AS table_comment
+            FROM information_schema.tables t
+            LEFT JOIN duckdb_tables() dt
+                ON t.table_schema = dt.schema_name
+                AND t.table_name = dt.table_name
             WHERE {" AND ".join(where_conditions)}
-            ORDER BY table_schema, table_name;
+            ORDER BY t.table_schema, t.table_name;
         """
 
         return await self._execute_query(connection, query, tuple(params))
@@ -166,7 +186,7 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
 
         table_filters = []
         for table in tables:
-            table_filters.append("(table_schema = ? AND table_name = ?)")
+            table_filters.append("(c.table_schema = ? AND c.table_name = ?)")
 
         params: list[Any] = []
         for table in tables:
@@ -174,18 +194,23 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
 
         query = f"""
             SELECT
-                table_schema,
-                table_name,
-                column_name,
-                data_type,
-                is_nullable,
-                column_default,
-                character_maximum_length,
-                numeric_precision,
-                numeric_scale
-            FROM information_schema.columns
+                c.table_schema,
+                c.table_name,
+                c.column_name,
+                c.data_type,
+                c.is_nullable,
+                c.column_default,
+                c.character_maximum_length,
+                c.numeric_precision,
+                c.numeric_scale,
+                dc.comment AS column_comment
+            FROM information_schema.columns c
+            LEFT JOIN duckdb_columns() dc
+                ON c.table_schema = dc.schema_name
+                AND c.table_name = dc.table_name
+                AND c.column_name = dc.column_name
             WHERE {" OR ".join(table_filters)}
-            ORDER BY table_schema, table_name, ordinal_position;
+            ORDER BY c.table_schema, c.table_name, c.ordinal_position;
         """
 
         return await self._execute_query(connection, query, tuple(params))
@@ -305,14 +330,27 @@ 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
-                table_schema,
-                table_name,
-                table_type
-            FROM information_schema.tables
-            WHERE table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')
-            ORDER BY table_schema, table_name;
+                t.table_schema,
+                t.table_name,
+                t.table_type,
+                dt.comment AS table_comment
+            FROM information_schema.tables t
+            LEFT JOIN duckdb_tables() dt
+                ON t.table_schema = dt.schema_name
+                AND t.table_name = dt.table_name
+            {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,12 +208,16 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         )
                         params.extend([table_pattern, table_pattern])
 
+                if not where_conditions:
+                    where_conditions.append("1=1")
+
                 # Get tables
                 tables_query = f"""
                     SELECT
                         table_schema,
                         table_name,
-                        table_type
+                        table_type,
+                        table_comment
                     FROM information_schema.tables
                     WHERE {" AND ".join(where_conditions)}
                     ORDER BY table_schema, table_name;
@@ -230,7 +245,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         c.column_default,
                         c.character_maximum_length,
                         c.numeric_precision,
-                        c.numeric_scale
+                        c.numeric_scale,
+                        c.column_comment
                     FROM information_schema.columns c
                     WHERE (c.table_schema, c.table_name) IN ({placeholders})
                     ORDER BY c.table_schema, c.table_name, c.ordinal_position;
@@ -327,16 +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_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
@@ -345,6 +371,7 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         "table_schema": row["table_schema"],
                         "table_name": row["table_name"],
                         "table_type": row["table_type"],
+                        "table_comment": row["table_comment"],
                     }
                     for row in rows
                 ]

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})")
@@ -226,7 +218,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                 SELECT
                     table_schema,
                     table_name,
-                    table_type
+                    table_type,
+                    obj_description(('"' || table_schema || '"."' || table_name || '"')::regclass, 'pg_class') AS table_comment
                 FROM information_schema.tables
                 WHERE {" AND ".join(where_conditions)}
                 ORDER BY table_schema, table_name;
@@ -252,7 +245,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                     c.column_default,
                     c.character_maximum_length,
                     c.numeric_precision,
-                    c.numeric_scale
+                    c.numeric_scale,
+                    col_description(('"' || c.table_schema || '"."' || c.table_name || '"')::regclass::oid, c.ordinal_position::INT) AS column_comment
                 FROM information_schema.columns c
                 WHERE (c.table_schema, c.table_name) IN (VALUES {values_clause})
                 ORDER BY c.table_schema, c.table_name, c.ordinal_position;
@@ -352,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)))
@@ -367,7 +361,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                 SELECT
                     table_schema,
                     table_name,
-                    table_type
+                    table_type,
+                    obj_description(('"' || table_schema || '"."' || table_name || '"')::regclass, 'pg_class') AS table_comment
                 FROM information_schema.tables
                 WHERE {where_clause}
                 ORDER BY table_schema, table_name;
@@ -380,6 +375,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                     "table_schema": table["table_schema"],
                     "table_name": table["table_name"],
                     "table_type": table["table_type"],
+                    "table_comment": table["table_comment"],
                 }
                 for table in tables
             ]

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/database/schema.py

@@ -72,6 +72,7 @@ class SchemaManager:
                 "schema": schema_name,
                 "name": table_name,
                 "type": table["table_type"],
+                "comment": table["table_comment"],
                 "columns": {},
                 "primary_keys": [],
                 "foreign_keys": [],
@@ -85,6 +86,7 @@ class SchemaManager:
         for col in columns:
             full_name = f"{col['table_schema']}.{col['table_name']}"
             if full_name in schema_info:
+                # Handle different row types (dict vs Row objects)
                 column_info: ColumnInfo = {
                     "data_type": col["data_type"],
                     "nullable": col.get("is_nullable", "YES") == "YES",
@@ -92,6 +94,7 @@ class SchemaManager:
                     "max_length": col.get("character_maximum_length"),
                     "precision": col.get("numeric_precision"),
                     "scale": col.get("numeric_scale"),
+                    "comment": col.get("column_comment"),
                 }
                 # Add type field for display compatibility
                 column_info["type"] = col["data_type"]

sqlsaber/database/sqlite.py

@@ -93,7 +93,10 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
     async def get_tables_info(
         self, connection, table_pattern: str | None = None
     ) -> dict[str, Any]:
-        """Get tables information for SQLite."""
+        """Get tables information for SQLite.
+
+        Note: SQLite does not support native table comments, so table_comment is always None.
+        """
         where_conditions = ["type IN ('table', 'view')", "name NOT LIKE 'sqlite_%'"]
         params = ()
 
@@ -105,7 +108,8 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
             SELECT
                 'main' as table_schema,
                 name as table_name,
-                type as table_type
+                type as table_type,
+                NULL as table_comment
             FROM sqlite_master
             WHERE {" AND ".join(where_conditions)}
             ORDER BY name;
@@ -114,7 +118,10 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
         return await self._execute_query(connection, query, params)
 
     async def get_columns_info(self, connection, tables: list) -> list:
-        """Get columns information for SQLite."""
+        """Get columns information for SQLite.
+
+        Note: SQLite does not support native column comments, so column_comment is always None.
+        """
         if not tables:
             return []
 
@@ -138,6 +145,7 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
                         "character_maximum_length": None,
                         "numeric_precision": None,
                         "numeric_scale": None,
+                        "column_comment": None,
                     }
                 )
 
@@ -237,13 +245,17 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
         return indexes
 
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
-        """Get list of tables with basic information for SQLite."""
+        """Get list of tables with basic information for SQLite.
+
+        Note: SQLite does not support native table comments, so table_comment is always None.
+        """
         # Get table names without row counts for better performance
         tables_query = """
             SELECT
                 'main' as table_schema,
                 name as table_name,
-                type as table_type
+                type as table_type,
+                NULL as table_comment
             FROM sqlite_master
             WHERE type IN ('table', 'view')
             AND name NOT LIKE 'sqlite_%'
@@ -258,6 +270,7 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
                 "table_schema": table["table_schema"],
                 "table_name": table["table_name"],
                 "table_type": table["table_type"],
+                "table_comment": table["table_comment"],
             }
             for table in tables
         ]

sqlsaber/tools/sql_tools.py

@@ -95,27 +95,38 @@ class IntrospectSchemaTool(SQLTool):
             # Format the schema information
             formatted_info = {}
             for table_name, table_info in schema_info.items():
-                formatted_info[table_name] = {
-                    "columns": {
-                        col_name: {
-                            "type": col_info["data_type"],
-                            "nullable": col_info["nullable"],
-                            "default": col_info["default"],
-                        }
-                        for col_name, col_info in table_info["columns"].items()
-                    },
-                    "primary_keys": table_info["primary_keys"],
-                    "foreign_keys": [
-                        f"{fk['column']} -> {fk['references']['table']}.{fk['references']['column']}"
-                        for fk in table_info["foreign_keys"]
-                    ],
-                    "indexes": [
-                        f"{idx['name']} ({', '.join(idx['columns'])})"
-                        + (" UNIQUE" if idx["unique"] else "")
-                        + (f" [{idx['type']}]" if idx["type"] else "")
-                        for idx in table_info["indexes"]
-                    ],
-                }
+                table_data = {}
+
+                # Add table comment if present
+                if table_info.get("comment"):
+                    table_data["comment"] = table_info["comment"]
+
+                # Add columns with comments if present
+                table_data["columns"] = {}
+                for col_name, col_info in table_info["columns"].items():
+                    column_data = {
+                        "type": col_info["data_type"],
+                        "nullable": col_info["nullable"],
+                        "default": col_info["default"],
+                    }
+                    if col_info.get("comment"):
+                        column_data["comment"] = col_info["comment"]
+                    table_data["columns"][col_name] = column_data
+
+                # Add other schema information
+                table_data["primary_keys"] = table_info["primary_keys"]
+                table_data["foreign_keys"] = [
+                    f"{fk['column']} -> {fk['references']['table']}.{fk['references']['column']}"
+                    for fk in table_info["foreign_keys"]
+                ]
+                table_data["indexes"] = [
+                    f"{idx['name']} ({', '.join(idx['columns'])})"
+                    + (" UNIQUE" if idx["unique"] else "")
+                    + (f" [{idx['type']}]" if idx["type"] else "")
+                    for idx in table_info["indexes"]
+                ]
+
+                formatted_info[table_name] = table_data
 
             return json.dumps(formatted_info)
         except Exception as e:

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

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