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

sqlsaber/agents/base.py

@@ -8,6 +8,7 @@ from typing import Any, AsyncIterator
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
     CSVConnection,
+    DuckDBConnection,
     MySQLConnection,
     PostgreSQLConnection,
     SQLiteConnection,
@@ -51,7 +52,9 @@ class BaseSQLAgent(ABC):
         elif isinstance(self.db, SQLiteConnection):
             return "SQLite"
         elif isinstance(self.db, CSVConnection):
-            return "SQLite"  # we convert csv to in-memory sqlite
+            return "DuckDB"
+        elif isinstance(self.db, DuckDBConnection):
+            return "DuckDB"
         else:
             return "database"  # Fallback
 

sqlsaber/agents/pydantic_ai_agent.py

@@ -17,6 +17,7 @@ from sqlsaber.config.settings import Config
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
     CSVConnection,
+    DuckDBConnection,
     MySQLConnection,
     PostgreSQLConnection,
     SQLiteConnection,
@@ -169,7 +170,9 @@ def _get_database_type_name(db: BaseDatabaseConnection) -> str:
         return "MySQL"
     elif isinstance(db, SQLiteConnection):
         return "SQLite"
+    elif isinstance(db, DuckDBConnection):
+        return "DuckDB"
     elif isinstance(db, CSVConnection):
-        return "SQLite"
+        return "DuckDB"
     else:
         return "database"

sqlsaber/cli/commands.py

