thoth-dbmanager 0.4.13__py3-none-any.whl → 0.5.1__py3-none-any.whl

thoth_dbmanager/adapters/supabase.py

@@ -1,249 +0,0 @@
-"""
-Supabase adapter implementation.
-"""
-import logging
-from typing import Any, Dict, List, Optional, Union
-import psycopg2
-from psycopg2.extras import RealDictCursor
-from sqlalchemy import create_engine, text
-from sqlalchemy.exc import SQLAlchemyError
-from urllib.parse import urlparse, parse_qs
-
-from .postgresql import PostgreSQLAdapter
-from ..core.interfaces import DbAdapter
-from ..documents import (
-    TableDocument,
-    ColumnDocument,
-    SchemaDocument,
-    ForeignKeyDocument,
-    IndexDocument
-)
-
-logger = logging.getLogger(__name__)
-
-
-class SupabaseAdapter(PostgreSQLAdapter):
-    """
-    Supabase database adapter implementation.
-    Extends PostgreSQL adapter with Supabase-specific features.
-    """
-    
-    def __init__(self, connection_params: Dict[str, Any]):
-        super().__init__(connection_params)
-        self.supabase_url = None
-        self.api_key = None
-        self.use_rest_api = False
-        
-    def connect(self) -> None:
-        """Establish Supabase connection with SSL enforcement"""
-        try:
-            # Check if we should use REST API or direct database connection
-            self.use_rest_api = self.connection_params.get('use_rest_api', False)
-            
-            if self.use_rest_api:
-                # REST API connection setup
-                self.supabase_url = self.connection_params.get('project_url')
-                self.api_key = self.connection_params.get('api_key')
-                
-                if not self.supabase_url or not self.api_key:
-                    raise ValueError("project_url and api_key are required for REST API mode")
-                
-                logger.info("Supabase REST API connection established")
-            else:
-                # Direct database connection (PostgreSQL with SSL)
-                super().connect()
-                
-                # Ensure SSL is enabled for Supabase
-                if hasattr(self, 'engine') and self.engine:
-                    # Update connection string to enforce SSL
-                    connection_string = self._build_connection_string()
-                    if 'sslmode=' not in connection_string:
-                        connection_string += '?sslmode=require'
-                    
-                    self.engine = create_engine(connection_string, echo=False)
-                    
-                    # Test connection
-                    with self.engine.connect() as conn:
-                        conn.execute(text("SELECT 1"))
-                
-                logger.info("Supabase database connection established with SSL")
-                
-        except Exception as e:
-            logger.error(f"Failed to connect to Supabase: {e}")
-            raise
-    
-    def _build_connection_string(self) -> str:
-        """Build SQLAlchemy connection string with Supabase-specific parameters"""
-        params = self.connection_params
-        
-        if self.use_rest_api:
-            return params.get('project_url')
-        
-        # Direct database connection
-        host = params.get('host')
-        port = params.get('port', 5432)
-        database = params.get('database')
-        user = params.get('user')
-        password = params.get('password')
-        
-        if not all([host, database, user, password]):
-            raise ValueError("Missing required connection parameters: host, database, user, password")
-        
-        # Ensure SSL mode for Supabase
-        ssl_mode = params.get('sslmode', 'require')
-        
-        connection_string = f"postgresql://{user}:{password}@{host}:{port}/{database}?sslmode={ssl_mode}"
-        
-        # Add additional SSL parameters if provided
-        if params.get('sslcert'):
-            connection_string += f"&sslcert={params['sslcert']}"
-        if params.get('sslkey'):
-            connection_string += f"&sslkey={params['sslkey']}"
-        if params.get('sslrootcert'):
-            connection_string += f"&sslrootcert={params['sslrootcert']}"
-            
-        return connection_string
-    
-    def _get_psycopg2_params(self) -> Dict[str, Any]:
-        """Get parameters for psycopg2 connection with SSL"""
-        params = super()._get_psycopg2_params()
-        
-        # Ensure SSL is enabled for Supabase
-        params['sslmode'] = self.connection_params.get('sslmode', 'require')
-        
-        # Add SSL certificates if provided
-        if self.connection_params.get('sslcert'):
-            params['sslcert'] = self.connection_params['sslcert']
-        if self.connection_params.get('sslkey'):
-            params['sslkey'] = self.connection_params['sslkey']
-        if self.connection_params.get('sslrootcert'):
-            params['sslrootcert'] = self.connection_params['sslrootcert']
-            
-        return params
-    
-    def execute_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """Execute SQL queries with Supabase-specific optimizations"""
-        if self.use_rest_api:
-            return self._execute_rest_query(query, params, fetch, timeout)
-        else:
-            return super().execute_query(query, params, fetch, timeout)
-    
-    def _execute_rest_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """Execute query using Supabase REST API"""
-        try:
-            from supabase import create_client
-            from postgrest.exceptions import APIError
-            
-            # Create Supabase client
-            supabase = create_client(self.supabase_url, self.api_key)
-            
-            # For REST API, we need to convert SQL to Postgrest queries
-            # This is a simplified implementation - in practice, you'd need a SQL parser
-            if query.strip().upper().startswith('SELECT'):
-                # Extract table name and conditions from query
-                table_name = self._extract_table_name(query)
-                
-                # Build Postgrest query
-                result = supabase.table(table_name).select('*').execute()
-                
-                if fetch == "all":
-                    return result.data
-                elif fetch == "one":
-                    return result.data[0] if result.data else None
-                elif isinstance(fetch, int):
-                    return result.data[:fetch]
-                else:
-                    return result.data
-            else:
-                # For non-SELECT queries, use RPC
-                result = supabase.rpc('execute_sql', {'sql': query}).execute()
-                return result.data
-                
-        except ImportError:
-            raise RuntimeError("supabase-py package is required for REST API mode")
-        except APIError as e:
-            logger.error(f"Supabase REST API error: {e}")
-            raise
-    
-    def _extract_table_name(self, query: str) -> str:
-        """Extract table name from SQL query (simplified)"""
-        # This is a basic implementation - in practice, you'd use a proper SQL parser
-        query = query.upper()
-        from_index = query.find('FROM')
-        if from_index != -1:
-            after_from = query[from_index + 4:].strip()
-            # Find first space or end of string
-            space_index = after_from.find(' ')
-            if space_index != -1:
-                return after_from[:space_index].lower()
-            else:
-                return after_from.lower()
-        return "unknown"
-    
-    def get_tables_as_documents(self) -> List[TableDocument]:
-        """Get tables with Supabase schema considerations"""
-        tables = super().get_tables_as_documents()
-        
-        # Filter out Supabase system schemas
-        filtered_tables = []
-        for table in tables:
-            if table.schema_name not in ['auth', 'storage', 'realtime', 'supabase_functions']:
-                filtered_tables.append(table)
-        
-        return filtered_tables
-    
-    def get_columns_as_documents(self, table_name: str) -> List[ColumnDocument]:
-        """Get columns with Supabase-specific handling"""
-        columns = super().get_columns_as_documents(table_name)
-        
-        # Add Supabase-specific metadata
-        for column in columns:
-            if column.column_name in ['created_at', 'updated_at']:
-                column.comment = f"{column.comment} (Supabase auto-timestamp)"
-            elif column.column_name == 'id':
-                column.comment = f"{column.comment} (Supabase auto-increment)"
-        
-        return columns
-    
-    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
-        """Get unique values with Supabase schema filtering"""
-        result = super().get_unique_values()
-        
-        # Filter out Supabase system tables
-        filtered_result = {}
-        for table_name, columns in result.items():
-            if not table_name.startswith('auth_') and not table_name.startswith('storage_'):
-                filtered_result[table_name] = columns
-        
-        return filtered_result
-    
-    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
-        """Get example data with Supabase-specific handling"""
-        if self.use_rest_api:
-            return self._get_example_data_rest(table_name, number_of_rows)
-        else:
-            return super().get_example_data(table_name, number_of_rows)
-    
-    def _get_example_data_rest(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
-        """Get example data using REST API"""
-        try:
-            from supabase import create_client
-            
-            supabase = create_client(self.supabase_url, self.api_key)
-            
-            # Get data from REST API
-            result = supabase.table(table_name).select('*').limit(number_of_rows).execute()
-            
-            # Convert to the expected format
-            example_data = {}
-            if result.data:
-                for key in result.data[0].keys():
-                    example_data[key] = [row.get(key) for row in result.data]
-            
-            return example_data
-            
-        except ImportError:
-            raise RuntimeError("supabase-py package is required for REST API mode")
-        except Exception as e:
-            logger.error(f"Error getting example data via REST API: {e}")
-            return {}

thoth_dbmanager/plugins/mysql.py

@@ -1,408 +0,0 @@
-"""
-MySQL plugin for Thoth SQL Database Manager.
-Unified implementation combining plugin architecture with full database functionality.
-"""
-
-import logging
-import os
-from pathlib import Path
-from threading import Lock
-from typing import Any, Dict, List, Optional, Union
-
-from sqlalchemy import create_engine, inspect, text
-from sqlalchemy.exc import SQLAlchemyError
-
-from ..core.interfaces import DbPlugin, DbAdapter
-from ..core.registry import register_plugin
-from ..documents import TableDocument, ColumnDocument, ForeignKeyDocument, SchemaDocument, IndexDocument
-
-logger = logging.getLogger(__name__)
-
-
-class MySQLAdapter(DbAdapter):
-    """MySQL database adapter with full functionality."""
-    
-    def __init__(self, connection_params: Dict[str, Any]):
-        super().__init__(connection_params)
-        self.engine = None
-        self.host = connection_params.get('host')
-        self.port = connection_params.get('port', 3306)
-        self.dbname = connection_params.get('database') or connection_params.get('dbname')
-        self.user = connection_params.get('user') or connection_params.get('username')
-        self.password = connection_params.get('password')
-    
-    def connect(self) -> None:
-        """Establish database connection."""
-        try:
-            connection_string = f"mysql+mysqlconnector://{self.user}:{self.password}@{self.host}:{self.port}/{self.dbname}"
-            self.engine = create_engine(connection_string, pool_pre_ping=True)
-            self.connection = self.engine
-            self._initialized = True
-        except Exception as e:
-            raise ConnectionError(f"Failed to connect to MySQL: {e}")
-    
-    def disconnect(self) -> None:
-        """Close database connection."""
-        if self.engine:
-            self.engine.dispose()
-            self.engine = None
-            self.connection = None
-    
-    def execute_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
-        """Execute a query and return results."""
-        if not self.engine:
-            self.connect()
-
-        with self.engine.connect() as connection:
-            try:
-                if params:
-                    result = connection.execute(text(query), params)
-                else:
-                    result = connection.execute(text(query))
-
-                # Check if this is a query that returns rows (SELECT, SHOW, etc.)
-                query_upper = query.strip().upper()
-                if query_upper.startswith(('SELECT', 'SHOW', 'DESCRIBE', 'DESC', 'EXPLAIN', 'WITH')):
-                    if fetch == "all":
-                        return [row._asdict() for row in result.fetchall()]
-                    elif fetch == "one":
-                        row = result.fetchone()
-                        return row._asdict() if row else None
-                    elif isinstance(fetch, int) and fetch > 0:
-                        return [row._asdict() for row in result.fetchmany(fetch)]
-                    else:
-                        return [row._asdict() for row in result.fetchall()]
-                else:
-                    # For DDL/DML queries (CREATE, INSERT, UPDATE, DELETE), return rowcount
-                    connection.commit()
-                    return result.rowcount
-            except SQLAlchemyError as e:
-                logger.error(f"Error executing SQL: {str(e)}")
-                raise e
-    
-    def get_tables_as_documents(self) -> List[TableDocument]:
-        """Return tables as document objects."""
-        inspector = inspect(self.engine)
-        table_names = inspector.get_table_names()
-        tables = []
-        
-        for table_name in table_names:
-            try:
-                table_comment = inspector.get_table_comment(table_name).get('text', '')
-            except SQLAlchemyError:
-                table_comment = ''
-            
-            tables.append(TableDocument(
-                table_name=table_name,
-                schema_name="",  # MySQL doesn't have explicit schemas like PostgreSQL
-                comment=table_comment or "",
-                row_count=None  # Could be populated if needed
-            ))
-        
-        return tables
-    
-    def get_columns_as_documents(self, table_name: str) -> List[ColumnDocument]:
-        """Return columns as document objects."""
-        inspector = inspect(self.engine)
-        columns_metadata = inspector.get_columns(table_name)
-        pk_columns = inspector.get_pk_constraint(table_name).get('constrained_columns', [])
-        
-        columns = []
-        for col_meta in columns_metadata:
-            columns.append(ColumnDocument(
-                table_name=table_name,
-                column_name=col_meta['name'],
-                data_type=str(col_meta['type']),
-                is_nullable=col_meta.get('nullable', True),
-                is_pk=col_meta['name'] in pk_columns,
-                comment=col_meta.get('comment', '') or ""
-            ))
-        
-        return columns
-    
-    def get_foreign_keys_as_documents(self) -> List[ForeignKeyDocument]:
-        """Return foreign keys as document objects."""
-        inspector = inspect(self.engine)
-        all_foreign_keys = []
-        
-        for table_name in inspector.get_table_names():
-            fks = inspector.get_foreign_keys(table_name)
-            for fk in fks:
-                all_foreign_keys.append(ForeignKeyDocument(
-                    source_table_name=table_name,
-                    source_column_name=fk['constrained_columns'][0],
-                    target_table_name=fk['referred_table'],
-                    target_column_name=fk['referred_columns'][0],
-                    constraint_name=fk.get('name', '')
-                ))
-        
-        return all_foreign_keys
-    
-    def get_schemas_as_documents(self) -> List[SchemaDocument]:
-        """Return schemas as document objects."""
-        # MySQL doesn't have explicit schemas like PostgreSQL
-        return [SchemaDocument(
-            schema_name="default",
-            comment="Default MySQL schema"
-        )]
-    
-    def get_indexes_as_documents(self, table_name: Optional[str] = None) -> List[IndexDocument]:
-        """Return indexes as document objects."""
-        inspector = inspect(self.engine)
-        indexes = []
-        
-        tables = [table_name] if table_name else inspector.get_table_names()
-        
-        for tbl_name in tables:
-            try:
-                table_indexes = inspector.get_indexes(tbl_name)
-                for idx in table_indexes:
-                    indexes.append(IndexDocument(
-                        table_name=tbl_name,
-                        index_name=idx['name'],
-                        column_names=idx['column_names'],
-                        is_unique=idx['unique'],
-                        index_type="BTREE"  # Default for MySQL
-                    ))
-            except SQLAlchemyError as e:
-                logger.warning(f"Could not get indexes for table {tbl_name}: {e}")
-        
-        return indexes
-    
-    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
-        """Get unique values from the database."""
-        # This is a placeholder implementation.
-        # A more sophisticated version like in ThothPgManager should be implemented.
-        return {}
-    
-    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
-        """Get example data (most frequent values) for each column in a table."""
-        inspector = inspect(self.engine)
-        try:
-            columns = inspector.get_columns(table_name)
-        except SQLAlchemyError as e:
-            logger.error(f"Error inspecting columns for table {table_name}: {e}")
-            raise e
-
-        if not columns:
-            logger.warning(f"No columns found for table {table_name}")
-            return {}
-
-        most_frequent_values: Dict[str, List[Any]] = {}
-        
-        with self.engine.connect() as connection:
-            for col_info in columns:
-                column_name = col_info['name']
-                # MySQL uses backticks for identifier quoting
-                quoted_column_name = f'`{column_name}`'
-                quoted_table_name = f'`{table_name}`'
-
-                query_str = f"""
-                    SELECT {quoted_column_name}
-                    FROM (
-                        SELECT {quoted_column_name}, COUNT(*) as _freq
-                        FROM {quoted_table_name}
-                        WHERE {quoted_column_name} IS NOT NULL
-                        GROUP BY {quoted_column_name}
-                        ORDER BY _freq DESC
-                        LIMIT :num_rows
-                    ) as subquery;
-                """
-                try:
-                    result = connection.execute(text(query_str), {"num_rows": number_of_rows})
-                    values = [row[0] for row in result]
-                    most_frequent_values[column_name] = values
-                except SQLAlchemyError as e:
-                    logger.error(f"Error fetching frequent values for {column_name} in {table_name}: {e}")
-                    most_frequent_values[column_name] = []
-
-        # Normalize list lengths
-        max_length = 0
-        if most_frequent_values:
-            max_length = max(len(v) for v in most_frequent_values.values()) if most_frequent_values else 0
-        
-        for column_name in most_frequent_values:
-            current_len = len(most_frequent_values[column_name])
-            if current_len < max_length:
-                most_frequent_values[column_name].extend([None] * (max_length - current_len))
-                
-        return most_frequent_values
-
-
-@register_plugin("mysql")
-class MySQLPlugin(DbPlugin):
-    """MySQL database plugin with full functionality."""
-    
-    plugin_name = "MySQL Plugin"
-    plugin_version = "1.0.0"
-    supported_db_types = ["mysql"]
-    required_dependencies = ["mysql-connector-python", "SQLAlchemy"]
-    
-    _instances = {}
-    _lock = Lock()
-    
-    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.host = None
-        self.port = None
-        self.dbname = None
-        self.user = None
-        self.password = None
-        
-        # LSH manager integration (for backward compatibility)
-        self._lsh_manager = None
-    
-    @classmethod
-    def get_instance(cls, host: str, port: int, dbname: str, user: str, password: str, 
-                    db_root_path: str, db_mode: str = "dev", **kwargs):
-        """Get or create a singleton instance based on connection parameters."""
-        required_params = ['host', 'port', 'dbname', 'user', 'password', 'db_root_path']
-
-        all_params = {
-            'host': host,
-            'port': port,
-            'dbname': dbname,
-            'user': user,
-            'password': password,
-            'db_root_path': db_root_path,
-            'db_mode': db_mode,
-            **kwargs
-        }
-
-        missing_params = [param for param in required_params if all_params.get(param) is None]
-        if missing_params:
-            raise ValueError(f"Missing required parameter{'s' if len(missing_params) > 1 else ''}: {', '.join(missing_params)}")
-
-        with cls._lock:
-            instance_key = (host, port, dbname, user, password, db_root_path, db_mode)
-            
-            if instance_key not in cls._instances:
-                instance = cls(db_root_path=db_root_path, db_mode=db_mode, **all_params)
-                instance.initialize(**all_params)
-                cls._instances[instance_key] = instance
-                
-            return cls._instances[instance_key]
-    
-    def create_adapter(self, **kwargs) -> DbAdapter:
-        """Create and return a MySQL adapter instance."""
-        return MySQLAdapter(kwargs)
-    
-    def validate_connection_params(self, **kwargs) -> bool:
-        """Validate connection parameters for MySQL."""
-        required = ['host', 'port', 'user', 'password']
-        database = kwargs.get('database') or kwargs.get('dbname')
-        
-        if not database:
-            logger.error("Either 'database' or 'dbname' is required for MySQL")
-            return False
-        
-        for param in required:
-            if param not in kwargs:
-                logger.error(f"Missing required parameter: {param}")
-                return False
-        
-        port = kwargs.get('port')
-        if not isinstance(port, int) or not (1 <= port <= 65535):
-            logger.error("port must be an integer between 1 and 65535")
-            return False
-        
-        return True
-    
-    def initialize(self, **kwargs) -> None:
-        """Initialize the MySQL plugin."""
-        # Validate and extract parameters
-        self.host = kwargs.get('host')
-        self.port = kwargs.get('port', 3306)
-        self.dbname = kwargs.get('database') or kwargs.get('dbname')
-        self.user = kwargs.get('user') or kwargs.get('username')
-        self.password = kwargs.get('password')
-        
-        # Set additional attributes
-        for key, value in kwargs.items():
-            if key not in ['host', 'port', 'database', 'dbname', 'user', 'username', 'password']:
-                setattr(self, key, value)
-        
-        # Initialize with updated kwargs
-        super().initialize(**kwargs)
-        
-        # Set up database directory path and ID
-        self.db_id = self.dbname
-        self._setup_directory_path(self.db_id)
-        
-        logger.info(f"MySQL plugin initialized for database: {self.db_id} at {self.host}:{self.port}")
-    
-    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,
-            "host": self.host,
-            "port": self.port,
-            "database": self.dbname,
-            "user": self.user,
-            "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")