sqlsaber 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

sqlsaber/agents/anthropic.py

@@ -11,13 +11,7 @@ from sqlsaber.agents.streaming import (
     build_tool_result_block,
 )
 from sqlsaber.config.settings import Config
-from sqlsaber.database.connection import (
-    BaseDatabaseConnection,
-    MySQLConnection,
-    PostgreSQLConnection,
-    SQLiteConnection,
-)
-from sqlsaber.database.schema import SchemaManager
+from sqlsaber.database.connection import BaseDatabaseConnection
 from sqlsaber.memory.manager import MemoryManager
 from sqlsaber.models.events import StreamEvent
 from sqlsaber.models.types import ToolDefinition
@@ -36,7 +30,6 @@ class AnthropicSQLAgent(BaseSQLAgent):
 
         self.client = AsyncAnthropic(api_key=config.api_key)
         self.model = config.model_name.replace("anthropic:", "")
-        self.schema_manager = SchemaManager(db_connection)
 
         self.database_name = database_name
         self.memory_manager = MemoryManager()
@@ -94,17 +87,6 @@ class AnthropicSQLAgent(BaseSQLAgent):
         # Build system prompt with memories if available
         self.system_prompt = self._build_system_prompt()
 
-    def _get_database_type_name(self) -> str:
-        """Get the human-readable database type name."""
-        if isinstance(self.db, PostgreSQLConnection):
-            return "PostgreSQL"
-        elif isinstance(self.db, MySQLConnection):
-            return "MySQL"
-        elif isinstance(self.db, SQLiteConnection):
-            return "SQLite"
-        else:
-            return "database"  # Fallback
-
     def _build_system_prompt(self) -> str:
         """Build system prompt with optional memory context."""
         db_type = self._get_database_type_name()
@@ -152,109 +134,33 @@ Guidelines:
         self.system_prompt = self._build_system_prompt()
         return memory.id
 
-    async def introspect_schema(self, table_pattern: Optional[str] = None) -> str:
-        """Introspect database schema to understand table structures."""
-        try:
-            # Pass table_pattern to get_schema_info for efficient filtering at DB level
-            schema_info = await self.schema_manager.get_schema_info(table_pattern)
-
-            # 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"]
-                    ],
-                }
-
-            return json.dumps(formatted_info)
-        except Exception as e:
-            return json.dumps({"error": f"Error introspecting schema: {str(e)}"})
-
-    async def list_tables(self) -> str:
-        """List all tables in the database with basic information."""
-        try:
-            tables_info = await self.schema_manager.list_tables()
-            return json.dumps(tables_info)
-        except Exception as e:
-            return json.dumps({"error": f"Error listing tables: {str(e)}"})
-
     async def execute_sql(self, query: str, limit: Optional[int] = 100) -> str:
-        """Execute a SQL query against the database."""
-        try:
-            # Security check - only allow SELECT queries unless write is enabled
-            write_error = self._validate_write_operation(query)
-            if write_error:
-                return json.dumps(
-                    {
-                        "error": write_error,
-                    }
-                )
-
-            # Add LIMIT if not present and it's a SELECT query
-            query = self._add_limit_to_query(query, limit)
-
-            # Execute the query (wrapped in a transaction for safety)
-            results = await self.db.execute_query(query)
-
-            # Format results - but also store the actual data
-            actual_limit = limit if limit is not None else len(results)
-            self._last_results = results[:actual_limit]
-            self._last_query = query
+        """Execute a SQL query against the database with streaming support."""
+        # Call parent implementation for core functionality
+        result = await super().execute_sql(query, limit)
 
