mcp-dbutils 0.15.5__py3-none-any.whl → 0.16.1__py3-none-any.whl

mcp_dbutils/base.py

@@ -299,6 +299,64 @@ class ConnectionServer:
                 self.send_log(LOG_LEVEL_ERROR, f"Error in list_prompts: {str(e)}")
                 raise
 
+    def _get_config_or_raise(self, connection: str) -> dict:
+        """读取配置文件并验证连接配置
+        
+        Args:
+            connection: 连接名称
+            
+        Returns:
+            dict: 连接配置
+            
+        Raises:
+            ConfigurationError: 如果配置文件格式不正确或连接不存在
+        """
+        with open(self.config_path, 'r') as f:
+            config = yaml.safe_load(f)
+            if not config or 'connections' not in config:
+                raise ConfigurationError("Configuration file must contain 'connections' section")
+            if connection not in config['connections']:
+                available_connections = list(config['connections'].keys())
+                raise ConfigurationError(f"Connection not found: {connection}. Available connections: {available_connections}")
+            
+            db_config = config['connections'][connection]
+            
+            if 'type' not in db_config:
+                raise ConfigurationError("Database configuration must include 'type' field")
+                
+            return db_config
+            
+    def _create_handler_for_type(self, db_type: str, connection: str) -> ConnectionHandler:
+        """基于数据库类型创建相应的处理器
+        
+        Args:
+            db_type: 数据库类型
+            connection: 连接名称
+            
+        Returns:
+            ConnectionHandler: 数据库连接处理器
+            
+        Raises:
+            ConfigurationError: 如果数据库类型不支持或导入失败
+        """
+        self.send_log(LOG_LEVEL_DEBUG, f"Creating handler for database type: {db_type}")
+        
+        try:
+            if db_type == 'sqlite':
+                from .sqlite.handler import SQLiteHandler
+                return SQLiteHandler(self.config_path, connection, self.debug)
+            elif db_type == 'postgres':
+                from .postgres.handler import PostgreSQLHandler
+                return PostgreSQLHandler(self.config_path, connection, self.debug)
+            elif db_type == 'mysql':
+                from .mysql.handler import MySQLHandler
+                return MySQLHandler(self.config_path, connection, self.debug)
+            else:
+                raise ConfigurationError(f"Unsupported database type: {db_type}")
+        except ImportError as e:
+            # 捕获导入错误并转换为ConfigurationError，以保持与现有测试兼容
+            raise ConfigurationError(f"Failed to import handler for {db_type}: {str(e)}")
+
     @asynccontextmanager
     async def get_handler(self, connection: str) -> AsyncContextManager[ConnectionHandler]:
         """Get connection handler
@@ -311,74 +369,385 @@ class ConnectionServer:
         Returns:
             AsyncContextManager[ConnectionHandler]: Context manager for connection handler
         """
-        # Read configuration file to determine database type
-        with open(self.config_path, 'r') as f:
-            config = yaml.safe_load(f)
-            if not config or 'connections' not in config:
-                raise ConfigurationError("Configuration file must contain 'connections' section")
-            if connection not in config['connections']:
-                available_connections = list(config['connections'].keys())
-                raise ConfigurationError(f"Connection not found: {connection}. Available connections: {available_connections}")
+        # Read configuration file and validate connection
+        db_config = self._get_config_or_raise(connection)
+        
+        # Create appropriate handler based on database type
+        handler = None
+        try:
+            db_type = db_config['type']
+            handler = self._create_handler_for_type(db_type, connection)
 
-            db_config = config['connections'][connection]
+            # Set session for MCP logging
+            if hasattr(self.server, 'session'):
+                handler._session = self.server.session
 
