sqlsaber 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

sqlsaber/database/schema.py

@@ -1,13 +1,16 @@
 """Database schema introspection utilities."""
 
+import asyncio
 from abc import ABC, abstractmethod
 from typing import Any, TypedDict
 
 import aiosqlite
+import duckdb
 
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
     CSVConnection,
+    DuckDBConnection,
     MySQLConnection,
     PostgreSQLConnection,
     SQLiteConnection,
@@ -32,6 +35,15 @@ class ForeignKeyInfo(TypedDict):
     references: dict[str, str]  # {"table": "schema.table", "column": "column_name"}
 
 
+class IndexInfo(TypedDict):
+    """Type definition for index information."""
+
+    name: str
+    columns: list[str]  # ordered
+    unique: bool
+    type: str | None  # btree, gin, FULLTEXT, etc. None if unknown
+
+
 class SchemaInfo(TypedDict):
     """Type definition for schema information."""
 
@@ -41,6 +53,7 @@ class SchemaInfo(TypedDict):
     columns: dict[str, ColumnInfo]
     primary_keys: list[str]
     foreign_keys: list[ForeignKeyInfo]
+    indexes: list[IndexInfo]
 
 
 class BaseSchemaIntrospector(ABC):
@@ -68,6 +81,11 @@ class BaseSchemaIntrospector(ABC):
         """Get primary keys information for the specific database type."""
         pass
 
+    @abstractmethod
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for the specific database type."""
+        pass
+
     @abstractmethod
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information."""
@@ -209,6 +227,43 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             """
             return await conn.fetch(pk_query)
 
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for PostgreSQL."""
+        if not tables:
+            return []
+
+        pool = await connection.get_pool()
+        async with pool.acquire() as conn:
+            # Build proper table filters
+            idx_table_filters = []
+            for table in tables:
+                idx_table_filters.append(
+                    f"(ns.nspname = '{table['table_schema']}' AND t.relname = '{table['table_name']}')"
+                )
+
+            idx_query = f"""
+                SELECT
+                    ns.nspname      AS table_schema,
+                    t.relname       AS table_name,
+                    i.relname       AS index_name,
+                    ix.indisunique  AS is_unique,
+                    am.amname       AS index_type,
+                    array_agg(a.attname ORDER BY ord.ordinality) AS column_names
+                FROM pg_class t
+                JOIN pg_namespace ns     ON ns.oid = t.relnamespace
+                JOIN pg_index    ix      ON ix.indrelid = t.oid
+                JOIN pg_class    i       ON i.oid  = ix.indexrelid
+                JOIN pg_am       am      ON am.oid = i.relam
+                JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS ord(attnum, ordinality)
+                     ON TRUE
+                JOIN pg_attribute a      ON a.attrelid = t.oid AND a.attnum = ord.attnum
+                WHERE ns.nspname NOT IN ('pg_catalog', 'information_schema')
+                  AND ({" OR ".join(idx_table_filters)})
+                GROUP BY table_schema, table_name, index_name, is_unique, index_type
+                ORDER BY table_schema, table_name, index_name;
+            """
+            return await conn.fetch(idx_query)
+
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
@@ -379,6 +434,37 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                 await cursor.execute(pk_query)
                 return await cursor.fetchall()
 
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for MySQL."""
+        if not tables:
+            return []
+
+        pool = await connection.get_pool()
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cursor:
+                # Build proper table filters
+                idx_table_filters = []
+                for table in tables:
+                    idx_table_filters.append(
+                        f"(TABLE_SCHEMA = '{table['table_schema']}' AND TABLE_NAME = '{table['table_name']}')"
+                    )
+
+                idx_query = f"""
+                    SELECT
+                        TABLE_SCHEMA   AS table_schema,
+                        TABLE_NAME     AS table_name,
+                        INDEX_NAME     AS index_name,
+                        (NON_UNIQUE = 0) AS is_unique,
+                        INDEX_TYPE     AS index_type,
+                        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS column_names
+                    FROM INFORMATION_SCHEMA.STATISTICS
+                    WHERE ({" OR ".join(idx_table_filters)})
+                    GROUP BY table_schema, table_name, index_name, is_unique, index_type
+                    ORDER BY table_schema, table_name, index_name;
+                """
+                await cursor.execute(idx_query)
+                return await cursor.fetchall()
+
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for MySQL."""
         pool = await connection.get_pool()