@@ -46,7 +46,7 @@ def meta_handler(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite/DuckDB), or connection string (postgresql://, mysql://, duckdb://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -59,8 +59,10 @@ def meta_handler(
         saber -d mydb "show me users"          # Run a query with specific database
         saber -d data.csv "show me users"      # Run a query with ad-hoc CSV file
         saber -d data.db "show me users"       # Run a query with ad-hoc SQLite file
+        saber -d data.duckdb "show me users"   # Run a query with ad-hoc DuckDB file
         saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
         saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
+        saber -d "duckdb:///data.duckdb" "show users"                 # DuckDB connection string
         echo "show me all users" | saber       # Read query from stdin
         cat query.txt | saber                  # Read query from file via stdin
     """
@@ -80,7 +82,7 @@ def query(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite/DuckDB), or connection string (postgresql://, mysql://, duckdb://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -97,8 +99,10 @@ def query(
         saber "show me all users"         # Run a single query
         saber -d data.csv "show users"    # Run a query with ad-hoc CSV file
         saber -d data.db "show users"     # Run a query with ad-hoc SQLite file
+        saber -d data.duckdb "show users" # Run a query with ad-hoc DuckDB file
         saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
         saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
+        saber -d "duckdb:///data.duckdb" "show users"                 # DuckDB connection string
         echo "show me all users" | saber  # Read query from stdin
     """
 
@@ -111,6 +115,7 @@ def query(
         from sqlsaber.database.connection import (
             CSVConnection,
             DatabaseConnection,
+            DuckDBConnection,
             MySQLConnection,
             PostgreSQLConnection,
             SQLiteConnection,
@@ -149,15 +154,18 @@ def query(
                 # Single query mode with streaming
                 streaming_handler = StreamingQueryHandler(console)
                 # Compute DB type for the greeting line
-                db_type = (
-                    "PostgreSQL"
-                    if isinstance(db_conn, PostgreSQLConnection)
-                    else "MySQL"
-                    if isinstance(db_conn, MySQLConnection)
-                    else "SQLite"
-                    if isinstance(db_conn, (SQLiteConnection, CSVConnection))
-                    else "database"
-                )
+                if isinstance(db_conn, PostgreSQLConnection):
+                    db_type = "PostgreSQL"
+                elif isinstance(db_conn, MySQLConnection):
+                    db_type = "MySQL"
+                elif isinstance(db_conn, DuckDBConnection):
+                    db_type = "DuckDB"
+                elif isinstance(db_conn, SQLiteConnection):
+                    db_type = "SQLite"
+                elif isinstance(db_conn, CSVConnection):
+                    db_type = "DuckDB"
+                else:
+                    db_type = "database"
                 console.print(
                     f"[bold blue]Connected to:[/bold blue] {db_name} ({db_type})\n"
                 )

sqlsaber/cli/database.py

@@ -31,7 +31,7 @@ def add(
         str,
         cyclopts.Parameter(
             ["--type", "-t"],
-            help="Database type (postgresql, mysql, sqlite)",
+            help="Database type (postgresql, mysql, sqlite, duckdb)",
         ),
     ] = "postgresql",
     host: Annotated[
@@ -87,17 +87,17 @@ def add(
         if not type or type == "postgresql":
             type = questionary.select(
                 "Database type:",
-                choices=["postgresql", "mysql", "sqlite"],
+                choices=["postgresql", "mysql", "sqlite", "duckdb"],
                 default="postgresql",
             ).ask()
 
-        if type == "sqlite":
-            # SQLite only needs database path
+        if type in {"sqlite", "duckdb"}:
+            # SQLite/DuckDB only need database file path
             database = database or questionary.path("Database file path:").ask()
             database = str(Path(database).expanduser().resolve())
             host = "localhost"
             port = 0
-            username = "sqlite"
+            username = type
             password = ""
         else:
             # PostgreSQL/MySQL need connection details
@@ -182,6 +182,17 @@ def add(
             port = 0
             username = "sqlite"
             password = ""
+        elif type == "duckdb":
+            if not database:
+                console.print(
+                    "[bold red]Error:[/bold red] Database file path is required for DuckDB"
+                )
+                sys.exit(1)
+            database = str(Path(database).expanduser().resolve())
+            host = "localhost"
+            port = 0
+            username = "duckdb"
+            password = ""
         else:
             if not all([host, database, username]):
                 console.print(
@@ -264,7 +275,7 @@ def list():
             if db.ssl_ca or db.ssl_cert:
                 ssl_status += " (certs)"
         else:
-            ssl_status = "disabled" if db.type != "sqlite" else "N/A"
+            ssl_status = "disabled" if db.type not in {"sqlite", "duckdb"} else "N/A"
 
         table.add_row(
             db.name,

sqlsaber/cli/interactive.py

@@ -23,6 +23,7 @@ from sqlsaber.cli.display import DisplayManager
 from sqlsaber.cli.streaming import StreamingQueryHandler
 from sqlsaber.database.connection import (
     CSVConnection,
+    DuckDBConnection,
     MySQLConnection,
     PostgreSQLConnection,
     SQLiteConnection,
@@ -85,8 +86,12 @@ class InteractiveSession:
             if isinstance(self.db_conn, PostgreSQLConnection)
             else "MySQL"
             if isinstance(self.db_conn, MySQLConnection)
+            else "DuckDB"
+            if isinstance(self.db_conn, DuckDBConnection)
+            else "DuckDB"
+            if isinstance(self.db_conn, CSVConnection)
             else "SQLite"
-            if isinstance(self.db_conn, (SQLiteConnection, CSVConnection))
+            if isinstance(self.db_conn, SQLiteConnection)
             else "database"
         )
 

sqlsaber/config/database.py

@@ -18,7 +18,7 @@ class DatabaseConfig:
     """Database connection configuration."""
 
     name: str
-    type: str  # postgresql, mysql, sqlite, csv
+    type: str  # postgresql, mysql, sqlite, duckdb, csv
     host: str | None
     port: int | None
     database: str
@@ -90,6 +90,8 @@ class DatabaseConfig:
 
         elif self.type == "sqlite":
             return f"sqlite:///{self.database}"
+        elif self.type == "duckdb":
+            return f"duckdb:///{self.database}"
         elif self.type == "csv":
             # For CSV files, database field contains the file path
             base_url = f"csv:///{self.database}"

sqlsaber/database/connection.py

@@ -10,6 +10,7 @@ from urllib.parse import parse_qs, urlparse
 import aiomysql
 import aiosqlite
 import asyncpg
+import duckdb
 
 # Default query timeout to prevent runaway queries
 DEFAULT_QUERY_TIMEOUT = 30.0  # seconds
@@ -351,115 +352,143 @@ class SQLiteConnection(BaseDatabaseConnection):
                 await conn.rollback()
 
 
+def _execute_duckdb_transaction(
+    conn: duckdb.DuckDBPyConnection, query: str, args: tuple[Any, ...]
+) -> list[dict[str, Any]]:
+    """Run a DuckDB query inside a transaction and return list of dicts."""
+    conn.execute("BEGIN TRANSACTION")
+    try:
+        if args:
+            conn.execute(query, args)
+        else:
+            conn.execute(query)
+
+        if conn.description is None:
+            rows: list[dict[str, Any]] = []
+        else:
+            columns = [col[0] for col in conn.description]
+            data = conn.fetchall()
+            rows = [dict(zip(columns, row)) for row in data]
+
+        conn.execute("ROLLBACK")
+        return rows
+    except Exception:
+        conn.execute("ROLLBACK")
+        raise
+
+
 class CSVConnection(BaseDatabaseConnection):
-    """CSV file connection using in-memory SQLite database."""
+    """CSV file connection using DuckDB per query."""
 
     def __init__(self, connection_string: str):
         super().__init__(connection_string)
 
-        # Parse CSV file path from connection string
-        self.csv_path = connection_string.replace("csv:///", "")
+        raw_path = connection_string.replace("csv:///", "", 1)
+        self.csv_path = raw_path.split("?", 1)[0]
 
-        # CSV parsing options
         self.delimiter = ","
         self.encoding = "utf-8"
         self.has_header = True
 
-        # Parse additional options from connection string
         parsed = urlparse(connection_string)
         if parsed.query:
             params = parse_qs(parsed.query)
-            self.delimiter = params.get("delimiter", [","])[0]
-            self.encoding = params.get("encoding", ["utf-8"])[0]
+            self.delimiter = params.get("delimiter", [self.delimiter])[0]
+            self.encoding = params.get("encoding", [self.encoding])[0]
             self.has_header = params.get("header", ["true"])[0].lower() == "true"
 
-        # Table name derived from filename
-        self.table_name = Path(self.csv_path).stem
-
-        # Initialize connection and flag to track if CSV is loaded
-        self._conn = None
-        self._csv_loaded = False
+        self.table_name = Path(self.csv_path).stem or "csv_table"
 
     async def get_pool(self):
-        """Get or create the in-memory database connection."""
-        if self._conn is None:
-            self._conn = await aiosqlite.connect(":memory:")
-            self._conn.row_factory = aiosqlite.Row
-            await self._load_csv_data()
-        return self._conn
+        """CSV connections do not maintain a pool."""
+        return None
 
     async def close(self):
-        """Close the database connection."""
-        if self._conn:
-            await self._conn.close()
-            self._conn = None
-            self._csv_loaded = False
+        """No persistent resources to close for CSV connections."""
+        pass
+
+    def _quote_identifier(self, identifier: str) -> str:
+        escaped = identifier.replace('"', '""')
+        return f'"{escaped}"'
+
+    def _quote_literal(self, value: str) -> str:
+        escaped = value.replace("'", "''")
+        return f"'{escaped}'"
+
+    def _normalized_encoding(self) -> str | None:
+        encoding = (self.encoding or "").strip()
+        if not encoding or encoding.lower() == "utf-8":
+            return None
+        return encoding.replace("-", "").replace("_", "").upper()
+
+    def _create_view(self, conn: duckdb.DuckDBPyConnection) -> None:
+        header_literal = "TRUE" if self.has_header else "FALSE"
+        option_parts = [f"HEADER={header_literal}"]
+
+        if self.delimiter:
+            option_parts.append(f"DELIM={self._quote_literal(self.delimiter)}")
+
+        encoding = self._normalized_encoding()
+        if encoding:
+            option_parts.append(f"ENCODING={self._quote_literal(encoding)}")
+
+        options_sql = ""
+        if option_parts:
+            options_sql = ", " + ", ".join(option_parts)
+
+        base_relation_sql = (
+            f"read_csv_auto({self._quote_literal(self.csv_path)}{options_sql})"
+        )
+
+        create_view_sql = (
+            f"CREATE VIEW {self._quote_identifier(self.table_name)} AS "
+            f"SELECT * FROM {base_relation_sql}"
+        )
+        conn.execute(create_view_sql)
+
+    async def execute_query(
+        self, query: str, *args, timeout: float | None = None
+    ) -> list[dict[str, Any]]:
+        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
+        args_tuple = tuple(args) if args else tuple()
 
-    async def _load_csv_data(self):
-        """Load CSV data into the in-memory SQLite database."""
-        if self._csv_loaded or not self._conn:
-            return
+        def _run_query() -> list[dict[str, Any]]:
+            conn = duckdb.connect(":memory:")
+            try:
+                self._create_view(conn)
+                return _execute_duckdb_transaction(conn, query, args_tuple)
+            finally:
+                conn.close()
 
         try:
-            # Import pandas only when needed for CSV operations
-            # This improves CLI load times
-            import pandas as pd
-
-            # Read CSV file using pandas
-            df = pd.read_csv(
-                self.csv_path,
-                delimiter=self.delimiter,
-                encoding=self.encoding,
-                header=0 if self.has_header else None,
+            return await asyncio.wait_for(
+                asyncio.to_thread(_run_query), timeout=effective_timeout
             )
+        except asyncio.TimeoutError as exc:
+            raise QueryTimeoutError(effective_timeout or 0) from exc
 
-            # If no header, create column names
-            if not self.has_header:
-                df.columns = [f"column_{i}" for i in range(len(df.columns))]
-
-            # Create table with proper column types
-            columns_sql = []
-            for col in df.columns:
-                # Infer SQLite type from pandas dtype
-                dtype = df[col].dtype
-                if pd.api.types.is_integer_dtype(dtype):
-                    sql_type = "INTEGER"
-                elif pd.api.types.is_float_dtype(dtype):
-                    sql_type = "REAL"
-                elif pd.api.types.is_bool_dtype(dtype):
-                    sql_type = "INTEGER"  # SQLite doesn't have BOOLEAN
-                else:
-                    sql_type = "TEXT"
 
-                columns_sql.append(f'"{col}" {sql_type}')
+class DuckDBConnection(BaseDatabaseConnection):
+    """DuckDB database connection using duckdb Python API."""
 
-            create_table_sql = (
-                f'CREATE TABLE "{self.table_name}" ({", ".join(columns_sql)})'
-            )
-            await self._conn.execute(create_table_sql)
-
-            # Insert data row by row
-            placeholders = ", ".join(["?" for _ in df.columns])
-            insert_sql = f'INSERT INTO "{self.table_name}" VALUES ({placeholders})'
-
-            for _, row in df.iterrows():
-                # Convert pandas values to Python native types
-                values = []
-                for val in row:
-                    if pd.isna(val):
-                        values.append(None)
-                    elif isinstance(val, (pd.Timestamp, pd.Timedelta)):
-                        values.append(str(val))
-                    else:
-                        values.append(val)
+    def __init__(self, connection_string: str):
+        super().__init__(connection_string)
+        if connection_string.startswith("duckdb:///"):
+            db_path = connection_string.replace("duckdb:///", "", 1)
+        elif connection_string.startswith("duckdb://"):
+            db_path = connection_string.replace("duckdb://", "", 1)
+        else:
+            db_path = connection_string
 
-                await self._conn.execute(insert_sql, values)
+        self.database_path = db_path or ":memory:"
 
-            await self._conn.commit()
-            self._csv_loaded = True
+    async def get_pool(self):
+        """DuckDB creates connections per query, return database path."""
+        return self.database_path
 
-        except Exception as e:
-            raise ValueError(f"Error loading CSV file '{self.csv_path}': {str(e)}")
+    async def close(self):
+        """DuckDB connections are created per query, no persistent pool to close."""
+        pass
 
     async def execute_query(
         self, query: str, *args, timeout: float | None = None
@@ -470,29 +499,22 @@ class CSVConnection(BaseDatabaseConnection):
         ensuring no changes are persisted to the database.
         """
         effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-        conn = await self.get_pool()
 
-        # Start transaction
-        await conn.execute("BEGIN")
-        try:
-            # Execute query with client-side timeout (CSV uses in-memory SQLite)
-            if effective_timeout:
-                cursor = await asyncio.wait_for(
-                    conn.execute(query, args if args else ()), timeout=effective_timeout
-                )
-                rows = await asyncio.wait_for(
-                    cursor.fetchall(), timeout=effective_timeout
-                )
-            else:
-                cursor = await conn.execute(query, args if args else ())
-                rows = await cursor.fetchall()
+        args_tuple = tuple(args) if args else tuple()
 
-            return [dict(row) for row in rows]
+        def _run_query() -> list[dict[str, Any]]:
+            conn = duckdb.connect(self.database_path)
+            try:
+                return _execute_duckdb_transaction(conn, query, args_tuple)
+            finally:
+                conn.close()
+
+        try:
+            return await asyncio.wait_for(
+                asyncio.to_thread(_run_query), timeout=effective_timeout
+            )
         except asyncio.TimeoutError as exc:
             raise QueryTimeoutError(effective_timeout or 0) from exc
-        finally:
-            # Always rollback to ensure no changes are committed
-            await conn.rollback()
 
 
 def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
@@ -503,6 +525,8 @@ def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
         return MySQLConnection(connection_string)
     elif connection_string.startswith("sqlite:///"):
         return SQLiteConnection(connection_string)
+    elif connection_string.startswith("duckdb://"):
+        return DuckDBConnection(connection_string)
     elif connection_string.startswith("csv:///"):
         return CSVConnection(connection_string)
     else:

sqlsaber/database/resolver.py

@@ -23,7 +23,7 @@ class ResolvedDatabase:
     connection_string: str  # Canonical connection string for DatabaseConnection factory
 
 
-SUPPORTED_SCHEMES = {"postgresql", "mysql", "sqlite", "csv"}
+SUPPORTED_SCHEMES = {"postgresql", "mysql", "sqlite", "duckdb", "csv"}
 
 
 def _is_connection_string(s: str) -> bool:
@@ -67,8 +67,8 @@ def resolve_database(
         scheme = urlparse(spec).scheme
         if scheme in {"postgresql", "mysql"}:
             db_name = urlparse(spec).path.lstrip("/") or "database"
-        elif scheme in {"sqlite", "csv"}:
-            db_name = Path(urlparse(spec).path).stem
+        elif scheme in {"sqlite", "duckdb", "csv"}:
+            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)
@@ -83,6 +83,10 @@ def resolve_database(
         if not path.exists():
             raise DatabaseResolutionError(f"SQLite file '{spec}' not found.")
         return ResolvedDatabase(name=path.stem, connection_string=f"sqlite:///{path}")
+    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}")
 
     # 3. Must be a configured name
     db_cfg: DatabaseConfig | None = config_mgr.get_database(spec)

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,
@@ -682,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."""
 
@@ -693,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)}"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.24.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.24.0.dist-info → sqlsaber-0.25.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
 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/database.py,sha256=93etjqiYAfH08jBe_OJpLMNKiu3H81G8O7CMB31MIIc,13424
 sqlsaber/cli/display.py,sha256=XuKiTWUw5k0U0P_f1K7zhDWX5KTO2DQVG0Q0XU9VEhs,16334
-sqlsaber/cli/interactive.py,sha256=7uM4LoXbhPJr8o5yNjICSzL0uxZkp1psWrVq4G9V0OI,13118
+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
@@ -18,15 +18,15 @@ 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=Le5DXSgpsWyhMDuY6qpc_dsP4jjMXgJTRtAKq9S5Oog,32868
+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
@@ -40,8 +40,8 @@ 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=j4yRqfKokPFnZ_tEZPrWU5WStDc3Mexo1fWZ8KsmUjQ,9965
-sqlsaber-0.24.0.dist-info/METADATA,sha256=cPXj4eFPU-I6AWgHVVboKwu3zMmYKvs46LtrmZCBlhU,6178
-sqlsaber-0.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.24.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.24.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.24.0.dist-info/RECORD,,
+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,,