-            handler = None
-            try:
-                if 'type' not in db_config:
-                    raise ConfigurationError("Database configuration must include 'type' field")
-
-                db_type = db_config['type']
-                self.send_log(LOG_LEVEL_DEBUG, f"Creating handler for database type: {db_type}")
-                if db_type == 'sqlite':
-                    from .sqlite.handler import SQLiteHandler
-                    handler = SQLiteHandler(self.config_path, connection, self.debug)
-                elif db_type == 'postgres':
-                    from .postgres.handler import PostgreSQLHandler
-                    handler = PostgreSQLHandler(self.config_path, connection, self.debug)
-                elif db_type == 'mysql':
-                    from .mysql.handler import MySQLHandler
-                    handler = MySQLHandler(self.config_path, connection, self.debug)
-                else:
-                    raise ConfigurationError(f"Unsupported database type: {db_type}")
-
-                # Set session for MCP logging
-                if hasattr(self.server, 'session'):
-                    handler._session = self.server.session
-
-                handler.stats.record_connection_start()
-                self.send_log(LOG_LEVEL_DEBUG, f"Handler created successfully for {connection}")
-                # 使用通用的方式处理统计信息序列化
+            handler.stats.record_connection_start()
+            self.send_log(LOG_LEVEL_DEBUG, f"Handler created successfully for {connection}")
+            
+            yield handler
+        finally:
+            if handler:
+                self.send_log(LOG_LEVEL_DEBUG, f"Cleaning up handler for {connection}")
+                handler.stats.record_connection_end()
+                
+                if hasattr(handler, 'cleanup') and callable(handler.cleanup):
+                    await handler.cleanup()
+
+    def _get_available_tools(self) -> list[types.Tool]:
+        """返回所有可用的数据库工具列表
+        
+        Returns:
+            list[types.Tool]: 工具列表
+        """
+        return [
+            types.Tool(
+                name="dbutils-run-query",
+                description="Execute read-only SQL query on database connection",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "sql": {
+                            "type": "string",
+                            "description": "SQL query (SELECT only)"
+                        }
+                    },
+                    "required": ["connection", "sql"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-list-tables",
+                description="List all available tables in the specified database connection",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        }
+                    },
+                    "required": ["connection"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-describe-table",
+                description="Get detailed information about a table's structure",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "table": {
+                            "type": "string",
+                            "description": "Table name to describe"
+                        }
+                    },
+                    "required": ["connection", "table"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-get-ddl",
+                description="Get DDL statement for creating the table",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "table": {
+                            "type": "string",
+                            "description": "Table name to get DDL for"
+                        }
+                    },
+                    "required": ["connection", "table"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-list-indexes",
+                description="List all indexes on the specified table",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "table": {
+                            "type": "string",
+                            "description": "Table name to list indexes for"
+                        }
+                    },
+                    "required": ["connection", "table"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-get-stats",
+                description="Get table statistics like row count and size",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "table": {
+                            "type": "string",
+                            "description": "Table name to get statistics for"
+                        }
+                    },
+                    "required": ["connection", "table"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-list-constraints",
+                description="List all constraints (primary key, foreign keys, etc) on the table",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "table": {
+                            "type": "string",
+                            "description": "Table name to list constraints for"
+                        }
+                    },
+                    "required": ["connection", "table"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-explain-query",
+                description="Get execution plan for a SQL query",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "sql": {
+                            "type": "string",
+                            "description": "SQL query to explain"
+                        }
+                    },
+                    "required": ["connection", "sql"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-get-performance",
+                description="Get database performance statistics",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        }
+                    },
+                    "required": ["connection"]
+                }
+            ),
+            types.Tool(
+                name="dbutils-analyze-query",
+                description="Analyze a SQL query for performance",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "connection": {
+                            "type": "string",
+                            "description": DATABASE_CONNECTION_NAME
+                        },
+                        "sql": {
+                            "type": "string",
+                            "description": "SQL query to analyze"
+                        }
+                    },
+                    "required": ["connection", "sql"]
+                }
+            )
+        ]
+        
+    async def _handle_list_tables(self, connection: str) -> list[types.TextContent]:
+        """处理列表表格工具调用
+        
+        Args:
+            connection: 数据库连接名称
+            
+        Returns:
+            list[types.TextContent]: 表格列表
+        """
+        async with self.get_handler(connection) as handler:
+            tables = await handler.get_tables()
+            if not tables:
+                # 空表列表的情况也返回数据库类型
+                return [types.TextContent(type="text", text=f"[{handler.db_type}] No tables found")]
+            
+            formatted_tables = "\n".join([
+                f"Table: {table.name}\n" +
+                f"URI: {table.uri}\n" +
+                (f"Description: {table.description}\n" if table.description else "") +
+                "---"
+                for table in tables
+            ])
+            # 添加数据库类型前缀
+            return [types.TextContent(type="text", text=f"[{handler.db_type}]\n{formatted_tables}")]
+            
+    async def _handle_run_query(self, connection: str, sql: str) -> list[types.TextContent]:
+        """处理运行查询工具调用
+        
+        Args:
+            connection: 数据库连接名称
+            sql: SQL查询语句
+            
+        Returns:
+            list[types.TextContent]: 查询结果
+            
+        Raises:
+            ConfigurationError: 如果SQL为空或非SELECT语句
+        """
+        if not sql:
+            raise ConfigurationError(EMPTY_QUERY_ERROR)
+
+        # Only allow SELECT statements
+        if not sql.lower().startswith("select"):
+            raise ConfigurationError(SELECT_ONLY_ERROR)
+
+        async with self.get_handler(connection) as handler:
+            result = await handler.execute_query(sql)
+            return [types.TextContent(type="text", text=result)]
+            
+    async def _handle_table_tools(self, name: str, connection: str, table: str) -> list[types.TextContent]:
+        """处理表相关工具调用
+        
+        Args:
+            name: 工具名称
+            connection: 数据库连接名称
+            table: 表名
+            
+        Returns:
+            list[types.TextContent]: 工具执行结果
+            
+        Raises:
+            ConfigurationError: 如果表名为空
+        """
+        if not table:
+            raise ConfigurationError(EMPTY_TABLE_NAME_ERROR)
+        
+        async with self.get_handler(connection) as handler:
+            result = await handler.execute_tool_query(name, table_name=table)
+            return [types.TextContent(type="text", text=result)]
+            
+    async def _handle_explain_query(self, connection: str, sql: str) -> list[types.TextContent]:
+        """处理解释查询工具调用
+        
+        Args:
+            connection: 数据库连接名称
+            sql: SQL查询语句
+            
+        Returns:
+            list[types.TextContent]: 查询解释
+            
+        Raises:
+            ConfigurationError: 如果SQL为空
+        """
+        if not sql:
+            raise ConfigurationError(EMPTY_QUERY_ERROR)
+        
+        async with self.get_handler(connection) as handler:
+            result = await handler.execute_tool_query("dbutils-explain-query", sql=sql)
+            return [types.TextContent(type="text", text=result)]
+            
+    async def _handle_performance(self, connection: str) -> list[types.TextContent]:
+        """处理性能统计工具调用
+        
+        Args:
+            connection: 数据库连接名称
+            
+        Returns:
+            list[types.TextContent]: 性能统计
+        """
+        async with self.get_handler(connection) as handler:
+            performance_stats = handler.stats.get_performance_stats()
+            return [types.TextContent(type="text", text=f"[{handler.db_type}]\n{performance_stats}")]
+            
+    async def _handle_analyze_query(self, connection: str, sql: str) -> list[types.TextContent]:
+        """处理查询分析工具调用
+        
+        Args:
+            connection: 数据库连接名称
+            sql: SQL查询语句
+            
+        Returns:
+            list[types.TextContent]: 查询分析结果
+            
+        Raises:
+            ConfigurationError: 如果SQL为空
+        """
+        if not sql:
+            raise ConfigurationError(EMPTY_QUERY_ERROR)
+        
+        async with self.get_handler(connection) as handler:
+            # First get the execution plan
+            explain_result = await handler.explain_query(sql)
+            
+            # Then execute the actual query to measure performance
+            start_time = datetime.now()
+            if sql.lower().startswith("select"):
                 try:
-                    if hasattr(handler.stats, 'to_dict') and callable(handler.stats.to_dict):
-                        stats_dict = handler.stats.to_dict()
-                        stats_json = json.dumps(stats_dict)
-                        self.send_log(LOG_LEVEL_INFO, f"Resource stats: {stats_json}")
-                    else:
-                        self.send_log(LOG_LEVEL_INFO, "Resource stats not available")
-                except TypeError:
-                    self.send_log(LOG_LEVEL_INFO, "Resource stats: [Could not serialize stats object]")
-                yield handler
-            except yaml.YAMLError as e:
-                raise ConfigurationError(f"Invalid YAML configuration: {str(e)}")
-            except ImportError as e:
-                raise ConfigurationError(f"Failed to import handler for {db_type}: {str(e)}")
-            finally:
-                if handler:
-                    self.send_log(LOG_LEVEL_DEBUG, f"Cleaning up handler for {connection}")
-                    handler.stats.record_connection_end()
-                    # 使用通用的方式处理统计信息序列化
-                    try:
-                        if hasattr(handler.stats, 'to_dict') and callable(handler.stats.to_dict):
-                            stats_dict = handler.stats.to_dict()
-                            stats_json = json.dumps(stats_dict)
-                            self.send_log(LOG_LEVEL_INFO, f"Final resource stats: {stats_json}")
-                        else:
-                            self.send_log(LOG_LEVEL_INFO, "Final resource stats not available")
-                    except TypeError:
-                        self.send_log(LOG_LEVEL_INFO, "Final resource stats: [Could not serialize stats object]")
-                    # 清理资源
-                    if hasattr(handler, 'cleanup') and callable(handler.cleanup):
-                        await handler.cleanup()
+                    await handler.execute_query(sql)
+                except Exception as e:
+                    # If query fails, we still provide the execution plan
+                    self.send_log(LOG_LEVEL_ERROR, f"Query execution failed during analysis: {str(e)}")
+            duration = (datetime.now() - start_time).total_seconds()
+            
+            # Combine analysis results
+            analysis = [
+                f"[{handler.db_type}] Query Analysis",
+                f"SQL: {sql}",
+                "",
+                f"Execution Time: {duration*1000:.2f}ms",
+                "",
+                "Execution Plan:",
+                explain_result
+            ]
+            
+            # Add optimization suggestions
+            suggestions = self._get_optimization_suggestions(explain_result, duration)
+            if suggestions:
+                analysis.append("\nOptimization Suggestions:")
+                analysis.extend(suggestions)
+                
+            return [types.TextContent(type="text", text="\n".join(analysis))]
+            
+    def _get_optimization_suggestions(self, explain_result: str, duration: float) -> list[str]:
+        """根据执行计划和耗时获取优化建议
+        
+        Args:
+            explain_result: 执行计划
+            duration: 查询耗时（秒）
+            
+        Returns:
+            list[str]: 优化建议列表
+        """
+        suggestions = []
+        if "seq scan" in explain_result.lower() and duration > 0.1:
+            suggestions.append("- Consider adding an index to avoid sequential scan")
+        if "hash join" in explain_result.lower() and duration > 0.5:
+            suggestions.append("- Consider optimizing join conditions")
+        if duration > 0.5:  # 500ms
+            suggestions.append("- Query is slow, consider optimizing or adding caching")
+        if "temporary" in explain_result.lower():
+            suggestions.append("- Query creates temporary tables, consider restructuring")
+            
+        return suggestions
 
     def _setup_handlers(self):
         """Setup MCP handlers"""