@@ -531,6 +617,47 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
         return primary_keys
 
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for SQLite."""
+        if not tables:
+            return []
+
+        indexes = []
+        for table in tables:
+            table_name = table["table_name"]
+
+            # Get index list using PRAGMA
+            pragma_query = f"PRAGMA index_list({table_name})"
+            table_indexes = await self._execute_query(connection, pragma_query)
+
+            for idx in table_indexes:
+                idx_name = idx["name"]
+                unique = bool(idx["unique"])
+
+                # Skip auto-generated primary key indexes
+                if idx_name.startswith("sqlite_autoindex_"):
+                    continue
+
+                # Get index columns using PRAGMA
+                pragma_info_query = f"PRAGMA index_info({idx_name})"
+                idx_cols = await self._execute_query(connection, pragma_info_query)
+                columns = [
+                    c["name"] for c in sorted(idx_cols, key=lambda r: r["seqno"])
+                ]
+
+                indexes.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "index_name": idx_name,
+                        "is_unique": unique,
+                        "index_type": None,  # SQLite only has B-tree currently
+                        "column_names": columns,
+                    }
+                )
+
+        return indexes
+
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for SQLite."""
         # Get table names without row counts for better performance
@@ -558,6 +685,225 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
         ]
 
 
+class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
+    """DuckDB-specific schema introspection."""
+
+    async def _execute_query(
+        self,
+        connection: DuckDBConnection | CSVConnection,
+        query: str,
+        params: tuple[Any, ...] = (),
+    ) -> list[dict[str, Any]]:
+        """Run a DuckDB query on a thread and return list of dictionaries."""
+
+        params_tuple = tuple(params)
+
+        def fetch_rows(conn: duckdb.DuckDBPyConnection) -> list[dict[str, Any]]:
+            cursor = conn.execute(query, params_tuple)
+            if cursor.description is None:
+                return []
+
+            columns = [col[0] for col in cursor.description]
+            rows = conn.fetchall()
+            return [dict(zip(columns, row)) for row in rows]
+
+        if isinstance(connection, CSVConnection):
+            return await connection.execute_query(query, *params_tuple)
+
+        def run_query() -> list[dict[str, Any]]:
+            conn = duckdb.connect(connection.database_path)
+            try:
+                return fetch_rows(conn)
+            finally:
+                conn.close()
+
+        return await asyncio.to_thread(run_query)
+
+    async def get_tables_info(
+        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')"
+        ]
+        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 ?)"
+                )
+                params.extend([schema_pattern, table_name_pattern])
+            else:
+                where_conditions.append(
+                    "(table_name LIKE ? OR table_schema || '.' || table_name LIKE ?)"
+                )
+                params.extend([table_pattern, table_pattern])
+
+        query = f"""
+            SELECT
+                table_schema,
+                table_name,
+                table_type
+            FROM information_schema.tables
+            WHERE {" AND ".join(where_conditions)}
+            ORDER BY table_schema, table_name;
+        """
+
+        return await self._execute_query(connection, query, tuple(params))
+
+    async def get_columns_info(self, connection, tables: list) -> list[dict[str, Any]]:
+        """Get columns information for DuckDB."""
+        if not tables:
+            return []
+
+        table_filters = []
+        for table in tables:
+            table_filters.append(
+                "(table_schema = ? AND table_name = ?)"
+            )
+
+        params: list[Any] = []
+        for table in tables:
+            params.extend([table["table_schema"], table["table_name"]])
+
+        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
+            WHERE {" OR ".join(table_filters)}
+            ORDER BY table_schema, table_name, ordinal_position;
+        """
+
+        return await self._execute_query(connection, query, tuple(params))
+
+    async def get_foreign_keys_info(self, connection, tables: list) -> list[dict[str, Any]]:
+        """Get foreign keys information for DuckDB."""
+        if not tables:
+            return []
+
+        table_filters = []
+        params: list[Any] = []
+        for table in tables:
+            table_filters.append("(kcu.table_schema = ? AND kcu.table_name = ?)")
+            params.extend([table["table_schema"], table["table_name"]])
+
+        query = f"""
+            SELECT
+                kcu.table_schema,
+                kcu.table_name,
+                kcu.column_name,
+                ccu.table_schema AS foreign_table_schema,
+                ccu.table_name AS foreign_table_name,
+                ccu.column_name AS foreign_column_name
+            FROM information_schema.referential_constraints AS rc
+            JOIN information_schema.key_column_usage AS kcu
+                ON rc.constraint_schema = kcu.constraint_schema
+                AND rc.constraint_name = kcu.constraint_name
+            JOIN information_schema.key_column_usage AS ccu
+                ON rc.unique_constraint_schema = ccu.constraint_schema
+                AND rc.unique_constraint_name = ccu.constraint_name
+                AND ccu.ordinal_position = kcu.position_in_unique_constraint
+            WHERE {" OR ".join(table_filters)}
+            ORDER BY kcu.table_schema, kcu.table_name, kcu.ordinal_position;
+        """
+
+        return await self._execute_query(connection, query, tuple(params))
+
+    async def get_primary_keys_info(self, connection, tables: list) -> list[dict[str, Any]]:
+        """Get primary keys information for DuckDB."""
+        if not tables:
+            return []
+
+        table_filters = []
+        params: list[Any] = []
+        for table in tables:
+            table_filters.append("(tc.table_schema = ? AND tc.table_name = ?)")
+            params.extend([table["table_schema"], table["table_name"]])
+
+        query = f"""
+            SELECT
+                tc.table_schema,
+                tc.table_name,
+                kcu.column_name
+            FROM information_schema.table_constraints AS tc
+            JOIN information_schema.key_column_usage AS kcu
+                ON tc.constraint_name = kcu.constraint_name
+                AND tc.constraint_schema = kcu.constraint_schema
+            WHERE tc.constraint_type = 'PRIMARY KEY'
+                AND ({" OR ".join(table_filters)})
+            ORDER BY tc.table_schema, tc.table_name, kcu.ordinal_position;
+        """
+
+        return await self._execute_query(connection, query, tuple(params))
+
+    async def get_indexes_info(self, connection, tables: list) -> list[dict[str, Any]]:
+        """Get indexes information for DuckDB."""
+        if not tables:
+            return []
+
+        indexes: list[dict[str, Any]] = []
+        for table in tables:
+            schema = table["table_schema"]
+            table_name = table["table_name"]
+            query = """
+                SELECT
+                    schema_name,
+                    table_name,
+                    index_name,
+                    sql
+                FROM duckdb_indexes()
+                WHERE schema_name = ? AND table_name = ?;
+            """
+            rows = await self._execute_query(connection, query, (schema, table_name))
+
+            for row in rows:
+                sql_text = (row.get("sql") or "").strip()
+                upper_sql = sql_text.upper()
+                unique = "UNIQUE" in upper_sql.split("(")[0]
+
+                columns: list[str] = []
+                if "(" in sql_text and ")" in sql_text:
+                    column_section = sql_text[sql_text.find("(") + 1 : sql_text.rfind(")")]
+                    columns = [col.strip().strip('"') for col in column_section.split(",") if col.strip()]
+
+                indexes.append(
+                    {
+                        "table_schema": row.get("schema_name") or schema or "main",
+                        "table_name": row.get("table_name") or table_name,
+                        "index_name": row.get("index_name"),
+                        "is_unique": unique,
+                        "index_type": None,
+                        "column_names": columns,
+                    }
+                )
+
+        return indexes
+
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
+        """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;
+        """
+
+        return await self._execute_query(connection, query)
+
+
 class SchemaManager:
     """Manages database schema introspection."""
 
@@ -569,8 +915,10 @@ class SchemaManager:
             self.introspector = PostgreSQLSchemaIntrospector()
         elif isinstance(db_connection, MySQLConnection):
             self.introspector = MySQLSchemaIntrospector()
-        elif isinstance(db_connection, (SQLiteConnection, CSVConnection)):
+        elif isinstance(db_connection, SQLiteConnection):
             self.introspector = SQLiteSchemaIntrospector()
+        elif isinstance(db_connection, (DuckDBConnection, CSVConnection)):
+            self.introspector = DuckDBSchemaIntrospector()
         else:
             raise ValueError(
                 f"Unsupported database connection type: {type(db_connection)}"
@@ -589,12 +937,14 @@ class SchemaManager:
         columns = await self.introspector.get_columns_info(self.db, tables)
         foreign_keys = await self.introspector.get_foreign_keys_info(self.db, tables)
         primary_keys = await self.introspector.get_primary_keys_info(self.db, tables)
+        indexes = await self.introspector.get_indexes_info(self.db, tables)
 
         # Build schema structure
         schema_info = self._build_table_structure(tables)
         self._add_columns_to_schema(schema_info, columns)
         self._add_primary_keys_to_schema(schema_info, primary_keys)
         self._add_foreign_keys_to_schema(schema_info, foreign_keys)
+        self._add_indexes_to_schema(schema_info, indexes)
 
         return schema_info
 
@@ -613,6 +963,7 @@ class SchemaManager:
                 "columns": {},
                 "primary_keys": [],
                 "foreign_keys": [],
+                "indexes": [],
             }
         return schema_info
 
@@ -666,6 +1017,31 @@ class SchemaManager:
                     }
                 )
 
+    def _add_indexes_to_schema(
+        self, schema_info: dict[str, dict], indexes: list
+    ) -> None:
+        """Add index information to schema."""
+        for idx in indexes:
+            full_name = f"{idx['table_schema']}.{idx['table_name']}"
+            if full_name in schema_info:
+                # Handle different column name formats from different databases
+                if isinstance(idx["column_names"], list):
+                    columns = idx["column_names"]
+                else:
+                    # MySQL returns comma-separated string
+                    columns = (
+                        idx["column_names"].split(",") if idx["column_names"] else []
+                    )
+
+                schema_info[full_name]["indexes"].append(
+                    {
+                        "name": idx["index_name"],
+                        "columns": columns,
+                        "unique": idx["is_unique"],
+                        "type": idx.get("index_type"),
+                    }
+                )
+
     async def list_tables(self) -> dict[str, Any]:
         """Get a list of all tables with basic information."""
         tables = await self.introspector.list_tables_info(self.db)

sqlsaber/tools/sql_tools.py

@@ -138,6 +138,12 @@ class IntrospectSchemaTool(SQLTool):
                         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"]
+                    ],
                 }
 
             return json.dumps(formatted_info)

{sqlsaber-0.23.0.dist-info → sqlsaber-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.23.0
+Version: 0.25.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -8,10 +8,10 @@ Requires-Dist: aiomysql>=0.2.0
 Requires-Dist: aiosqlite>=0.21.0
 Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: cyclopts>=3.22.1
+Requires-Dist: duckdb>=0.9.2
 Requires-Dist: fastmcp>=2.9.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: keyring>=25.6.0
-Requires-Dist: pandas>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: prompt-toolkit>3.0.51
 Requires-Dist: pydantic-ai
@@ -58,7 +58,7 @@ Ask your questions in natural language and `sqlsaber` will gather the right cont
 - 🧠 Memory management
 - 💬 Interactive REPL mode
 - 🧵 Conversation threads (store, display, and resume conversations)
-- 🗄️ Support for PostgreSQL, SQLite, and MySQL
+- 🗄️ Support for PostgreSQL, MySQL, SQLite, and DuckDB
 - 🔌 MCP (Model Context Protocol) server support
 - 🎨 Beautiful formatted output
 
@@ -170,6 +170,7 @@ saber -d mydb "count all orders"
 
 # You can also pass a connection string
 saber -d "postgresql://user:password@localhost:5432/mydb" "count all orders"
+saber -d "duckdb:///path/to/data.duckdb" "top customers"
 ```
 
 ## Examples

{sqlsaber-0.23.0.dist-info → sqlsaber-0.25.0.dist-info}/RECORD

@@ -1,32 +1,32 @@
 sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
 sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
 sqlsaber/agents/__init__.py,sha256=i_MI2eWMQaVzGikKU71FPCmSQxNDKq36Imq1PrYoIPU,130
-sqlsaber/agents/base.py,sha256=7zOZTHKxUuU0uMc-NTaCkkBfDnU3jtwbT8_eP1ZtJ2k,2615
+sqlsaber/agents/base.py,sha256=EAuoj3vpWNqksudMd2lL1Fmx68Y91qNX6NyK1RjQ4-g,2679
 sqlsaber/agents/mcp.py,sha256=GcJTx7YDYH6aaxIADEIxSgcWAdWakUx395JIzVnf17U,768
-sqlsaber/agents/pydantic_ai_agent.py,sha256=6RvG2O7G8P6NN9QaRXUodg5Q26QJ4ShGWoTGYbVQ5K4,7065
+sqlsaber/agents/pydantic_ai_agent.py,sha256=qn-DnTGcdUzSEn9xBWwGhgtifYxZ_NEo8XPePnl1StE,7154
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/auth.py,sha256=jTsRgbmlGPlASSuIKmdjjwfqtKvjfKd_cTYxX0-QqaQ,7400
-sqlsaber/cli/commands.py,sha256=mjLG9i1bXf0TEroxkIxq5O7Hhjufz3Ad72cyJz7vE1k,8128
+sqlsaber/cli/commands.py,sha256=NyBDr5qEnCOZrHEMGcEpHLXEWdlzEQW3D61NIrPi2fQ,8727
 sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
-sqlsaber/cli/database.py,sha256=JKtHSN-BFzBa14REf0phFVQB7d67m1M5FFaD8N6DdrY,12966
-sqlsaber/cli/display.py,sha256=9uXg0GqFXGAwBj1O7-i6aLPQkGq-iURrsKHk6PWTq1E,15025
-sqlsaber/cli/interactive.py,sha256=7uM4LoXbhPJr8o5yNjICSzL0uxZkp1psWrVq4G9V0OI,13118
+sqlsaber/cli/database.py,sha256=93etjqiYAfH08jBe_OJpLMNKiu3H81G8O7CMB31MIIc,13424
+sqlsaber/cli/display.py,sha256=XuKiTWUw5k0U0P_f1K7zhDWX5KTO2DQVG0Q0XU9VEhs,16334
+sqlsaber/cli/interactive.py,sha256=lVOtONBeAmZxWdfkvdoVoX4POs_-C1YVs0jPxY9MoZs,13288
 sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
 sqlsaber/cli/models.py,sha256=ZewtwGQwhd9b-yxBAPKePolvI1qQG-EkmeWAGMqtWNQ,8986
 sqlsaber/cli/streaming.py,sha256=Eo5CNUgDGY1WYP90jwDA2aY7RefN-TfcStA6NyjUQTY,7076
-sqlsaber/cli/threads.py,sha256=HJ6v9wEv1as21B7IJglYs3q6LH7Plv2oheLbM5YEQQA,11549
+sqlsaber/cli/threads.py,sha256=ufDABlqndVJKd5COgSokcFRIKTgsGqXdHV84DVVm7MA,12743
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=RqWQCko1tY7sES7YOlexgBH5Hd5ne_kGXHdBDNqcV2U,3649
 sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
-sqlsaber/config/database.py,sha256=c6q3l4EvoBch1ckYHA70hf6L7fSOY-sItnLCpvJiPrA,11357
+sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
 sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
 sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
 sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
 sqlsaber/config/settings.py,sha256=vgb_RXaM-7DgbxYDmWNw1cSyMqwys4j3qNCvM4bljwI,5586
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
-sqlsaber/database/connection.py,sha256=1bDPEa6cmdh87gPfhNeBLpOdI0E2_2KlE74q_-4l_jI,18913
-sqlsaber/database/resolver.py,sha256=RPXF5EoKzvQDDLmPGNHYd2uG_oNICH8qvUjBp6iXmNY,3348
-sqlsaber/database/schema.py,sha256=r12qoN3tdtAXdO22EKlauAe7QwOm8lL2vTMM59XEMMY,26594
+sqlsaber/database/connection.py,sha256=J3U08Qu7NQrmem0jPM5XKIHPmPJE927IiLhN8zA6oLo,19392
+sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
+sqlsaber/database/schema.py,sha256=9HXTb5O_nlS2aNDeyv7EXhX7_kN2hs6rbPnJ8fnLyWk,41260
 sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
 sqlsaber/mcp/mcp.py,sha256=X12oCMZYAtgJ7MNuh5cqz8y3lALrOzkXWcfpuY0Ijxk,3950
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
@@ -39,9 +39,9 @@ sqlsaber/tools/base.py,sha256=mHhvAj27BHmckyvuDLCPlAQdzABJyYxd9SJnaYAwwuA,1777
 sqlsaber/tools/enums.py,sha256=CH32mL-0k9ZA18911xLpNtsgpV6tB85TktMj6uqGz54,411
 sqlsaber/tools/instructions.py,sha256=X-x8maVkkyi16b6Tl0hcAFgjiYceZaSwyWTfmrvx8U8,9024
 sqlsaber/tools/registry.py,sha256=HWOQMsNIdL4XZS6TeNUyrL-5KoSDH6PHsWd3X66o-18,3211
-sqlsaber/tools/sql_tools.py,sha256=hM6tKqW5MDhFUt6MesoqhTUqIpq_5baIIDoN1MjDCXY,9647
-sqlsaber-0.23.0.dist-info/METADATA,sha256=olVI7W6UB-F6oZUqOjTWhJAvYtDbXXO0xoeOVYYmpfM,6178
-sqlsaber-0.23.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.23.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.23.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.23.0.dist-info/RECORD,,
+sqlsaber/tools/sql_tools.py,sha256=j4yRqfKokPFnZ_tEZPrWU5WStDc3Mexo1fWZ8KsmUjQ,9965
+sqlsaber-0.25.0.dist-info/METADATA,sha256=9Q2AsBv4I78FLo8Uezmnv_fCch3jIKgv1gzBBm1cVB4,6243
+sqlsaber-0.25.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.25.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
+sqlsaber-0.25.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.25.0.dist-info/RECORD,,