-            return json.dumps(
-                {
-                    "success": True,
-                    "row_count": len(results),
-                    "results": results[:actual_limit],  # Extra safety for limit
-                    "truncated": len(results) > actual_limit,
-                }
-            )
-
-        except Exception as e:
-            error_msg = str(e)
-
-            # Provide helpful error messages
-            suggestions = []
-            if "column" in error_msg.lower() and "does not exist" in error_msg.lower():
-                suggestions.append(
-                    "Check column names using the schema introspection tool"
-                )
-            elif "table" in error_msg.lower() and "does not exist" in error_msg.lower():
-                suggestions.append(
-                    "Check table names using the schema introspection tool"
-                )
-            elif "syntax error" in error_msg.lower():
-                suggestions.append(
-                    "Review SQL syntax, especially JOIN conditions and WHERE clauses"
+        # Parse result to extract data for streaming (AnthropicSQLAgent specific)
+        try:
+            result_data = json.loads(result)
+            if result_data.get("success") and "results" in result_data:
+                # Store results for streaming
+                actual_limit = (
+                    limit if limit is not None else len(result_data["results"])
                 )
+                self._last_results = result_data["results"][:actual_limit]
+                self._last_query = query
+        except (json.JSONDecodeError, KeyError):
+            # If we can't parse the result, just continue without storing
+            pass
 
-            return json.dumps({"error": error_msg, "suggestions": suggestions})
+        return result
 
     async def process_tool_call(
         self, tool_name: str, tool_input: Dict[str, Any]
     ) -> str:
         """Process a tool call and return the result."""
-        if tool_name == "list_tables":
-            return await self.list_tables()
-        elif tool_name == "introspect_schema":
-            return await self.introspect_schema(tool_input.get("table_pattern"))
-        elif tool_name == "execute_sql":
-            return await self.execute_sql(
-                tool_input["query"], tool_input.get("limit", 100)
-            )
-        else:
-            return json.dumps({"error": f"Unknown tool: {tool_name}"})
+        # Use parent implementation for core tools
+        return await super().process_tool_call(tool_name, tool_input)
 
     async def _process_stream_events(
         self, stream, content_blocks: List[Dict], tool_use_blocks: List[Dict]

sqlsaber/agents/base.py

@@ -1,9 +1,17 @@
 """Abstract base class for SQL agents."""
 
+import json
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Dict, List, Optional
 
-from sqlsaber.database.connection import BaseDatabaseConnection
+from sqlsaber.database.connection import (
+    BaseDatabaseConnection,
+    CSVConnection,
+    MySQLConnection,
+    PostgreSQLConnection,
+    SQLiteConnection,
+)
+from sqlsaber.database.schema import SchemaManager
 from sqlsaber.models.events import StreamEvent
 
 
@@ -12,6 +20,7 @@ class BaseSQLAgent(ABC):
 
     def __init__(self, db_connection: BaseDatabaseConnection):
         self.db = db_connection
+        self.schema_manager = SchemaManager(db_connection)
         self.conversation_history: List[Dict[str, Any]] = []
 
     @abstractmethod
@@ -25,12 +34,120 @@ class BaseSQLAgent(ABC):
         """Clear conversation history."""
         self.conversation_history = []
 
-    @abstractmethod
+    def _get_database_type_name(self) -> str:
+        """Get the human-readable database type name."""
+        if isinstance(self.db, PostgreSQLConnection):
+            return "PostgreSQL"
+        elif isinstance(self.db, MySQLConnection):
+            return "MySQL"
+        elif isinstance(self.db, SQLiteConnection):
+            return "SQLite"
+        elif isinstance(self.db, CSVConnection):
+            return "SQLite"  # we convert csv to in-memory sqlite
+        else:
+            return "database"  # Fallback
+
+    async def introspect_schema(self, table_pattern: Optional[str] = None) -> str:
+        """Introspect database schema to understand table structures."""
+        try:
+            # Pass table_pattern to get_schema_info for efficient filtering at DB level
+            schema_info = await self.schema_manager.get_schema_info(table_pattern)
+
+            # 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"]
+                    ],
+                }
+
+            return json.dumps(formatted_info)
+        except Exception as e:
+            return json.dumps({"error": f"Error introspecting schema: {str(e)}"})
+
+    async def list_tables(self) -> str:
+        """List all tables in the database with basic information."""
+        try:
+            tables_info = await self.schema_manager.list_tables()
+            return json.dumps(tables_info)
+        except Exception as e:
+            return json.dumps({"error": f"Error listing tables: {str(e)}"})
+
+    async def execute_sql(self, query: str, limit: Optional[int] = 100) -> str:
+        """Execute a SQL query against the database."""
+        try:
+            # Security check - only allow SELECT queries unless write is enabled
+            write_error = self._validate_write_operation(query)
+            if write_error:
+                return json.dumps(
+                    {
+                        "error": write_error,
+                    }
+                )
+
+            # Add LIMIT if not present and it's a SELECT query
+            query = self._add_limit_to_query(query, limit)
+
+            # Execute the query (wrapped in a transaction for safety)
+            results = await self.db.execute_query(query)
+
+            # Format results
+            actual_limit = limit if limit is not None else len(results)
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "row_count": len(results),
+                    "results": results[:actual_limit],  # Extra safety for limit
+                    "truncated": len(results) > actual_limit,
+                }
+            )
+
+        except Exception as e:
+            error_msg = str(e)
+
+            # Provide helpful error messages
+            suggestions = []
+            if "column" in error_msg.lower() and "does not exist" in error_msg.lower():
+                suggestions.append(
+                    "Check column names using the schema introspection tool"
+                )
+            elif "table" in error_msg.lower() and "does not exist" in error_msg.lower():
+                suggestions.append(
+                    "Check table names using the schema introspection tool"
+                )
+            elif "syntax error" in error_msg.lower():
+                suggestions.append(
+                    "Review SQL syntax, especially JOIN conditions and WHERE clauses"
+                )
+
+            return json.dumps({"error": error_msg, "suggestions": suggestions})
+
     async def process_tool_call(
         self, tool_name: str, tool_input: Dict[str, Any]
     ) -> str:
         """Process a tool call and return the result."""
