thoth-dbmanager 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

thoth_dbmanager/plugins/postgresql.py

@@ -0,0 +1,145 @@
+"""
+PostgreSQL plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.postgresql import PostgreSQLAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("postgresql")
+class PostgreSQLPlugin(DbPlugin):
+    """
+    PostgreSQL database plugin implementation.
+    """
+    
+    plugin_name = "PostgreSQL Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["postgresql", "postgres"]
+    required_dependencies = ["psycopg2-binary", "SQLAlchemy"]
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+        
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+    
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a PostgreSQL adapter instance"""
+        return PostgreSQLAdapter(kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for PostgreSQL"""
+        required_params = ['host', 'port', 'database', 'user', 'password']
+        
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter: {param}")
+                return False
+        
+        # Validate types
+        try:
+            port = int(kwargs['port'])
+            if port <= 0 or port > 65535:
+                logger.error(f"Invalid port number: {port}")
+                return False
+        except (ValueError, TypeError):
+            logger.error(f"Port must be a valid integer: {kwargs.get('port')}")
+            return False
+        
+        # Validate required string parameters are not empty
+        string_params = ['host', 'database', 'user', 'password']
+        for param in string_params:
+            if not kwargs.get(param) or not isinstance(kwargs[param], str):
+                logger.error(f"Parameter {param} must be a non-empty string")
+                return False
+        
+        return True
+    
+    def initialize(self, **kwargs) -> None:
+        """Initialize the PostgreSQL plugin"""
+        super().initialize(**kwargs)
+        
+        # Set up database directory path (for LSH and other features)
+        if 'database' in kwargs:
+            self.db_id = kwargs['database']
+            self._setup_directory_path(self.db_id)
+        
+        logger.info(f"PostgreSQL plugin initialized for database: {self.db_id}")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up the database directory path"""
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = Path(self.db_root_path) / f"{self.db_mode}_databases" / db_id
+        self.db_id = db_id
+        
+        # Reset LSH manager when directory path changes
+        self._lsh_manager = None
+    
+    @property
+    def lsh_manager(self):
+        """Lazy load LSH manager for backward compatibility"""
+        if self._lsh_manager is None and self.db_directory_path:
+            from ..lsh.manager import LshManager
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+    
+    # LSH integration methods for backward compatibility
+    def set_lsh(self) -> str:
+        """Set LSH for backward compatibility"""
+        try:
+            if self.lsh_manager and self.lsh_manager.load_lsh():
+                return "success"
+            else:
+                return "error"
+        except Exception as e:
+            logger.error(f"Error loading LSH: {e}")
+            return "error"
+    
+    def query_lsh(self, keyword: str, signature_size: int = 30, n_gram: int = 3, top_n: int = 10) -> Dict[str, Dict[str, List[str]]]:
+        """Query LSH for backward compatibility"""
+        if self.lsh_manager:
+            try:
+                return self.lsh_manager.query(
+                    keyword=keyword,
+                    signature_size=signature_size,
+                    n_gram=n_gram,
+                    top_n=top_n
+                )
+            except Exception as e:
+                logger.error(f"LSH query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH not available for {self.db_id}")
+    
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+        
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+        
+        base_info.update({
+            "db_id": self.db_id,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+        
+        return base_info
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")

thoth_dbmanager/plugins/qdrant.py

@@ -0,0 +1,41 @@
+"""
+Qdrant plugin for Thoth SQL Database Manager.
+"""
+
+from typing import List
+from ..core.interfaces import DbPlugin
+from ..adapters.qdrant import QdrantAdapter
+
+
+class QdrantPlugin(DbPlugin):
+    """Plugin for Qdrant vector database."""
+    
+    plugin_name = "qdrant"
+    plugin_version = "1.0.0"
+    supported_db_types = ["qdrant"]
+    required_dependencies = ["qdrant-client"]
+    
+    def create_adapter(self, **kwargs) -> QdrantAdapter:
+        """Create and return a QdrantAdapter instance."""
+        return QdrantAdapter(**kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate Qdrant connection parameters."""
+        required_params = ['host']
+        
+        for param in required_params:
+            if param not in kwargs:
+                return False
+        
+        # Validate host format
+        host = kwargs.get('host')
+        if not isinstance(host, str) or not host.strip():
+            return False
+        
+        # Validate port if provided
+        port = kwargs.get('port')
+        if port is not None:
+            if not isinstance(port, int) or port <= 0 or port > 65535:
+                return False
+        
+        return True

thoth_dbmanager/plugins/sqlite.py

@@ -0,0 +1,170 @@
+"""
+SQLite plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.sqlite import SQLiteAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("sqlite")
+class SQLitePlugin(DbPlugin):
+    """
+    SQLite database plugin implementation.
+    """
+    
+    plugin_name = "SQLite Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["sqlite", "sqlite3"]
+    required_dependencies = ["SQLAlchemy"]
+    
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+        self.database_path = None
+        
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+    
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a SQLite adapter instance"""
+        return SQLiteAdapter(kwargs)
+    
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for SQLite"""
+        # For SQLite, we need either database_path or database_name
+        database_path = kwargs.get('database_path')
+        database_name = kwargs.get('database_name')
+        
+        if not database_path and not database_name:
+            logger.error("Either 'database_path' or 'database_name' is required for SQLite")
+            return False
+        
+        if database_path:
+            # Validate that the path is a string
+            if not isinstance(database_path, str):
+                logger.error("database_path must be a string")
+                return False
+            
+            # Check if parent directory exists or can be created
+            try:
+                db_path = Path(database_path)
+                db_path.parent.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                logger.error(f"Cannot create directory for database path {database_path}: {e}")
+                return False
+        
+        if database_name:
+            if not isinstance(database_name, str) or not database_name.strip():
+                logger.error("database_name must be a non-empty string")
+                return False
+        
+        return True
+    
+    def initialize(self, **kwargs) -> None:
+        """Initialize the SQLite plugin"""
+        # Handle database path resolution
+        database_path = kwargs.get('database_path')
+        database_name = kwargs.get('database_name')
+        
+        if not database_path and database_name:
+            # Create database path from name and root path
+            db_root = Path(self.db_root_path)
+            db_dir = db_root / f"{self.db_mode}_databases" / database_name
+            db_dir.mkdir(parents=True, exist_ok=True)
+            database_path = str(db_dir / f"{database_name}.db")
+            kwargs['database_path'] = database_path
+        
+        # Set database path for adapter
+        self.database_path = database_path
+        
+        # Initialize with updated kwargs
+        super().initialize(**kwargs)
+        
+        # Set up database directory path and ID
+        if database_name:
+            self.db_id = database_name
+        else:
+            # Extract database name from path
+            self.db_id = Path(database_path).stem
+        
+        self._setup_directory_path(self.db_id)
+        
+        logger.info(f"SQLite plugin initialized for database: {self.db_id} at {self.database_path}")
+    
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up the database directory path"""
+        if isinstance(self.db_root_path, str):
+            self.db_root_path = Path(self.db_root_path)
+        
+        self.db_directory_path = Path(self.db_root_path) / f"{self.db_mode}_databases" / db_id
+        self.db_id = db_id
+        
+        # Reset LSH manager when directory path changes
+        self._lsh_manager = None
+    
+    @property
+    def lsh_manager(self):
+        """Lazy load LSH manager for backward compatibility"""
+        if self._lsh_manager is None and self.db_directory_path:
+            from ..lsh.manager import LshManager
+            self._lsh_manager = LshManager(self.db_directory_path)
+        return self._lsh_manager
+    
+    # LSH integration methods for backward compatibility
+    def set_lsh(self) -> str:
+        """Set LSH for backward compatibility"""
+        try:
+            if self.lsh_manager and self.lsh_manager.load_lsh():
+                return "success"
+            else:
+                return "error"
+        except Exception as e:
+            logger.error(f"Error loading LSH: {e}")
+            return "error"
+    
+    def query_lsh(self, keyword: str, signature_size: int = 30, n_gram: int = 3, top_n: int = 10) -> Dict[str, Dict[str, List[str]]]:
+        """Query LSH for backward compatibility"""
+        if self.lsh_manager:
+            try:
+                return self.lsh_manager.query(
+                    keyword=keyword,
+                    signature_size=signature_size,
+                    n_gram=n_gram,
+                    top_n=top_n
+                )
+            except Exception as e:
+                logger.error(f"LSH query failed: {e}")
+                raise Exception(f"Error querying LSH for {self.db_id}: {e}")
+        else:
+            raise Exception(f"LSH not available for {self.db_id}")
+    
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+        
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+        
+        base_info.update({
+            "db_id": self.db_id,
+            "database_path": self.database_path,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+        
+        return base_info
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")

thoth_dbmanager/plugins/sqlserver.py

@@ -0,0 +1,149 @@
+"""
+SQL Server plugin implementation.
+"""
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..core.interfaces import DbPlugin, DbAdapter
+from ..core.registry import register_plugin
+from ..adapters.sqlserver import SQLServerAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@register_plugin("sqlserver")
+class SQLServerPlugin(DbPlugin):
+    """
+    SQL Server database plugin implementation.
+    """
+
+    plugin_name = "SQL Server Plugin"
+    plugin_version = "1.0.0"
+    supported_db_types = ["sqlserver", "mssql"]
+    required_dependencies = ["pyodbc", "SQLAlchemy"]
+
+    def __init__(self, db_root_path: str, db_mode: str = "dev", **kwargs):
+        super().__init__(db_root_path, db_mode, **kwargs)
+        self.db_id = None
+        self.db_directory_path = None
+
+        # LSH manager integration (for backward compatibility)
+        self._lsh_manager = None
+
+    def create_adapter(self, **kwargs) -> DbAdapter:
+        """Create and return a SQL Server adapter instance"""
+        return SQLServerAdapter(kwargs)
+
+    def validate_connection_params(self, **kwargs) -> bool:
+        """Validate connection parameters for SQL Server"""
+        required_params = ['host', 'port', 'database', 'user', 'password']
+
+        for param in required_params:
+            if param not in kwargs:
+                logger.error(f"Missing required parameter: {param}")
+                return False
+
+        # Validate types
+        try:
+            port = int(kwargs['port'])
+            if port <= 0 or port > 65535:
+                logger.error(f"Invalid port number: {port}")
+                return False
+        except (ValueError, TypeError):
+            logger.error(f"Port must be a valid integer: {kwargs.get('port')}")
+            return False
+
+        # Validate required string parameters are not empty
+        string_params = ['host', 'database', 'user', 'password']
+        for param in string_params:
+            if not kwargs.get(param) or not isinstance(kwargs[param], str):
+                logger.error(f"Parameter {param} must be a non-empty string")
+                return False
+
+        return True
+
+    def initialize(self, **kwargs) -> None:
+        """Initialize the SQL Server plugin"""
+        super().initialize(**kwargs)
+
+        # Set up database directory path (for LSH and other features)
+        if 'database' in kwargs:
+            self.db_id = kwargs['database']
+            self._setup_directory_path(self.db_id)
+
+        logger.info(f"SQL Server plugin initialized for database: {self.db_id}")
+
+    def _setup_directory_path(self, db_id: str) -> None:
+        """Set up directory path for database-specific files"""
+        if self.db_root_path:
+            self.db_directory_path = Path(self.db_root_path) / "sqlserver" / db_id
+            self.db_directory_path.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def lsh_manager(self):
+        """Get LSH manager (for backward compatibility)"""
+        return self._lsh_manager
+
+    def get_connection_info(self) -> Dict[str, Any]:
+        """Get connection information"""
+        base_info = super().get_plugin_info()
+
+        if self.adapter:
+            adapter_info = self.adapter.get_connection_info()
+            base_info.update(adapter_info)
+
+        base_info.update({
+            "db_id": self.db_id,
+            "db_directory_path": str(self.db_directory_path) if self.db_directory_path else None,
+            "lsh_available": self.lsh_manager is not None
+        })
+
+        return base_info
+
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data through adapter"""
+        if self.adapter:
+            return self.adapter.get_example_data(table_name, number_of_rows)
+        else:
+            raise RuntimeError("Plugin not initialized")
+    
+    def validate_connection_string(self, connection_string: str) -> bool:
+        """Validate SQL Server connection string format."""
+        return "mssql+pyodbc://" in connection_string
+    
+    def get_database_info(self) -> Dict[str, Any]:
+        """Get SQL Server database information."""
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "version": self.version,
+            "features": [
+                "transactions",
+                "foreign_keys",
+                "indexes",
+                "views",
+                "stored_procedures",
+                "triggers",
+                "computed_columns",
+                "partitioning"
+            ],
+            "data_types": [
+                "INT", "BIGINT", "DECIMAL", "NUMERIC", "FLOAT", "REAL",
+                "VARCHAR", "NVARCHAR", "TEXT", "NTEXT", "BINARY", "VARBINARY",
+                "DATE", "TIME", "DATETIME", "DATETIME2", "SMALLDATETIME",
+                "BIT", "UNIQUEIDENTIFIER", "XML"
+            ]
+        }
+    
+    def get_sample_connection_config(self) -> Dict[str, Any]:
+        """Get sample connection configuration."""
+        return {
+            "host": "localhost",
+            "port": 1433,
+            "database": "mydatabase",
+            "username": "user",
+            "password": "password",
+            "driver": "ODBC Driver 17 for SQL Server"
+        }