db-storage-manager 1.0.8__py3-none-any.whl

db_storage_manager/__init__.py

@@ -0,0 +1,7 @@
+"""
+DB Storage Manager
+A professional desktop application for managing database storage and backups.
+"""
+
+__version__ = "1.0.8"
+__author__ = "VoxHash"

db_storage_manager/analysis/__init__.py

@@ -0,0 +1,27 @@
+"""
+Advanced database analysis features
+"""
+
+from .performance import QueryPerformanceAnalyzer
+from .optimization import IndexOptimizer
+from .prediction import StorageGrowthPredictor
+from .capacity import CapacityPlanner
+from .query_suggestions import (
+    QuerySuggestion,
+    analyze_explain_plan,
+    analyze_sql_heuristics,
+    fetch_explain_plan,
+    suggest_for_query,
+)
+
+__all__ = [
+    "QueryPerformanceAnalyzer",
+    "IndexOptimizer",
+    "StorageGrowthPredictor",
+    "CapacityPlanner",
+    "QuerySuggestion",
+    "analyze_sql_heuristics",
+    "analyze_explain_plan",
+    "fetch_explain_plan",
+    "suggest_for_query",
+]

db_storage_manager/analysis/capacity.py

@@ -0,0 +1,181 @@
+"""
+Capacity planning tools
+"""
+
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+from ..db.base import DatabaseConnection, StorageAnalysis
+from .prediction import StorageGrowthPredictor
+
+
+class CapacityPlanner:
+    """Capacity planning and forecasting"""
+
+    def __init__(self, connection: DatabaseConnection):
+        self.connection = connection
+        self.predictor = StorageGrowthPredictor(connection)
+
+    def add_analysis(self, analysis: StorageAnalysis) -> None:
+        """Add analysis for capacity planning"""
+        self.predictor.add_analysis(analysis)
+
+    def calculate_capacity_utilization(
+        self, analysis: StorageAnalysis, total_capacity: int
+    ) -> Dict[str, Any]:
+        """Calculate current capacity utilization"""
+        current_size = analysis.get("totalSize", 0)
+        utilization_percent = (
+            (current_size / total_capacity * 100) if total_capacity > 0 else 0
+        )
+
+        status = (
+            "critical"
+            if utilization_percent > 90
+            else "warning" if utilization_percent > 75 else "healthy"
+        )
+
+        return {
+            "currentSize": current_size,
+            "totalCapacity": total_capacity,
+            "availableSpace": total_capacity - current_size,
+            "utilizationPercent": utilization_percent,
+            "status": status,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    def estimate_time_to_capacity(
+        self, total_capacity: int, threshold_percent: float = 90.0
+    ) -> Dict[str, Any]:
+        """Estimate time until capacity threshold is reached"""
+        if len(self.predictor.history) < 2:
+            return {
+                "estimatedDays": None,
+                "estimatedDate": None,
+                "confidence": "low",
+                "message": "Insufficient historical data",
+            }
+
+        current_size = self.predictor.history[-1]["totalSize"]
+        threshold_size = total_capacity * (threshold_percent / 100)
+
+        if current_size >= threshold_size:
+            return {
+                "estimatedDays": 0,
+                "estimatedDate": datetime.now().isoformat(),
+                "status": "threshold_reached",
+                "message": f"Already at {threshold_percent}% capacity",
+            }
+
+        # Predict growth
+        prediction = self.predictor.predict_growth(days=365)
+        growth_rate = prediction.get("growthRate", 0) / 100
+
+        if growth_rate <= 0:
+            return {
+                "estimatedDays": None,
+                "estimatedDate": None,
+                "status": "no_growth",
+                "message": "No growth detected, capacity threshold not expected",
+            }
+
+        # Calculate days to threshold
+        remaining_space = threshold_size - current_size
+        daily_growth = current_size * growth_rate
+        estimated_days = (
+            int(remaining_space / daily_growth) if daily_growth > 0 else None
+        )
+
+        if estimated_days:
+            estimated_date = datetime.now() + timedelta(days=estimated_days)
+            return {
+                "estimatedDays": estimated_days,
+                "estimatedDate": estimated_date.isoformat(),
+                "thresholdPercent": threshold_percent,
+                "thresholdSize": int(threshold_size),
+                "currentSize": current_size,
+                "growthRate": growth_rate * 100,
+                "confidence": prediction.get("confidence", "low"),
+            }
+        else:
+            return {
+                "estimatedDays": None,
+                "estimatedDate": None,
+                "status": "unable_to_calculate",
+            }
+
+    def get_capacity_recommendations(
+        self, analysis: StorageAnalysis, total_capacity: int
+    ) -> List[Dict[str, Any]]:
+        """Get capacity planning recommendations"""
+        recommendations = []
+        utilization = self.calculate_capacity_utilization(analysis, total_capacity)
+
+        if utilization["utilizationPercent"] > 90:
+            recommendations.append(
+                {
+                    "type": "urgent",
+                    "severity": "critical",
+                    "message": "Database is at critical capacity (>90%)",
+                    "recommendation": "Immediate action required: Consider archiving old data or increasing capacity",
+                }
+            )
+        elif utilization["utilizationPercent"] > 75:
+            recommendations.append(
+                {
+                    "type": "warning",
+                    "severity": "high",
+                    "message": "Database is approaching capacity (>75%)",
+                    "recommendation": "Plan for capacity increase or data archiving in the near future",
+                }
+            )
+
+        # Check growth trends
+        trends = self.predictor.get_growth_trends()
+        if trends.get("trend") == "rapid_growth":
+            recommendations.append(
+                {
+                    "type": "growth_alert",
+                    "severity": "medium",
+                    "message": "Rapid growth detected",
+                    "recommendation": "Monitor growth closely and plan capacity expansion",
+                }
+            )
+
+        # Time to capacity estimate
+        time_estimate = self.estimate_time_to_capacity(total_capacity)
+        if time_estimate.get("estimatedDays") and time_estimate["estimatedDays"] < 90:
+            recommendations.append(
+                {
+                    "type": "capacity_forecast",
+                    "severity": "high",
+                    "message": f"Capacity threshold may be reached in {time_estimate['estimatedDays']} days",
+                    "recommendation": "Plan capacity increase or data management strategy",
+                }
+            )
+
+        return recommendations
+
+    def generate_capacity_report(
+        self, analysis: StorageAnalysis, total_capacity: int
+    ) -> Dict[str, Any]:
+        """Generate comprehensive capacity planning report"""
+        utilization = self.calculate_capacity_utilization(analysis, total_capacity)
+        trends = self.predictor.get_growth_trends()
+        time_estimate = self.estimate_time_to_capacity(total_capacity)
+        recommendations = self.get_capacity_recommendations(analysis, total_capacity)
+
+        # Predictions for different timeframes
+        predictions = {
+            "30days": self.predictor.predict_growth(30),
+            "90days": self.predictor.predict_growth(90),
+            "365days": self.predictor.predict_growth(365),
+        }
+
+        return {
+            "currentState": utilization,
+            "growthTrends": trends,
+            "timeToCapacity": time_estimate,
+            "predictions": predictions,
+            "recommendations": recommendations,
+            "reportDate": datetime.now().isoformat(),
+        }

db_storage_manager/analysis/optimization.py

@@ -0,0 +1,155 @@
+"""
+Index optimization suggestions
+"""
+
+from typing import Dict, List, Any
+from ..db.base import DatabaseConnection, StorageAnalysis
+
+
+class IndexOptimizer:
+    """Provide index optimization suggestions"""
+
+    def __init__(self, connection: DatabaseConnection):
+        self.connection = connection
+
+    async def analyze_indexes(self, analysis: StorageAnalysis) -> List[Dict[str, Any]]:
+        """Analyze indexes and provide optimization suggestions"""
+        suggestions = []
+        db_type = self.connection.config.type.lower()
+
+        if db_type in ["postgresql", "postgres"]:
+            suggestions = await self._analyze_postgres_indexes(analysis)
+        elif db_type in ["mysql", "mariadb"]:
+            suggestions = await self._analyze_mysql_indexes(analysis)
+        elif db_type == "sqlserver" or db_type == "mssql":
+            suggestions = await self._analyze_sqlserver_indexes(analysis)
+
+        return suggestions
+
+    async def _analyze_postgres_indexes(
+        self, analysis: StorageAnalysis
+    ) -> List[Dict[str, Any]]:
+        """Analyze PostgreSQL indexes"""
+        suggestions = []
+
+        # Check for tables without indexes
+        for table in analysis.get("tables", []):
+            table_indexes = [
+                idx
+                for idx in analysis.get("indexes", [])
+                if idx.get("tableName") == table.get("name")
+            ]
+
+            if not table_indexes and table.get("rowCount", 0) > 1000:
+                suggestions.append(
+                    {
+                        "type": "missing_index",
+                        "severity": "medium",
+                        "table": table.get("name"),
+                        "message": f"Table {table.get('name')} has {table.get('rowCount')} rows but no indexes",
+                        "recommendation": f"Consider adding indexes on frequently queried columns in {table.get('name')}",
+                    }
+                )
+
+            # Check for high bloat indexes
+            for idx in table_indexes:
+                if idx.get("bloat", 0) > 30.0:
+                    suggestions.append(
+                        {
+                            "type": "index_bloat",
+                            "severity": "high",
+                            "index": idx.get("name"),
+                            "table": idx.get("tableName"),
+                            "bloat": idx.get("bloat"),
+                            "message": f"Index {idx.get('name')} has {idx.get('bloat'):.2f}% bloat",
+                            "recommendation": f"Consider rebuilding index {idx.get('name')} to reduce bloat",
+                        }
+                    )
+
+        return suggestions
+
+    async def _analyze_mysql_indexes(
+        self, analysis: StorageAnalysis
+    ) -> List[Dict[str, Any]]:
+        """Analyze MySQL indexes"""
+        suggestions = []
+
+        # Check for large tables without indexes
+        for table in analysis.get("tables", []):
+            table_indexes = [
+                idx
+                for idx in analysis.get("indexes", [])
+                if idx.get("tableName") == table.get("name")
+            ]
+
+            if not table_indexes and table.get("rowCount", 0) > 1000:
+                suggestions.append(
+                    {
+                        "type": "missing_index",
+                        "severity": "medium",
+                        "table": table.get("name"),
+                        "message": f"Table {table.get('name')} has {table.get('rowCount')} rows but no indexes",
+                        "recommendation": f"Add indexes on foreign keys and frequently queried columns",
+                    }
+                )
+
+        return suggestions
+
+    async def _analyze_sqlserver_indexes(
+        self, analysis: StorageAnalysis
+    ) -> List[Dict[str, Any]]:
+        """Analyze SQL Server indexes"""
+        suggestions = []
+
+        # Check for missing indexes (SQL Server specific)
+        if self.connection.connected:
+            try:
+                result = await self.connection.execute_query(
+                    """
+                    SELECT 
+                        OBJECT_NAME(d.object_id) AS table_name,
+                        d.equality_columns,
+                        d.inequality_columns,
+                        d.included_columns,
+                        s.avg_user_impact
+                    FROM sys.dm_db_missing_index_details d
+                    INNER JOIN sys.dm_db_missing_index_groups g ON d.index_handle = g.index_handle
+                    INNER JOIN sys.dm_db_missing_index_group_stats s ON g.index_group_handle = s.group_handle
+                    WHERE s.avg_user_impact > 50
+                    ORDER BY s.avg_user_impact DESC
+                """,
+                    safe_mode=True,
+                )
+
+                for row in result.get("rows", []):
+                    suggestions.append(
+                        {
+                            "type": "missing_index",
+                            "severity": "high",
+                            "table": row.get("table_name"),
+                            "message": f"Missing index on {row.get('table_name')} could improve performance by {row.get('avg_user_impact')}%",
+                            "recommendation": f"Create index on {row.get('equality_columns')} for table {row.get('table_name')}",
+                        }
+                    )
+            except Exception:
+                pass
+
+        return suggestions
+
+    async def get_optimization_recommendations(
+        self, analysis: StorageAnalysis
+    ) -> Dict[str, Any]:
+        """Get comprehensive optimization recommendations"""
+        suggestions = await self.analyze_indexes(analysis)
+
+        high_priority = [s for s in suggestions if s.get("severity") == "high"]
+        medium_priority = [s for s in suggestions if s.get("severity") == "medium"]
+        low_priority = [s for s in suggestions if s.get("severity") == "low"]
+
+        return {
+            "totalSuggestions": len(suggestions),
+            "highPriority": high_priority,
+            "mediumPriority": medium_priority,
+            "lowPriority": low_priority,
+            "suggestions": suggestions,
+        }

db_storage_manager/analysis/performance.py

@@ -0,0 +1,127 @@
+"""
+Query performance analysis
+"""
+
+import time
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from ..db.base import DatabaseConnection, QueryResult
+
+
+class QueryPerformanceAnalyzer:
+    """Analyze query performance"""
+
+    def __init__(self, connection: DatabaseConnection):
+        self.connection = connection
+        self.query_history: List[Dict[str, Any]] = []
+
+    async def analyze_query(self, query: str) -> Dict[str, Any]:
+        """Analyze a query's performance"""
+        start_time = time.time()
+
+        try:
+            result = await self.connection.execute_query(query, safe_mode=True)
+            execution_time = (
+                time.time() - start_time
+            ) * 1000  # Convert to milliseconds
+
+            analysis = {
+                "query": query,
+                "executionTime": execution_time,
+                "rowCount": result.get("rowCount", 0),
+                "columns": result.get("columns", []),
+                "timestamp": datetime.now().isoformat(),
+                "status": "success",
+            }
+
+            # Get explain plan if available
+            try:
+                explain_plan = await self._get_explain_plan(query)
+                analysis["explainPlan"] = explain_plan
+            except Exception:
+                analysis["explainPlan"] = None
+
+            self.query_history.append(analysis)
+            return analysis
+
+        except Exception as e:
+            execution_time = (time.time() - start_time) * 1000
+            analysis = {
+                "query": query,
+                "executionTime": execution_time,
+                "rowCount": 0,
+                "columns": [],
+                "timestamp": datetime.now().isoformat(),
+                "status": "error",
+                "error": str(e),
+            }
+            self.query_history.append(analysis)
+            return analysis
+
+    async def _get_explain_plan(self, query: str) -> Optional[Dict[str, Any]]:
+        """Get query explain plan"""
+        db_type = self.connection.config.type.lower()
+
+        if db_type in ["postgresql", "postgres"]:
+            explain_query = f"EXPLAIN ANALYZE {query}"
+        elif db_type in ["mysql", "mariadb"]:
+            explain_query = f"EXPLAIN {query}"
+        elif db_type == "sqlite":
+            explain_query = f"EXPLAIN QUERY PLAN {query}"
+        else:
+            return None
+
+        try:
+            result = await self.connection.execute_query(explain_query, safe_mode=True)
+            return {
+                "plan": result.get("rows", []),
+                "columns": result.get("columns", []),
+            }
+        except Exception:
+            return None
+
+    def get_slow_queries(self, threshold_ms: float = 1000.0) -> List[Dict[str, Any]]:
+        """Get queries that took longer than threshold"""
+        return [
+            q
+            for q in self.query_history
+            if q.get("executionTime", 0) > threshold_ms and q.get("status") == "success"
+        ]
+
+    def get_query_statistics(self) -> Dict[str, Any]:
+        """Get query performance statistics"""
+        if not self.query_history:
+            return {
+                "totalQueries": 0,
+                "averageExecutionTime": 0,
+                "slowQueries": 0,
+                "errorQueries": 0,
+            }
+
+        successful_queries = [
+            q for q in self.query_history if q.get("status") == "success"
+        ]
+
+        if successful_queries:
+            from ..native import aggregate_f64
+
+            times = [float(q.get("executionTime", 0) or 0) for q in successful_queries]
+            _count, _total, min_time, max_time, avg_time = aggregate_f64(times)
+            slow_queries = len(self.get_slow_queries())
+        else:
+            avg_time = 0
+            min_time = 0
+            max_time = 0
+            slow_queries = 0
+
+        return {
+            "totalQueries": len(self.query_history),
+            "averageExecutionTime": avg_time,
+            "minExecutionTime": min_time,
+            "maxExecutionTime": max_time,
+            "slowQueries": slow_queries,
+            "errorQueries": len(
+                [q for q in self.query_history if q.get("status") == "error"]
+            ),
+            "successfulQueries": len(successful_queries),
+        }

db_storage_manager/analysis/prediction.py

@@ -0,0 +1,169 @@
+"""
+Storage growth predictions
+"""
+
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+import statistics
+from ..db.base import DatabaseConnection, StorageAnalysis
+
+
+class StorageGrowthPredictor:
+    """Predict storage growth based on historical data"""
+
+    def __init__(self, connection: DatabaseConnection):
+        self.connection = connection
+        self.history: List[Dict[str, Any]] = []
+
+    def add_analysis(self, analysis: StorageAnalysis) -> None:
+        """Add analysis data point to history"""
+        self.history.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "totalSize": analysis.get("totalSize", 0),
+                "tableCount": analysis.get("tableCount", 0),
+                "analysis": analysis,
+            }
+        )
+
+    def predict_growth(self, days: int = 30) -> Dict[str, Any]:
+        """Predict storage growth for the next N days"""
+        if len(self.history) < 2:
+            return {
+                "predictedSize": 0,
+                "growthRate": 0,
+                "confidence": "low",
+                "message": "Insufficient historical data for prediction",
+            }
+
+        # Calculate growth rate
+        sizes = [h["totalSize"] for h in self.history]
+        growth_rates = []
+
+        for i in range(1, len(sizes)):
+            if sizes[i - 1] > 0:
+                rate = (sizes[i] - sizes[i - 1]) / sizes[i - 1]
+                growth_rates.append(rate)
+
+        if not growth_rates:
+            return {
+                "predictedSize": sizes[-1] if sizes else 0,
+                "growthRate": 0,
+                "confidence": "low",
+                "message": "No growth detected",
+            }
+
+        avg_growth_rate = statistics.mean(growth_rates)
+        current_size = sizes[-1]
+
+        # Predict future size
+        predicted_size = current_size * (1 + avg_growth_rate) ** days
+
+        # Calculate confidence based on data points
+        confidence = (
+            "high"
+            if len(self.history) >= 10
+            else "medium" if len(self.history) >= 5 else "low"
+        )
+
+        return {
+            "predictedSize": int(predicted_size),
+            "currentSize": current_size,
+            "growthRate": avg_growth_rate * 100,  # Percentage
+            "growthAmount": int(predicted_size - current_size),
+            "days": days,
+            "confidence": confidence,
+            "predictedDate": (datetime.now() + timedelta(days=days)).isoformat(),
+        }
+
+    def predict_table_growth(self, table_name: str, days: int = 30) -> Dict[str, Any]:
+        """Predict growth for a specific table"""
+        table_history = []
+
+        for h in self.history:
+            analysis = h.get("analysis", {})
+            for table in analysis.get("tables", []):
+                if table.get("name") == table_name:
+                    table_history.append(
+                        {
+                            "timestamp": h["timestamp"],
+                            "size": table.get("size", 0),
+                            "rowCount": table.get("rowCount", 0),
+                        }
+                    )
+
+        if len(table_history) < 2:
+            return {
+                "predictedSize": 0,
+                "growthRate": 0,
+                "confidence": "low",
+                "message": f"Insufficient data for table {table_name}",
+            }
+
+        sizes = [h["size"] for h in table_history]
+        growth_rates = []
+
+        for i in range(1, len(sizes)):
+            if sizes[i - 1] > 0:
+                rate = (sizes[i] - sizes[i - 1]) / sizes[i - 1]
+                growth_rates.append(rate)
+
+        if not growth_rates:
+            return {
+                "predictedSize": sizes[-1] if sizes else 0,
+                "growthRate": 0,
+                "confidence": "low",
+            }
+
+        avg_growth_rate = statistics.mean(growth_rates)
+        current_size = sizes[-1]
+        predicted_size = current_size * (1 + avg_growth_rate) ** days
+
+        return {
+            "tableName": table_name,
+            "predictedSize": int(predicted_size),
+            "currentSize": current_size,
+            "growthRate": avg_growth_rate * 100,
+            "growthAmount": int(predicted_size - current_size),
+            "days": days,
+            "confidence": "high" if len(table_history) >= 10 else "medium",
+        }
+
+    def get_growth_trends(self) -> Dict[str, Any]:
+        """Get overall growth trends"""
+        if len(self.history) < 2:
+            return {
+                "trend": "insufficient_data",
+                "message": "Need at least 2 data points",
+            }
+
+        sizes = [h["totalSize"] for h in self.history]
+        growth_rates = []
+
+        for i in range(1, len(sizes)):
+            if sizes[i - 1] > 0:
+                rate = (sizes[i] - sizes[i - 1]) / sizes[i - 1]
+                growth_rates.append(rate)
+
+        if not growth_rates:
+            return {"trend": "stable", "growthRate": 0}
+
+        avg_rate = statistics.mean(growth_rates)
+
+        if avg_rate > 0.1:
+            trend = "rapid_growth"
+        elif avg_rate > 0.01:
+            trend = "moderate_growth"
+        elif avg_rate > 0:
+            trend = "slow_growth"
+        elif avg_rate == 0:
+            trend = "stable"
+        else:
+            trend = "declining"
+
+        return {
+            "trend": trend,
+            "growthRate": avg_rate * 100,
+            "dataPoints": len(self.history),
+            "totalGrowth": sizes[-1] - sizes[0] if sizes else 0,
+        }