sqlsaber 0.34.0__tar.gz → 0.35.0__tar.gz

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/PKG-INFO

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

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/docs/src/content/docs/changelog.md

@@ -9,6 +9,23 @@ All notable changes to SQLsaber will be documented here.
 
 ---
 
+### v0.35.0 - 2025-10-22
+
+#### Added
+
+- Table and column comment support across all databases
+  - Comments are now included in schema introspection to provide richer context to LLM
+  - PostgreSQL: Uses `obj_description()` and `col_description()` functions
+  - MySQL: Retrieves `table_comment` and `column_comment` from `information_schema`
+  - DuckDB: Joins with `duckdb_tables()` and `duckdb_columns()` for comment data
+  - SQLite: Returns `None` for comments (SQLite doesn't support native comments)
+  - Comments are conditionally included in tool output only when present, avoiding clutter
+  - Updated `ColumnInfo` and `SchemaInfo` TypedDicts with optional comment fields
+
+#### Fixed
+
+- Strip leading/trailing whitespace and new lines from submitted user inputs
+
 ### v0.34.0 - 2025-10-17
 
 #### Changed

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlsaber"
-version = "0.34.0"
+version = "0.35.0"
 description = "SQLsaber - Open-source agentic SQL assistant"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/cli/display.py

@@ -406,9 +406,17 @@ class DisplayManager:
             for table_name, table_info in data.items():
                 self.console.print(f"\n[heading]Table: {table_name}[/heading]")
 
+                table_comment = table_info.get("comment")
+                if table_comment:
+                    self.console.print(f"[muted]Comment: {table_comment}[/muted]")
+
                 # Show columns
                 table_columns = table_info.get("columns", {})
                 if table_columns:
+                    include_column_comments = any(
+                        col_info.get("comment") for col_info in table_columns.values()
+                    )
+
                     # Create a table for columns
                     columns = [
                         {"name": "Column Name", "style": "column.name"},
@@ -416,6 +424,8 @@ class DisplayManager:
                         {"name": "Nullable", "style": "info"},
                         {"name": "Default", "style": "muted"},
                     ]
+                    if include_column_comments:
+                        columns.append({"name": "Comment", "style": "muted"})
                     col_table = self._create_table(columns, title="Columns")
 
                     for col_name, col_info in table_columns.items():
@@ -425,9 +435,15 @@ class DisplayManager:
                             if col_info.get("default")
                             else ""
                         )
-                        col_table.add_row(
-                            col_name, col_info.get("type", ""), nullable, default
-                        )
+                        row = [
+                            col_name,
+                            col_info.get("type", ""),
+                            nullable,
+                            default,
+                        ]
+                        if include_column_comments:
+                            row.append(col_info.get("comment") or "")
+                        col_table.add_row(*row)
 
                     self.console.print(col_table)
 

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/cli/interactive.py

@@ -20,6 +20,7 @@ from sqlsaber.cli.completers import (
 )
 from sqlsaber.cli.display import DisplayManager
 from sqlsaber.cli.streaming import StreamingQueryHandler
+from sqlsaber.config.logging import get_logger
 from sqlsaber.database import (
     CSVConnection,
     DuckDBConnection,
@@ -30,7 +31,6 @@ from sqlsaber.database import (
 from sqlsaber.database.schema import SchemaManager
 from sqlsaber.theme.manager import get_theme_manager
 from sqlsaber.threads import ThreadStorage
-from sqlsaber.config.logging import get_logger
 
 if TYPE_CHECKING:
     from sqlsaber.agents.pydantic_ai_agent import SQLSaberAgent
@@ -309,6 +309,8 @@ class InteractiveSession:
                         style=self.tm.pt_style(),
                     )
 
+                user_query = user_query.strip()
+
                 if not user_query:
                     continue
 
@@ -325,7 +327,7 @@ class InteractiveSession:
 
                 # Handle memory addition
                 if user_query.strip().startswith("#"):
-                    await self._handle_memory(user_query.strip()[1:].strip())
+                    await self._handle_memory(user_query[1:].strip())
                     continue
 
                 # Execute query with cancellation support

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/database/base.py

@@ -24,6 +24,7 @@ class ColumnInfo(TypedDict):
     max_length: int | None
     precision: int | None
     scale: int | None
+    comment: str | None
 
 
 class ForeignKeyInfo(TypedDict):
@@ -48,6 +49,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]

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/database/duckdb.py

@@ -132,29 +132,35 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
     ) -> list[dict[str, Any]]:
         """Get tables information for DuckDB."""
         where_conditions = [
-            "table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')"
+            "t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')"
         ]
         params: list[Any] = []
 
         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])
 
         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 +172,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 +180,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))