@@ -409,180 +778,7 @@ class ConnectionServer:
 
         @self.server.list_tools()
         async def handle_list_tools() -> list[types.Tool]:
-            return [
-                types.Tool(
-                    name="dbutils-run-query",
-                    description="Execute read-only SQL query on database connection",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "sql": {
-                                "type": "string",
-                                "description": "SQL query (SELECT only)"
-                            }
-                        },
-                        "required": ["connection", "sql"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-list-tables",
-                    description="List all available tables in the specified database connection",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            }
-                        },
-                        "required": ["connection"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-describe-table",
-                    description="Get detailed information about a table's structure",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "table": {
-                                "type": "string",
-                                "description": "Table name to describe"
-                            }
-                        },
-                        "required": ["connection", "table"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-get-ddl",
-                    description="Get DDL statement for creating the table",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "table": {
-                                "type": "string",
-                                "description": "Table name to get DDL for"
-                            }
-                        },
-                        "required": ["connection", "table"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-list-indexes",
-                    description="List all indexes on the specified table",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "table": {
-                                "type": "string",
-                                "description": "Table name to list indexes for"
-                            }
-                        },
-                        "required": ["connection", "table"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-get-stats",
-                    description="Get table statistics like row count and size",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "table": {
-                                "type": "string",
-                                "description": "Table name to get statistics for"
-                            }
-                        },
-                        "required": ["connection", "table"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-list-constraints",
-                    description="List all constraints (primary key, foreign keys, etc) on the table",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "table": {
-                                "type": "string",
-                                "description": "Table name to list constraints for"
-                            }
-                        },
-                        "required": ["connection", "table"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-explain-query",
-                    description="Get execution plan for a SQL query",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "sql": {
-                                "type": "string",
-                                "description": "SQL query to explain"
-                            }
-                        },
-                        "required": ["connection", "sql"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-get-performance",
-                    description="Get database performance statistics",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            }
-                        },
-                        "required": ["connection"]
-                    }
-                ),
-                types.Tool(
-                    name="dbutils-analyze-query",
-                    description="Analyze a SQL query for performance",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "connection": {
-                                "type": "string",
-                                "description": DATABASE_CONNECTION_NAME
-                            },
-                            "sql": {
-                                "type": "string",
-                                "description": "SQL query to analyze"
-                            }
-                        },
-                        "required": ["connection", "sql"]
-                    }
-                )
-            ]
+            return self._get_available_tools()
 
         @self.server.call_tool()
         async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
@@ -592,100 +788,22 @@ class ConnectionServer:
             connection = arguments["connection"]
 
             if name == "dbutils-list-tables":
-                async with self.get_handler(connection) as handler:
-                    tables = await handler.get_tables()
-                    if not tables:
-                        # 空表列表的情况也返回数据库类型
-                        return [types.TextContent(type="text", text=f"[{handler.db_type}] No tables found")]
-                    
-                    formatted_tables = "\n".join([
-                        f"Table: {table.name}\n" +
-                        f"URI: {table.uri}\n" +
-                        (f"Description: {table.description}\n" if table.description else "") +
-                        "---"
-                        for table in tables
-                    ])
-                    # 添加数据库类型前缀
-                    return [types.TextContent(type="text", text=f"[{handler.db_type}]\n{formatted_tables}")]
+                return await self._handle_list_tables(connection)
             elif name == "dbutils-run-query":
                 sql = arguments.get("sql", "").strip()
-                if not sql:
-                    raise ConfigurationError(EMPTY_QUERY_ERROR)
-
-                # Only allow SELECT statements
-                if not sql.lower().startswith("select"):
-                    raise ConfigurationError(SELECT_ONLY_ERROR)
-
-                async with self.get_handler(connection) as handler:
-                    result = await handler.execute_query(sql)
-                    return [types.TextContent(type="text", text=result)]
+                return await self._handle_run_query(connection, sql)
             elif name in ["dbutils-describe-table", "dbutils-get-ddl", "dbutils-list-indexes",
                          "dbutils-get-stats", "dbutils-list-constraints"]:
                 table = arguments.get("table", "").strip()