-        pass
+        if tool_name == "list_tables":
+            return await self.list_tables()
+        elif tool_name == "introspect_schema":
+            return await self.introspect_schema(tool_input.get("table_pattern"))
+        elif tool_name == "execute_sql":
+            return await self.execute_sql(
+                tool_input["query"], tool_input.get("limit", 100)
+            )
+        else:
+            return json.dumps({"error": f"Unknown tool: {tool_name}"})
 
     def _validate_write_operation(self, query: str) -> Optional[str]:
         """Validate if a write operation is allowed.

sqlsaber/agents/streaming.py

@@ -14,13 +14,3 @@ class StreamingResponse:
 def build_tool_result_block(tool_use_id: str, content: str) -> Dict[str, Any]:
     """Build a tool result block for the conversation."""
     return {"type": "tool_result", "tool_use_id": tool_use_id, "content": content}
-
-
-def extract_sql_from_text(text: str) -> str:
-    """Extract SQL query from markdown-formatted text."""
-    if "```sql" in text:
-        sql_start = text.find("```sql") + 6
-        sql_end = text.find("```", sql_start)
-        if sql_end > sql_start:
-            return text[sql_start:sql_end].strip()
-    return ""

sqlsaber/cli/commands.py

@@ -1,6 +1,7 @@
 """CLI command definitions and handlers."""
 
 import asyncio
+from pathlib import Path
 from typing import Optional
 
 import typer
@@ -62,15 +63,31 @@ def query(
     """Run a query against the database or start interactive mode."""
 
     async def run_session():
-        # Get database configuration
+        # Get database configuration or handle direct CSV file
         if database:
-            db_config = config_manager.get_database(database)
-            if not db_config:
-                console.print(
-                    f"[bold red]Error:[/bold red] Database connection '{database}' not found."
-                )
-                console.print("Use 'sqlsaber db list' to see available connections.")
-                raise typer.Exit(1)
+            # Check if this is a direct CSV file path
+            if database.endswith(".csv"):
+                csv_path = Path(database).expanduser().resolve()
+                if not csv_path.exists():
+                    console.print(
+                        f"[bold red]Error:[/bold red] CSV file '{database}' not found."
+                    )
+                    raise typer.Exit(1)
+                connection_string = f"csv:///{csv_path}"
+                db_name = csv_path.stem
+            else:
+                # Look up configured database connection
+                db_config = config_manager.get_database(database)
+                if not db_config:
+                    console.print(
+                        f"[bold red]Error:[/bold red] Database connection '{database}' not found."
+                    )
+                    console.print(
+                        "Use 'sqlsaber db list' to see available connections."
+                    )
+                    raise typer.Exit(1)
+                connection_string = db_config.to_connection_string()
+                db_name = db_config.name
         else:
             db_config = config_manager.get_default_database()
             if not db_config:
@@ -81,10 +98,11 @@ def query(
                     "Use 'sqlsaber db add <name>' to add a database connection."
                 )
                 raise typer.Exit(1)
+            connection_string = db_config.to_connection_string()
+            db_name = db_config.name
 
         # Create database connection
         try:
-            connection_string = db_config.to_connection_string()
             db_conn = DatabaseConnection(connection_string)
         except Exception as e:
             console.print(
@@ -93,7 +111,7 @@ def query(
             raise typer.Exit(1)
 
         # Create agent instance with database name for memory context
-        agent = AnthropicSQLAgent(db_conn, db_config.name)
+        agent = AnthropicSQLAgent(db_conn, db_name)
 
         try:
             if query_text:

sqlsaber/cli/database.py

@@ -40,6 +40,20 @@ def add_database(
         None, "--database", "--db", help="Database name"
     ),
     username: Optional[str] = typer.Option(None, "--username", "-u", help="Username"),
+    ssl_mode: Optional[str] = typer.Option(
+        None,
+        "--ssl-mode",
+        help="SSL mode (disable, allow, prefer, require, verify-ca, verify-full for PostgreSQL; DISABLED, PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY for MySQL)",
+    ),
+    ssl_ca: Optional[str] = typer.Option(
+        None, "--ssl-ca", help="SSL CA certificate file path"
+    ),
+    ssl_cert: Optional[str] = typer.Option(
+        None, "--ssl-cert", help="SSL client certificate file path"
+    ),
+    ssl_key: Optional[str] = typer.Option(
+        None, "--ssl-key", help="SSL client private key file path"
+    ),
     interactive: bool = typer.Option(
         True, "--interactive/--no-interactive", help="Use interactive mode"
     ),
@@ -61,7 +75,7 @@ def add_database(
         if type == "sqlite":
             # SQLite only needs database path
             database = database or questionary.path("Database file path:").ask()
-            database = str(Path(database).expanduser())
+            database = str(Path(database).expanduser().resolve())
             host = "localhost"
             port = 0
             username = "sqlite"
@@ -80,6 +94,63 @@ def add_database(
 
             # Ask for password
             password = getpass.getpass("Password (stored in your OS keychain): ")
+
+            # Ask for SSL configuration
+            if questionary.confirm("Configure SSL/TLS settings?", default=False).ask():
+                if type == "postgresql":
+                    ssl_mode = (
+                        ssl_mode
+                        or questionary.select(
+                            "SSL mode for PostgreSQL:",
+                            choices=[
+                                "disable",
+                                "allow",
+                                "prefer",
+                                "require",
+                                "verify-ca",
+                                "verify-full",
+                            ],
+                            default="prefer",
+                        ).ask()
+                    )
+                elif type == "mysql":
+                    ssl_mode = (
+                        ssl_mode
+                        or questionary.select(
+                            "SSL mode for MySQL:",
+                            choices=[
+                                "DISABLED",
+                                "PREFERRED",
+                                "REQUIRED",
+                                "VERIFY_CA",
+                                "VERIFY_IDENTITY",
+                            ],
+                            default="PREFERRED",
+                        ).ask()
+                    )
+
+                if ssl_mode and ssl_mode not in ["disable", "DISABLED"]:
+                    if questionary.confirm(
+                        "Specify SSL certificate files?", default=False
+                    ).ask():
+                        ssl_ca = (
+                            ssl_ca or questionary.path("SSL CA certificate file:").ask()
+                        )
+                        if questionary.confirm(
+                            "Specify client certificate?", default=False
+                        ).ask():
+                            ssl_cert = (
+                                ssl_cert
+                                or questionary.path(
+                                    "SSL client certificate file:"
+                                ).ask()
+                            )
+                            ssl_key = (
+                                ssl_key
+                                or questionary.path(
+                                    "SSL client private key file:"
+                                ).ask()
+                            )
     else:
         # Non-interactive mode - use provided values or defaults
         if type == "sqlite":
@@ -123,6 +194,10 @@ def add_database(
         port=port,
         database=database,
         username=username,
+        ssl_mode=ssl_mode,
+        ssl_ca=ssl_ca,
+        ssl_cert=ssl_cert,
+        ssl_key=ssl_key,
     )
 
     try:
@@ -157,10 +232,21 @@ def list_databases():
     table.add_column("Port", style="yellow")
     table.add_column("Database", style="blue")
     table.add_column("Username", style="white")
+    table.add_column("SSL", style="bright_green")
     table.add_column("Default", style="bold red")
 
     for db in databases:
         is_default = "✓" if db.name == default_name else ""
+
+        # Format SSL status
+        ssl_status = ""
+        if db.ssl_mode:
+            ssl_status = db.ssl_mode
+            if db.ssl_ca or db.ssl_cert:
+                ssl_status += " (certs)"
+        else:
+            ssl_status = "disabled" if db.type != "sqlite" else "N/A"
+
         table.add_row(
             db.name,
             db.type,
@@ -168,6 +254,7 @@ def list_databases():
             str(db.port) if db.port else "",
             db.database,
             db.username,
+            ssl_status,
             is_default,
         )
 

sqlsaber/config/database.py

@@ -4,12 +4,12 @@ import json
 import os
 import platform
 import stat
-import keyring
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional
 from urllib.parse import quote_plus
 
+import keyring
 import platformdirs
 
 
@@ -18,13 +18,16 @@ class DatabaseConfig:
     """Database connection configuration."""
 
     name: str
-    type: str  # postgresql, mysql, sqlite
+    type: str  # postgresql, mysql, sqlite, csv
     host: Optional[str]
     port: Optional[int]
     database: str
     username: Optional[str]
     password: Optional[str] = None
     ssl_mode: Optional[str] = None
+    ssl_ca: Optional[str] = None
+    ssl_cert: Optional[str] = None
+    ssl_key: Optional[str] = None
     schema: Optional[str] = None
 
     def to_connection_string(self) -> str:
@@ -34,23 +37,81 @@ class DatabaseConfig:
         if self.type == "postgresql":
             if not all([self.host, self.port, self.username]):
                 raise ValueError("Host, port, and username are required for PostgreSQL")
+
+            # Build base connection string
             if password:
                 encoded_password = quote_plus(password)
-                return f"postgresql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
+                base_url = f"postgresql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
             else:
-                return f"postgresql://{self.username}@{self.host}:{self.port}/{self.database}"
+                base_url = f"postgresql://{self.username}@{self.host}:{self.port}/{self.database}"
+
+            # Add SSL parameters
+            ssl_params = []
+            if self.ssl_mode:
+                ssl_params.append(f"sslmode={self.ssl_mode}")
+            if self.ssl_ca:
+                ssl_params.append(f"sslrootcert={quote_plus(self.ssl_ca)}")
+            if self.ssl_cert:
+                ssl_params.append(f"sslcert={quote_plus(self.ssl_cert)}")
+            if self.ssl_key:
+                ssl_params.append(f"sslkey={quote_plus(self.ssl_key)}")
+
+            if ssl_params:
+                return f"{base_url}?{'&'.join(ssl_params)}"
+            return base_url
+
         elif self.type == "mysql":
             if not all([self.host, self.port, self.username]):
                 raise ValueError("Host, port, and username are required for MySQL")
+
+            # Build base connection string
             if password:
                 encoded_password = quote_plus(password)
-                return f"mysql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
+                base_url = f"mysql://{self.username}:{encoded_password}@{self.host}:{self.port}/{self.database}"
             else:
-                return (
+                base_url = (
                     f"mysql://{self.username}@{self.host}:{self.port}/{self.database}"
                 )
+
+            # Add SSL parameters
+            ssl_params = []
+            if self.ssl_mode:
+                ssl_params.append(f"ssl_mode={self.ssl_mode}")
+            if self.ssl_ca:
+                ssl_params.append(f"ssl_ca={quote_plus(self.ssl_ca)}")
+            if self.ssl_cert:
+                ssl_params.append(f"ssl_cert={quote_plus(self.ssl_cert)}")
+            if self.ssl_key:
+                ssl_params.append(f"ssl_key={quote_plus(self.ssl_key)}")
+
+            if ssl_params:
+                return f"{base_url}?{'&'.join(ssl_params)}"
+            return base_url
+
         elif self.type == "sqlite":
             return f"sqlite:///{self.database}"
+        elif self.type == "csv":
+            # For CSV files, database field contains the file path
+            base_url = f"csv:///{self.database}"
+
+            # Add CSV-specific parameters if they exist in schema field
+            if self.schema:
+                # Schema field can contain CSV options in JSON format
+                try:
+                    csv_options = json.loads(self.schema)
+                    params = []
+                    if "delimiter" in csv_options:
+                        params.append(f"delimiter={csv_options['delimiter']}")
+                    if "encoding" in csv_options:
+                        params.append(f"encoding={csv_options['encoding']}")
+                    if "header" in csv_options:
+                        params.append(f"header={str(csv_options['header']).lower()}")
+
+                    if params:
+                        return f"{base_url}?{'&'.join(params)}"
+                except (json.JSONDecodeError, KeyError):
+                    pass
+            return base_url
         else:
             raise ValueError(f"Unsupported database type: {self.type}")
 
@@ -82,6 +143,9 @@ class DatabaseConfig:
             "database": self.database,
             "username": self.username,
             "ssl_mode": self.ssl_mode,
+            "ssl_ca": self.ssl_ca,
+            "ssl_cert": self.ssl_cert,
+            "ssl_key": self.ssl_key,
             "schema": self.schema,
         }
 
@@ -96,6 +160,9 @@ class DatabaseConfig:
             database=data["database"],
             username=data["username"],
             ssl_mode=data.get("ssl_mode"),
+            ssl_ca=data.get("ssl_ca"),
+            ssl_cert=data.get("ssl_cert"),
+            ssl_key=data.get("ssl_key"),
             schema=data.get("schema"),
         )
 

sqlsaber/database/connection.py

@@ -2,11 +2,14 @@
 
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
-from urllib.parse import urlparse
+from urllib.parse import urlparse, parse_qs
+import ssl
+from pathlib import Path
 
 import aiomysql
 import aiosqlite
 import asyncpg
+import pandas as pd
 
 
 class BaseDatabaseConnection(ABC):
@@ -42,13 +45,65 @@ class PostgreSQLConnection(BaseDatabaseConnection):
     def __init__(self, connection_string: str):
         super().__init__(connection_string)
         self._pool: Optional[asyncpg.Pool] = None
+        self._ssl_context = self._create_ssl_context()
+
+    def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
+        """Create SSL context from connection string parameters."""
+        parsed = urlparse(self.connection_string)
+        if not parsed.query:
+            return None
+
+        params = parse_qs(parsed.query)
+        ssl_mode = params.get("sslmode", [None])[0]
+
+        if not ssl_mode or ssl_mode == "disable":
+            return None
+
+        # Create SSL context based on mode
+        if ssl_mode in ["require", "verify-ca", "verify-full"]:
+            ssl_context = ssl.create_default_context()
+
+            # Configure certificate verification
+            if ssl_mode == "require":
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            elif ssl_mode == "verify-ca":
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+            elif ssl_mode == "verify-full":
+                ssl_context.check_hostname = True
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+
+            # Load certificates if provided
+            ssl_ca = params.get("sslrootcert", [None])[0]
+            ssl_cert = params.get("sslcert", [None])[0]
+            ssl_key = params.get("sslkey", [None])[0]
+
+            if ssl_ca:
+                ssl_context.load_verify_locations(ssl_ca)
+
+            if ssl_cert and ssl_key:
+                ssl_context.load_cert_chain(ssl_cert, ssl_key)
+
+            return ssl_context
+
+        return None
 
     async def get_pool(self) -> asyncpg.Pool:
         """Get or create connection pool."""
         if self._pool is None:
-            self._pool = await asyncpg.create_pool(
-                self.connection_string, min_size=1, max_size=10
-            )
+            # Create pool with SSL context if configured
+            if self._ssl_context:
+                self._pool = await asyncpg.create_pool(
+                    self.connection_string,
+                    min_size=1,
+                    max_size=10,
+                    ssl=self._ssl_context,
+                )
+            else:
+                self._pool = await asyncpg.create_pool(
+                    self.connection_string, min_size=1, max_size=10
+                )
         return self._pool
 
     async def close(self):
@@ -94,19 +149,65 @@ class MySQLConnection(BaseDatabaseConnection):
         self.user = parsed.username or ""
         self.password = parsed.password or ""
 
+        # Parse SSL parameters
+        self.ssl_params = {}
+        if parsed.query:
+            params = parse_qs(parsed.query)
+
+            ssl_mode = params.get("ssl_mode", [None])[0]
+            if ssl_mode:
+                # Map SSL modes to aiomysql SSL parameters
+                if ssl_mode.upper() == "DISABLED":
+                    self.ssl_params["ssl"] = None
+                elif ssl_mode.upper() in [
+                    "PREFERRED",
+                    "REQUIRED",
+                    "VERIFY_CA",
+                    "VERIFY_IDENTITY",
+                ]:
+                    ssl_context = ssl.create_default_context()
+
+                    if ssl_mode.upper() == "REQUIRED":
+                        ssl_context.check_hostname = False
+                        ssl_context.verify_mode = ssl.CERT_NONE
+                    elif ssl_mode.upper() == "VERIFY_CA":
+                        ssl_context.check_hostname = False
+                        ssl_context.verify_mode = ssl.CERT_REQUIRED
+                    elif ssl_mode.upper() == "VERIFY_IDENTITY":
+                        ssl_context.check_hostname = True
+                        ssl_context.verify_mode = ssl.CERT_REQUIRED
+
+                    # Load certificates if provided
+                    ssl_ca = params.get("ssl_ca", [None])[0]
+                    ssl_cert = params.get("ssl_cert", [None])[0]
+                    ssl_key = params.get("ssl_key", [None])[0]
+
+                    if ssl_ca:
+                        ssl_context.load_verify_locations(ssl_ca)
+
+                    if ssl_cert and ssl_key:
+                        ssl_context.load_cert_chain(ssl_cert, ssl_key)
+
+                    self.ssl_params["ssl"] = ssl_context
+
     async def get_pool(self) -> aiomysql.Pool:
         """Get or create connection pool."""
         if self._pool is None:
-            self._pool = await aiomysql.create_pool(
-                host=self.host,
-                port=self.port,
-                user=self.user,
-                password=self.password,
-                db=self.database,
-                minsize=1,
-                maxsize=10,
-                autocommit=False,
-            )
+            pool_kwargs = {
+                "host": self.host,
+                "port": self.port,
+                "user": self.user,
+                "password": self.password,
+                "db": self.database,
+                "minsize": 1,
+                "maxsize": 10,
+                "autocommit": False,
+            }
+
+            # Add SSL parameters if configured
+            pool_kwargs.update(self.ssl_params)
+
+            self._pool = await aiomysql.create_pool(**pool_kwargs)
         return self._pool
 
     async def close(self):
@@ -173,6 +274,131 @@ class SQLiteConnection(BaseDatabaseConnection):
                 await conn.rollback()
 
 
+class CSVConnection(BaseDatabaseConnection):
+    """CSV file connection using in-memory SQLite database."""
+
+    def __init__(self, connection_string: str):
+        super().__init__(connection_string)
+
+        # Parse CSV file path from connection string
+        self.csv_path = connection_string.replace("csv:///", "")
+
+        # 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.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
+
+    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
+
+    async def close(self):
+        """Close the database connection."""
+        if self._conn:
+            await self._conn.close()
+            self._conn = None
+            self._csv_loaded = False
+
+    async def _load_csv_data(self):
+        """Load CSV data into the in-memory SQLite database."""
+        if self._csv_loaded or not self._conn:
+            return
+
+        try:
+            # 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,
+            )
+
+            # 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}')
+
+            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)
+
+                await self._conn.execute(insert_sql, values)
+
+            await self._conn.commit()
+            self._csv_loaded = True
+
+        except Exception as e:
+            raise ValueError(f"Error loading CSV file '{self.csv_path}': {str(e)}")
+
+    async def execute_query(self, query: str, *args) -> List[Dict[str, Any]]:
+        """Execute a query and return results as list of dicts.
+
+        All queries run in a transaction that is rolled back at the end,
+        ensuring no changes are persisted to the database.
+        """
+        conn = await self.get_pool()
+
+        # Start transaction
+        await conn.execute("BEGIN")
+        try:
+            cursor = await conn.execute(query, args if args else ())
+            rows = await cursor.fetchall()
+            return [dict(row) for row in rows]
+        finally:
+            # Always rollback to ensure no changes are committed
+            await conn.rollback()
+
+
 def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
     """Factory function to create appropriate database connection based on connection string."""
     if connection_string.startswith("postgresql://"):
@@ -181,6 +407,8 @@ def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
         return MySQLConnection(connection_string)
     elif connection_string.startswith("sqlite:///"):
         return SQLiteConnection(connection_string)
+    elif connection_string.startswith("csv:///"):
+        return CSVConnection(connection_string)
     else:
         raise ValueError(
             f"Unsupported database type in connection string: {connection_string}"

sqlsaber/database/schema.py

@@ -8,6 +8,7 @@ import aiosqlite
 
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
+    CSVConnection,
     MySQLConnection,
     PostgreSQLConnection,
     SQLiteConnection,
@@ -375,15 +376,30 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
 class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
     """SQLite-specific schema introspection."""
 
+    async def _execute_query(self, connection, query: str, params=()) -> list:
+        """Helper method to execute queries on both SQLite and CSV connections."""
+        # Handle both SQLite and CSV connections
+        if hasattr(connection, "database_path"):
+            # Regular SQLite connection
+            async with aiosqlite.connect(connection.database_path) as conn:
+                conn.row_factory = aiosqlite.Row
+                cursor = await conn.execute(query, params)
+                return await cursor.fetchall()
+        else:
+            # CSV connection - use the existing connection
+            conn = await connection.get_pool()
+            cursor = await conn.execute(query, params)
+            return await cursor.fetchall()
+
     async def get_tables_info(
         self, connection, table_pattern: Optional[str] = None
     ) -> Dict[str, Any]:
         """Get tables information for SQLite."""
-        where_clause = ""
+        where_conditions = ["type IN ('table', 'view')", "name NOT LIKE 'sqlite_%'"]
         params = ()
 
         if table_pattern:
-            where_clause = "WHERE name LIKE ?"
+            where_conditions.append("name LIKE ?")
             params = (table_pattern,)
 
         query = f"""