@@ -307,12 +318,16 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
         """Get list of tables with basic information for DuckDB."""
         query = """
             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 t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')
+            ORDER BY t.table_schema, t.table_name;
         """
 
         return await self._execute_query(connection, query)

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/database/mysql.py

@@ -202,7 +202,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                     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 +231,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;
@@ -331,7 +333,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                     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')
                     ORDER BY t.table_schema, t.table_name;
@@ -345,6 +348,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-0.34.0 → sqlsaber-0.35.0}/src/sqlsaber/database/postgresql.py

@@ -226,7 +226,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 +253,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;
@@ -367,7 +369,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 +383,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-0.34.0 → sqlsaber-0.35.0}/src/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-0.34.0 → sqlsaber-0.35.0}/src/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-0.34.0 → sqlsaber-0.35.0}/src/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.35.0/tests/test_database/test_schema.py

@@ -0,0 +1,110 @@
+"""Tests for schema introspection."""
+
+import aiosqlite
+import duckdb
+import pytest
+
+from sqlsaber.database import DuckDBConnection, SQLiteConnection
+from sqlsaber.database.schema import (
+    DuckDBSchemaIntrospector,
+    SchemaManager,
+)
+
+
+@pytest.mark.asyncio
+async def test_duckdb_schema_manager(tmp_path):
+    """Ensure DuckDB schema introspection surfaces tables and relationships."""
+    db_path = tmp_path / "introspection.duckdb"
+
+    conn = duckdb.connect(str(db_path))
+    try:
+        conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);")
+        conn.execute(
+            "CREATE TABLE orders (id INTEGER, user_id INTEGER, FOREIGN KEY(user_id) REFERENCES users(id));"
+        )
+        conn.execute("CREATE UNIQUE INDEX idx_users_name ON users(name);")
+    finally:
+        conn.close()
+
+    db_conn = DuckDBConnection(f"duckdb:///{db_path}")
+    schema_manager = SchemaManager(db_conn)
+
+    assert isinstance(schema_manager.introspector, DuckDBSchemaIntrospector)
+
+    tables = await schema_manager.list_tables()
+    table_names = {table["full_name"] for table in tables["tables"]}
+    assert "main.users" in table_names
+    assert "main.orders" in table_names
+
+    schema_info = await schema_manager.get_schema_info()
+    users_info = schema_info["main.users"]
+    orders_info = schema_info["main.orders"]
+
+    assert "id" in users_info["columns"]
+    assert "INTEGER" in users_info["columns"]["id"]["data_type"].upper()
+    assert "id" in users_info["primary_keys"]
+    assert any(idx["name"] == "idx_users_name" for idx in users_info["indexes"])
+
+    assert any(fk["column"] == "user_id" for fk in orders_info["foreign_keys"])
+
+
+@pytest.mark.asyncio
+async def test_duckdb_comments(tmp_path):
+    """Test that DuckDB table and column comments are retrieved correctly."""
+    db_path = tmp_path / "comments.duckdb"
+
+    conn = duckdb.connect(str(db_path))
+    try:
+        conn.execute(
+            "CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price DECIMAL);"
+        )
+        conn.execute("COMMENT ON TABLE products IS 'Product catalog';")
+        conn.execute("COMMENT ON COLUMN products.id IS 'Unique product identifier';")
+        conn.execute("COMMENT ON COLUMN products.name IS 'Product name';")
+        conn.execute("COMMENT ON COLUMN products.price IS 'Product price in USD';")
+    finally:
+        conn.close()
+
+    db_conn = DuckDBConnection(f"duckdb:///{db_path}")
+    schema_manager = SchemaManager(db_conn)
+
+    # Test list_tables includes comments
+    tables = await schema_manager.list_tables()
+    products_table = next(t for t in tables["tables"] if t["table_name"] == "products")
+    assert products_table["table_comment"] == "Product catalog"
+
+    # Test get_schema_info includes comments
+    schema_info = await schema_manager.get_schema_info()
+    products_info = schema_info["main.products"]
+
+    assert products_info["comment"] == "Product catalog"
+    assert products_info["columns"]["id"]["comment"] == "Unique product identifier"
+    assert products_info["columns"]["name"]["comment"] == "Product name"
+    assert products_info["columns"]["price"]["comment"] == "Product price in USD"
+
+
+@pytest.mark.asyncio
+async def test_sqlite_no_comments(tmp_path):
+    """Verify that SQLite returns None for comments since it doesn't support them."""
+
+    db_path = tmp_path / "no_comments.db"
+
+    async with aiosqlite.connect(str(db_path)) as conn:
+        await conn.execute("CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT);")
+        await conn.commit()
+
+    db_conn = SQLiteConnection(f"sqlite:///{db_path}")
+    schema_manager = SchemaManager(db_conn)
+
+    # Test list_tables has None for comments
+    tables = await schema_manager.list_tables()
+    items_table = next(t for t in tables["tables"] if t["table_name"] == "items")
+    assert items_table["table_comment"] is None
+
+    # Test get_schema_info has None for comments
+    schema_info = await schema_manager.get_schema_info()
+    items_info = schema_info["main.items"]
+
+    assert items_info["comment"] is None
+    assert items_info["columns"]["id"]["comment"] is None
+    assert items_info["columns"]["name"]["comment"] is None

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/tests/test_database/test_schema_display.py