-                if not table:
-                    raise ConfigurationError(EMPTY_TABLE_NAME_ERROR)
-                
-                async with self.get_handler(connection) as handler:
-                    result = await handler.execute_tool_query(name, table_name=table)
-                    return [types.TextContent(type="text", text=result)]
+                return await self._handle_table_tools(name, connection, table)
             elif name == "dbutils-explain-query":
                 sql = arguments.get("sql", "").strip()
-                if not sql:
-                    raise ConfigurationError(EMPTY_QUERY_ERROR)
-                
-                async with self.get_handler(connection) as handler:
-                    result = await handler.execute_tool_query(name, sql=sql)
-                    return [types.TextContent(type="text", text=result)]
+                return await self._handle_explain_query(connection, sql)
             elif name == "dbutils-get-performance":
-                async with self.get_handler(connection) as handler:
-                    performance_stats = handler.stats.get_performance_stats()
-                    return [types.TextContent(type="text", text=f"[{handler.db_type}]\n{performance_stats}")]
+                return await self._handle_performance(connection)
             elif name == "dbutils-analyze-query":
                 sql = arguments.get("sql", "").strip()
-                if not sql:
-                    raise ConfigurationError(EMPTY_QUERY_ERROR)
-                
-                async with self.get_handler(connection) as handler:
-                    # First get the execution plan
-                    explain_result = await handler.explain_query(sql)
-                    
-                    # Then execute the actual query to measure performance
-                    start_time = datetime.now()
-                    if sql.lower().startswith("select"):
-                        try:
-                            await handler.execute_query(sql)
-                        except Exception as e:
-                            # If query fails, we still provide the execution plan
-                            self.send_log(LOG_LEVEL_ERROR, f"Query execution failed during analysis: {str(e)}")
-                    duration = (datetime.now() - start_time).total_seconds()
-                    
-                    # Combine analysis results
-                    analysis = [
-                    f"[{handler.db_type}] Query Analysis",
-                    f"SQL: {sql}",
-                    "",
-                    f"Execution Time: {duration*1000:.2f}ms",
-                    "",
-                    "Execution Plan:",
-                        explain_result
-                    ]
-                    
-                    # Add optimization suggestions based on execution plan and timing
-                    suggestions = []
-                    if "seq scan" in explain_result.lower() and duration > 0.1:
-                        suggestions.append("- Consider adding an index to avoid sequential scan")
-                    if "hash join" in explain_result.lower() and duration > 0.5:
-                        suggestions.append("- Consider optimizing join conditions")
-                    if duration > 0.5:  # 500ms
-                        suggestions.append("- Query is slow, consider optimizing or adding caching")
-                    if "temporary" in explain_result.lower():
-                        suggestions.append("- Query creates temporary tables, consider restructuring")
-                    
-                    if suggestions:
-                        analysis.append("\nOptimization Suggestions:")
-                        analysis.extend(suggestions)
-                        
-                    return [types.TextContent(type="text", text="\n".join(analysis))]
+                return await self._handle_analyze_query(connection, sql)
             else:
                 raise ConfigurationError(f"Unknown tool: {name}")
 

mcp_dbutils/mysql/config.py

@@ -77,15 +77,19 @@ class MySQLConfig(ConnectionConfig):
     ssl: Optional[SSLConfig] = None
 
     @classmethod
-    def from_yaml(cls, yaml_path: str, db_name: str, local_host: Optional[str] = None) -> 'MySQLConfig':
-        """Create configuration from YAML file
-
+    def _validate_connection_config(cls, configs: dict, db_name: str) -> dict:
+        """验证连接配置是否有效
+        
         Args:
-            yaml_path: Path to YAML configuration file
-            db_name: Connection configuration name to use
-            local_host: Optional local host address
+            configs: 配置字典
+            db_name: 连接名称
+            
+        Returns:
+            dict: 数据库配置
+            
+        Raises:
+            ValueError: 如果配置无效
         """
-        configs = cls.load_yaml_config(yaml_path)
         if not db_name:
             raise ValueError("Connection name must be specified")
         if db_name not in configs:
@@ -103,57 +107,121 @@ class MySQLConfig(ConnectionConfig):
             raise ValueError("User must be specified in connection configuration")
         if not db_config.get('password'):
             raise ValueError("Password must be specified in connection configuration")
+            
+        return db_config
+        
+    @classmethod
+    def _create_config_from_url(cls, db_config: dict, local_host: Optional[str] = None) -> 'MySQLConfig':
+        """从URL创建配置
+        
+        Args:
+            db_config: 数据库配置
+            local_host: 可选的本地主机地址
+            
+        Returns:
+            MySQLConfig: 配置对象
+        """
+        # Parse URL for connection parameters
+        params = parse_url(db_config['url'])
+        config = cls(
+            database=params['database'],
+            user=db_config['user'],
+            password=db_config['password'],
+            host=params['host'],
+            port=params['port'],
+            charset=params['charset'],
+            local_host=local_host,
+            url=db_config['url'],
+            ssl=params.get('ssl')
+        )
+        return config
+        
+    @classmethod
+    def _create_config_from_params(cls, db_config: dict, local_host: Optional[str] = None) -> 'MySQLConfig':
+        """从参数创建配置
+        
+        Args:
+            db_config: 数据库配置
+            local_host: 可选的本地主机地址
+            
+        Returns:
+            MySQLConfig: 配置对象
+            
+        Raises:
+            ValueError: 如果缺少必需参数或SSL配置无效
+        """
+        if not db_config.get('database'):
+            raise ValueError("MySQL database name must be specified in configuration")
+        if not db_config.get('host'):
+            raise ValueError("Host must be specified in connection configuration")
+        if not db_config.get('port'):
+            raise ValueError("Port must be specified in connection configuration")
+        
+        # Parse SSL configuration if present
+        ssl_config = cls._parse_ssl_config(db_config)
+        
+        config = cls(
+            database=db_config['database'],
+            user=db_config['user'],
+            password=db_config['password'],
+            host=db_config['host'],
+            port=str(db_config['port']),
+            charset=db_config.get('charset', 'utf8mb4'),
+            local_host=local_host,
+            ssl=ssl_config
+        )
+        return config
+        
+    @classmethod
+    def _parse_ssl_config(cls, db_config: dict) -> Optional[SSLConfig]:
+        """解析SSL配置
+        
+        Args:
+            db_config: 数据库配置
+            
+        Returns:
+            Optional[SSLConfig]: SSL配置或None
+            
+        Raises:
+            ValueError: 如果SSL配置无效
+        """
+        if 'ssl' not in db_config:
+            return None
+            
+        ssl_params = db_config['ssl']
+        if not isinstance(ssl_params, dict):
+            raise ValueError("SSL configuration must be a dictionary")
+        
+        if ssl_params.get('mode') not in [None, 'disabled', 'required', 'verify_ca', 'verify_identity']:
+            raise ValueError(f"Invalid ssl-mode: {ssl_params.get('mode')}")
+        
+        return SSLConfig(
+            mode=ssl_params.get('mode', 'disabled'),
+            ca=ssl_params.get('ca'),
+            cert=ssl_params.get('cert'),
+            key=ssl_params.get('key')
+        )
 
-        # Get connection parameters
+    @classmethod
+    def from_yaml(cls, yaml_path: str, db_name: str, local_host: Optional[str] = None) -> 'MySQLConfig':
+        """Create configuration from YAML file
+
+        Args:
+            yaml_path: Path to YAML configuration file
+            db_name: Connection configuration name to use
+            local_host: Optional local host address
+        """
+        configs = cls.load_yaml_config(yaml_path)
+        
+        # Validate connection config
+        db_config = cls._validate_connection_config(configs, db_name)
+
+        # Create configuration based on URL or parameters
         if 'url' in db_config:
-            # Parse URL for connection parameters
-            params = parse_url(db_config['url'])
-            config = cls(
-                database=params['database'],
-                user=db_config['user'],
-                password=db_config['password'],
-                host=params['host'],
-                port=params['port'],
-                charset=params['charset'],
-                local_host=local_host,
-                url=db_config['url'],
-                ssl=params.get('ssl')
-            )
+            config = cls._create_config_from_url(db_config, local_host)
         else:
-            if not db_config.get('database'):
-                raise ValueError("MySQL database name must be specified in configuration")
-            if not db_config.get('host'):
-                raise ValueError("Host must be specified in connection configuration")
-            if not db_config.get('port'):
-                raise ValueError("Port must be specified in connection configuration")
-            
-            # Parse SSL configuration if present
-            ssl_config = None
-            if 'ssl' in db_config:
-                ssl_params = db_config['ssl']
-                if not isinstance(ssl_params, dict):
-                    raise ValueError("SSL configuration must be a dictionary")
-                
-                if ssl_params.get('mode') not in [None, 'disabled', 'required', 'verify_ca', 'verify_identity']:
-                    raise ValueError(f"Invalid ssl-mode: {ssl_params.get('mode')}")
-                
-                ssl_config = SSLConfig(
-                    mode=ssl_params.get('mode', 'disabled'),
-                    ca=ssl_params.get('ca'),
-                    cert=ssl_params.get('cert'),
-                    key=ssl_params.get('key')
-                )
+            config = cls._create_config_from_params(db_config, local_host)
             
-            config = cls(
-                database=db_config['database'],
-                user=db_config['user'],
-                password=db_config['password'],
-                host=db_config['host'],
-                port=str(db_config['port']),
-                charset=db_config.get('charset', 'utf8mb4'),
-                local_host=local_host,
-                ssl=ssl_config
-            )
         config.debug = cls.get_debug_mode()
         return config
 

mcp_dbutils/mysql/handler.py

@@ -36,7 +36,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 cur.execute("""
                     SELECT 
                         TABLE_NAME as table_name,