@@ -392,16 +408,11 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
                 name as table_name,
                 type as table_type
             FROM sqlite_master
-            WHERE type IN ('table', 'view')
-            AND name NOT LIKE 'sqlite_%'
-            {where_clause}
+            WHERE {" AND ".join(where_conditions)}
             ORDER BY name;
         """
 
-        async with aiosqlite.connect(connection.database_path) as conn:
-            conn.row_factory = aiosqlite.Row
-            cursor = await conn.execute(query, params)
-            return await cursor.fetchall()
+        return await self._execute_query(connection, query, params)
 
     async def get_columns_info(self, connection, tables: list) -> list:
         """Get columns information for SQLite."""
@@ -414,26 +425,22 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
             # Get table info using PRAGMA
             pragma_query = f"PRAGMA table_info({table_name})"
+            table_columns = await self._execute_query(connection, pragma_query)
 
-            async with aiosqlite.connect(connection.database_path) as conn:
-                conn.row_factory = aiosqlite.Row
-                cursor = await conn.execute(pragma_query)
-                table_columns = await cursor.fetchall()
-
-                for col in table_columns:
-                    columns.append(
-                        {
-                            "table_schema": "main",
-                            "table_name": table_name,
-                            "column_name": col["name"],
-                            "data_type": col["type"],
-                            "is_nullable": "YES" if not col["notnull"] else "NO",
-                            "column_default": col["dflt_value"],
-                            "character_maximum_length": None,
-                            "numeric_precision": None,
-                            "numeric_scale": None,
-                        }
-                    )
+            for col in table_columns:
+                columns.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "column_name": col["name"],
+                        "data_type": col["type"],
+                        "is_nullable": "YES" if not col["notnull"] else "NO",
+                        "column_default": col["dflt_value"],
+                        "character_maximum_length": None,
+                        "numeric_precision": None,
+                        "numeric_scale": None,
+                    }
+                )
 
         return columns
 
@@ -448,23 +455,19 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
             # Get foreign key info using PRAGMA
             pragma_query = f"PRAGMA foreign_key_list({table_name})"
+            table_fks = await self._execute_query(connection, pragma_query)
 
-            async with aiosqlite.connect(connection.database_path) as conn:
-                conn.row_factory = aiosqlite.Row
-                cursor = await conn.execute(pragma_query)
-                table_fks = await cursor.fetchall()
-
-                for fk in table_fks:
-                    foreign_keys.append(
-                        {
-                            "table_schema": "main",
-                            "table_name": table_name,
-                            "column_name": fk["from"],
-                            "foreign_table_schema": "main",
-                            "foreign_table_name": fk["table"],
-                            "foreign_column_name": fk["to"],
-                        }
-                    )
+            for fk in table_fks:
+                foreign_keys.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "column_name": fk["from"],
+                        "foreign_table_schema": "main",
+                        "foreign_table_name": fk["table"],
+                        "foreign_column_name": fk["to"],
+                    }
+                )
 
         return foreign_keys
 
@@ -479,43 +482,64 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
             # Get table info using PRAGMA to find primary keys
             pragma_query = f"PRAGMA table_info({table_name})"
+            table_columns = await self._execute_query(connection, pragma_query)
 
-            async with aiosqlite.connect(connection.database_path) as conn:
-                conn.row_factory = aiosqlite.Row
-                cursor = await conn.execute(pragma_query)
-                table_columns = await cursor.fetchall()
-
-                for col in table_columns:
-                    if col["pk"]:  # Primary key indicator
-                        primary_keys.append(
-                            {
-                                "table_schema": "main",
-                                "table_name": table_name,
-                                "column_name": col["name"],
-                            }
-                        )
+            for col in table_columns:
+                if col["pk"]:  # Primary key indicator
+                    primary_keys.append(
+                        {
+                            "table_schema": "main",
+                            "table_name": table_name,
+                            "column_name": col["name"],
+                        }
+                    )
 
         return primary_keys
 
     async def list_tables_info(self, connection) -> Dict[str, Any]:
         """Get list of tables with basic information for SQLite."""
-        # Get tables (SQLite doesn't have easy row count access)
+        # First get the table names
         tables_query = """
             SELECT
                 'main' as table_schema,
                 name as table_name,