@@ -147,6 +147,39 @@ class TestSchemaDisplayMappings:
 
         await db_conn.close()
 
+    @pytest.mark.asyncio
+    async def test_schema_display_includes_comments(self, tmp_path):
+        """Ensure schema display renders table and column comments when present."""
+        db_path = tmp_path / "test_comments.duckdb"
+
+        conn = duckdb.connect(str(db_path))
+        try:
+            conn.execute(
+                "CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price DECIMAL);"
+            )
+            conn.execute("COMMENT ON TABLE products IS 'Product catalog';")
+            conn.execute("COMMENT ON COLUMN products.id IS 'Unique product identifier';")
+            conn.execute("COMMENT ON COLUMN products.name IS 'Product name';")
+        finally:
+            conn.close()
+
+        db_conn = DuckDBConnection(f"duckdb:///{db_path}")
+        schema_manager = SchemaManager(db_conn)
+        schema_info = await schema_manager.get_schema_info()
+
+        string_io = StringIO()
+        console = create_console(file=string_io, width=120, legacy_windows=False)
+        display_manager = DisplayManager(console)
+
+        display_manager.show_schema_info(schema_info)
+        output = string_io.getvalue()
+
+        assert "Product catalog" in output
+        assert "Unique product identifier" in output
+        assert "Product name" in output
+
+        await db_conn.close()
+
     @pytest.mark.asyncio
     async def test_table_list_display_integration(self, tmp_path):
         """Test end-to-end table list display with type mappings."""

{sqlsaber-0.34.0 → sqlsaber-0.35.0}/uv.lock

@@ -1922,7 +1922,7 @@ wheels = [
 
 [[package]]
 name = "sqlsaber"
-version = "0.34.0"
+version = "0.35.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiomysql" },

sqlsaber-0.34.0/tests/test_database/test_schema.py

@@ -1,47 +0,0 @@
-"""Tests for schema introspection."""
-
-import duckdb
-import pytest
-
-from sqlsaber.database import DuckDBConnection
-from sqlsaber.database.schema import (
-    DuckDBSchemaIntrospector,
-    SchemaManager,
-)
-
-
-@pytest.mark.asyncio
-async def test_duckdb_schema_manager(tmp_path):
-    """Ensure DuckDB schema introspection surfaces tables and relationships."""
-    db_path = tmp_path / "introspection.duckdb"
-
-    conn = duckdb.connect(str(db_path))
-    try:
-        conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);")
-        conn.execute(
-            "CREATE TABLE orders (id INTEGER, user_id INTEGER, FOREIGN KEY(user_id) REFERENCES users(id));"
-        )
-        conn.execute("CREATE UNIQUE INDEX idx_users_name ON users(name);")
-    finally:
-        conn.close()
-
-    db_conn = DuckDBConnection(f"duckdb:///{db_path}")
-    schema_manager = SchemaManager(db_conn)
-
-    assert isinstance(schema_manager.introspector, DuckDBSchemaIntrospector)
-
-    tables = await schema_manager.list_tables()
-    table_names = {table["full_name"] for table in tables["tables"]}
-    assert "main.users" in table_names
-    assert "main.orders" in table_names
-
-    schema_info = await schema_manager.get_schema_info()
-    users_info = schema_info["main.users"]
-    orders_info = schema_info["main.orders"]
-
-    assert "id" in users_info["columns"]
-    assert "INTEGER" in users_info["columns"]["id"]["data_type"].upper()
-    assert "id" in users_info["primary_keys"]
-    assert any(idx["name"] == "idx_users_name" for idx in users_info["indexes"])
-
-    assert any(fk["column"] == "user_id" for fk in orders_info["foreign_keys"])