@@ -66,7 +66,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get column information
                 cur.execute("""
                     SELECT 
@@ -118,7 +118,7 @@ class MySQLHandler(ConnectionHandler):
             conn = mysql.connector.connect(**conn_params)
             self.log("debug", f"Executing query: {sql}")
 
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Start read-only transaction
                 cur.execute("SET TRANSACTION READ ONLY")
                 try:
@@ -150,7 +150,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get table information and comment
                 cur.execute("""
                     SELECT 
@@ -220,7 +220,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # MySQL provides a SHOW CREATE TABLE statement
                 cur.execute(f"SHOW CREATE TABLE {table_name}")
                 result = cur.fetchone()
@@ -242,7 +242,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get index information
                 cur.execute("""
                     SELECT 
@@ -301,7 +301,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get table statistics
                 cur.execute("""
                     SELECT 
@@ -366,7 +366,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get constraint information
                 cur.execute("""
                     SELECT 
@@ -429,7 +429,7 @@ class MySQLHandler(ConnectionHandler):
         try:
             conn_params = self.config.get_connection_params()
             conn = mysql.connector.connect(**conn_params)
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR
                 # Get EXPLAIN output
                 cur.execute(f"EXPLAIN FORMAT=TREE {sql}")
                 explain_result = cur.fetchall()

mcp_dbutils/mysql/server.py

@@ -49,7 +49,7 @@ class MySQLServer(ConnectionServer):
         """列出所有表资源"""
         try:
             conn = self.pool.get_connection()
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR - dictionary参数是正确的，用于返回字典格式的结果
                 cur.execute("""
                     SELECT 
                         table_name,
@@ -78,7 +78,7 @@ class MySQLServer(ConnectionServer):
         try:
             table_name = uri.split('/')[-2]
             conn = self.pool.get_connection()
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR - dictionary参数是正确的，用于返回字典格式的结果
                 # 获取列信息
                 cur.execute("""
                     SELECT 
@@ -170,7 +170,7 @@ class MySQLServer(ConnectionServer):
                 conn = self.pool.get_connection()
 
             self.log("info", f"执行查询: {sql}")
-            with conn.cursor(dictionary=True) as cur:
+            with conn.cursor(dictionary=True) as cur:  # NOSONAR - dictionary参数是正确的，用于返回字典格式的结果
                 # 设置只读事务
                 cur.execute("SET TRANSACTION READ ONLY")
                 try:

mcp_dbutils/sqlite/handler.py

@@ -142,7 +142,7 @@ class SQLiteHandler(ConnectionHandler):
             with sqlite3.connect(self.config.path) as conn:
                 cur = conn.cursor()
                 # SQLite provides the complete CREATE statement
-                cur.execute(f"SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+                cur.execute("SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
                 result = cur.fetchone()
                 
                 if not result:
@@ -151,7 +151,7 @@ class SQLiteHandler(ConnectionHandler):
                 ddl = result[0]
                 
                 # Get indexes
-                cur.execute(f"SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name=?", (table_name,))
+                cur.execute("SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name=?", (table_name,))
                 indexes = cur.fetchall()
                 
                 # Add index definitions
@@ -234,9 +234,9 @@ class SQLiteHandler(ConnectionHandler):
                 indexes = cur.fetchall()
                 
                 # Get page count and size
-                cur.execute(f"PRAGMA page_count")
+                cur.execute("PRAGMA page_count")
                 page_count = cur.fetchone()[0]
-                cur.execute(f"PRAGMA page_size")
+                cur.execute("PRAGMA page_size")
                 page_size = cur.fetchone()[0]
                 
                 # Calculate total size

mcp_dbutils/sqlite/server.py

@@ -54,7 +54,7 @@ class SQLiteServer(ConnectionServer):
             # 使用默认连接
             conn = self._get_connection()
 
-            with closing(conn) as connection:
+            with closing(conn) as _:
                 cursor = conn.execute(
                     "SELECT name FROM sqlite_master WHERE type='table'"
                 )
@@ -155,7 +155,7 @@ class SQLiteServer(ConnectionServer):
                 # 使用默认连接
                 conn = self._get_connection()
 
-            with closing(conn) as connection:
+            with closing(conn) as _:
                 self.log("info", f"执行查询: {sql}")
                 cursor = conn.execute(sql)
                 results = cursor.fetchall()

{mcp_dbutils-0.15.5.dist-info → mcp_dbutils-0.16.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-dbutils
-Version: 0.15.5
+Version: 0.16.1
 Summary: MCP Database Utilities Service
 Author: Dong Hao
 License-Expression: MIT

{mcp_dbutils-0.15.5.dist-info → mcp_dbutils-0.16.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
 mcp_dbutils/__init__.py,sha256=6LLccQv7je2L4IpY_I3OzSJZcK32VUDJv2IY31y6eYg,1900
-mcp_dbutils/base.py,sha256=d4kt29NQeE7xZ0DlGpJcpBXS1pY1VnY98gX-xJ-Ehpg,29126
+mcp_dbutils/base.py,sha256=9UDhPFpw6YdkUMhAqgGyy6vuXA2C78LIGrWiW0zeB8s,30839
 mcp_dbutils/config.py,sha256=bmXpOd1fyYfoyUS75I035ChT6t3wP5AyEnJ06e2ZS2o,1848
 mcp_dbutils/log.py,sha256=mqxi6I_IL-MF1F_pxBtnYZQKOHbGBJ74gsvZHVelr1w,823
 mcp_dbutils/stats.py,sha256=wMqWPfGnEOg9v5YBtTsARV-1YsFUMM_pKdzitzSU9x4,7137
 mcp_dbutils/mysql/__init__.py,sha256=gNhoHaxK1qhvMAH5AVl1vfV1rUpcbV9KZWUQb41aaQk,129
-mcp_dbutils/mysql/config.py,sha256=Yvdd02ZwPMM7RCjEvjNJphGiUfImI7Q2gcEH6Zi3Vjo,8071
-mcp_dbutils/mysql/handler.py,sha256=CZoce_Fs2YnGKvs6tIc083lRm4vo1cYT9VvsHfU1peI,19738
-mcp_dbutils/mysql/server.py,sha256=81DGLCg7iLR4TgydoQXCHxl-9RxZfv1vYGJmiYqj5sQ,8352
+mcp_dbutils/mysql/config.py,sha256=BTPPFqlhoTp7EBFIeLJZh8x6bCn3q9NivHYz9yZHziw,9820
+mcp_dbutils/mysql/handler.py,sha256=knBoFVYmdse5hsjr4GPi4fZhEaYOPRBPGR2d3w8qqzw,19837
+mcp_dbutils/mysql/server.py,sha256=1bWAu7qHYXVeTZu4wdEpS6gSVB0RoXKI3Smy_ix-y8A,8586
 mcp_dbutils/postgres/__init__.py,sha256=-2zYuEJEQ2AMvmGhH5Z_umerSvt7S4xOa_XV4wgvGfI,154
 mcp_dbutils/postgres/config.py,sha256=NyQOVhkXJ1S-JD0w-ePNjTKI1Ja-aZQkDUdHi6U7Vl4,7752
 mcp_dbutils/postgres/handler.py,sha256=ppltSKtSk-BlPpp3iEVJlmoyl4AmqKcQHx_0zHlz03Y,24403
 mcp_dbutils/postgres/server.py,sha256=_CiJC9PitpI1NB99Q1Bcs5TYADNgDpYMwv88fRHQunE,8640
 mcp_dbutils/sqlite/__init__.py,sha256=fK_3-WylCBYpBAzwuopi8hlwoIGJm2TPAlwcPWG46I0,134
 mcp_dbutils/sqlite/config.py,sha256=j67TJ8mQJ2D886MthSa-zYMtvUUYyyxYLMlNxkYoqZE,4509
-mcp_dbutils/sqlite/handler.py,sha256=T5atpRn71IwlTyPKhdpQsGIJb16716SKLBplsl9Wv50,17750
-mcp_dbutils/sqlite/server.py,sha256=3W0kB1mrVzcfMjVG3dkmt1R4Mh4lbiXkQsXon7e4i1U,7199
-mcp_dbutils-0.15.5.dist-info/METADATA,sha256=uvE4CSd5JTQfqQRDmzYi-fAZrTx0F-b7_B0EyJo_9C0,16714
-mcp_dbutils-0.15.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_dbutils-0.15.5.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
-mcp_dbutils-0.15.5.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
-mcp_dbutils-0.15.5.dist-info/RECORD,,
+mcp_dbutils/sqlite/handler.py,sha256=25zqoQpMhRNKeO3MH2a0E5dO3-4A8sPb7q87cn7Cs0E,17746
+mcp_dbutils/sqlite/server.py,sha256=jqpE8d9vJETMs5xYGB7P0tvNDPes6Yn5ZM_iCCF7Tv4,7181
+mcp_dbutils-0.16.1.dist-info/METADATA,sha256=mjE8oqdIRiIdiRlyWufFfxWGoHT8aGIoSaVTEuFlkJs,16714
+mcp_dbutils-0.16.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_dbutils-0.16.1.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
+mcp_dbutils-0.16.1.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
+mcp_dbutils-0.16.1.dist-info/RECORD,,