-                type as table_type,
-                0 as row_count
+                type as table_type
             FROM sqlite_master
             WHERE type IN ('table', 'view')
             AND name NOT LIKE 'sqlite_%'
             ORDER BY name;
         """
 
-        async with aiosqlite.connect(connection.database_path) as conn:
-            conn.row_factory = aiosqlite.Row
-            cursor = await conn.execute(tables_query)
-            return await cursor.fetchall()
+        tables = await self._execute_query(connection, tables_query)
+
+        # Now get row counts for each table
+        result = []
+        for table in tables:
+            table_name = table["table_name"]
+            table_type = table["table_type"]
+
+            # Only count rows for tables, not views
+            if table_type.lower() == "table":
+                try:
+                    count_query = f"SELECT COUNT(*) as count FROM [{table_name}]"
+                    count_result = await self._execute_query(connection, count_query)
+                    row_count = count_result[0]["count"] if count_result else 0
+                except Exception:
+                    # If count fails (e.g., table locked), default to 0
+                    row_count = 0
+            else:
+                # For views, we don't count rows as it could be expensive
+                row_count = 0
+
+            result.append(
+                {
+                    "table_schema": table["table_schema"],
+                    "table_name": table_name,
+                    "table_type": table_type,
+                    "row_count": row_count,
+                }
+            )
+        return result
 
 
 class SchemaManager:
@@ -531,7 +555,7 @@ class SchemaManager:
             self.introspector = PostgreSQLSchemaIntrospector()
         elif isinstance(db_connection, MySQLConnection):
             self.introspector = MySQLSchemaIntrospector()
-        elif isinstance(db_connection, SQLiteConnection):
+        elif isinstance(db_connection, (SQLiteConnection, CSVConnection)):
             self.introspector = SQLiteSchemaIntrospector()
         else:
             raise ValueError(

{sqlsaber-0.1.0.dist-info → sqlsaber-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.1.0
+Version: 0.3.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -10,6 +10,7 @@ Requires-Dist: anthropic>=0.54.0
 Requires-Dist: asyncpg>=0.30.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: questionary>=2.1.0
 Requires-Dist: rich>=13.7.0

{sqlsaber-0.1.0.dist-info → sqlsaber-0.3.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 sqlsaber/__init__.py,sha256=QCFi8xTVMohelfi7zOV1-6oLCcGoiXoOcKQY-HNBCk8,66
 sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
 sqlsaber/agents/__init__.py,sha256=LWeSeEUE4BhkyAYFF3TE-fx8TtLud3oyEtyB8ojFJgo,167
-sqlsaber/agents/anthropic.py,sha256=CPNshN68QxxdIvWS5YjEuiXd_8V8mmMTL9aC2Mqkvts,17863
-sqlsaber/agents/base.py,sha256=UUSGhoJImATXrYS7yrLR2qjg1iFW4udOUdRaV3Ryk5s,2086
-sqlsaber/agents/streaming.py,sha256=0bNzd_JhLlgQB40pf9FZFMvmU9Q7W6D9BmglA1rIGqw,850
+sqlsaber/agents/anthropic.py,sha256=xAjKeQSnaut-P5VBeBISbQeqdP41epDjX6MJb2ZUXWg,14060
+sqlsaber/agents/base.py,sha256=IuVyCaA7VsA92odfQS2_lYNzwIZwPxK55mL_xRewgwQ,6943
+sqlsaber/agents/streaming.py,sha256=_EO390-FHUrL1fRCNfibtE9QuJz3LGQygbwG3CB2ViY,533
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
-sqlsaber/cli/commands.py,sha256=Adrt_0LRgykb2FZ4F0TQpuBM8Z0qgfbggn0FexcVALI,4094
-sqlsaber/cli/database.py,sha256=W-tJqmihKjZhoe5AGpQKe0txzLIgRVGikZHM_ELAbnQ,9138
+sqlsaber/cli/commands.py,sha256=h418lgh_Xp7XEQ1xvjcDyplC2JON0-y98QMaDm6o29k,4919
+sqlsaber/cli/database.py,sha256=DUfyvNBDp47oFM_VAC_hXHQy_qyE7JbXtowflJpwwH8,12643
 sqlsaber/cli/display.py,sha256=5J4AgJADmMwKi9Aq5u6_MKRO1TA6unS4F4RUfml_sfU,7651
 sqlsaber/cli/interactive.py,sha256=y92rdoM49SOSwEctm9ZcrEN220fhJ_DMHPSd_7KsORg,3701
 sqlsaber/cli/memory.py,sha256=LW4ZF2V6Gw6hviUFGZ4ym9ostFCwucgBTIMZ3EANO-I,7671
@@ -14,19 +14,19 @@ sqlsaber/cli/models.py,sha256=3IcXeeU15IQvemSv-V-RQzVytJ3wuQ4YmWk89nTDcSE,7813
 sqlsaber/cli/streaming.py,sha256=5QGAYTAvg9mzQLxDEVtdDH-TIbGfYYzMOLoOYPrHPu0,3788
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=kLdoExF_My9ojmdhO5Ca7-ZeowsO0v1GVa_QT5jjUPo,3658
-sqlsaber/config/database.py,sha256=FX4zwmOkW-lvIH--c8xRyoyyjYLjn3OQTkSruEw-aQY,8790
+sqlsaber/config/database.py,sha256=vKFOxPjVakjQhj1uoLcfzhS9ZFr6Z2F5b4MmYALQZoA,11421
 sqlsaber/config/settings.py,sha256=zjQ7nS3ybcCb88Ea0tmwJox5-q0ettChZw89ZqRVpX8,3975
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
-sqlsaber/database/connection.py,sha256=Z1iIRBIoPQcCfBliROLeebEQeI7ggu-hh_G1l-tzhIM,6672
-sqlsaber/database/schema.py,sha256=gURfCFVE--UWIqD_0StqS2NMB9VIPpqczBEoS2GnKR4,27025
+sqlsaber/database/connection.py,sha256=s8GSFZebB8be8sVUr-N0x88-20YfkfljJFRyfoB1gH0,15154
+sqlsaber/database/schema.py,sha256=S3uPSXcrU3swoOPPjbXSxo1_fZ8vV3ELuPoV2GRy1ZI,27953
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
 sqlsaber/memory/manager.py,sha256=ML2NEO5Z4Aw36sEI9eOvWVnjl-qT2VOTojViJAj7Seo,2777
 sqlsaber/memory/storage.py,sha256=DvZBsSPaAfk_DqrNEn86uMD-TQsWUI6rQLfNw6PSCB8,5788
 sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
 sqlsaber/models/events.py,sha256=55m41tDwMsFxnKKA5_VLJz8iV-V4Sq3LDfta4VoutJI,737
 sqlsaber/models/types.py,sha256=3U_30n91EB3IglBTHipwiW4MqmmaA2qfshfraMZyPps,896
-sqlsaber-0.1.0.dist-info/METADATA,sha256=37Xik234wv415wWsvIWr4XFjzHiQV39EnDAYyZsMgXA,3953
-sqlsaber-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.1.0.dist-info/entry_points.txt,sha256=POwcsEskUp7xQQWabrAi6Eawz4qc5eBlB3KzAiBq-Y0,124
-sqlsaber-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.1.0.dist-info/RECORD,,
+sqlsaber-0.3.0.dist-info/METADATA,sha256=YKw06cBqX0bNZK98kJfYAES_c8VPXOhvOtIKONt1xFk,3982
+sqlsaber-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.3.0.dist-info/entry_points.txt,sha256=POwcsEskUp7xQQWabrAi6Eawz4qc5eBlB3KzAiBq-Y0,124
+sqlsaber-0.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.3.0.dist-info/RECORD,,