mcp-dbutils 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

mcp_dbutils/postgres/server.py

@@ -4,14 +4,14 @@ from psycopg2.pool import SimpleConnectionPool
 from typing import Optional, List
 import mcp.types as types
 from importlib.metadata import metadata
-from ..base import DatabaseServer
+from ..base import ConnectionServer
 from ..log import create_logger
-from .config import PostgresConfig
+from .config import PostgreSQLConfig
 
 # 获取包信息用于日志命名
 pkg_meta = metadata("mcp-dbutils")
-class PostgresServer(DatabaseServer):
-    def __init__(self, config: PostgresConfig, config_path: Optional[str] = None):
+class PostgreSQLServer(ConnectionServer):
+    def __init__(self, config: PostgreSQLConfig, config_path: Optional[str] = None):
         """初始化PostgreSQL服务器
         Args:
             config: 数据库配置
@@ -32,9 +32,9 @@ class PostgresServer(DatabaseServer):
             self.log("info", "测试连接成功")
             # 创建连接池
             self.pool = SimpleConnectionPool(1, 5, **conn_params)
-            self.log("info", "数据库连接池创建成功")
+            self.log("info", "连接池创建成功")
         except psycopg2.Error as e:
-            self.log("error", f"数据库连接失败: [Code: {e.pgcode}] {e.pgerror or str(e)}")
+            self.log("error", f"连接失败: [Code: {e.pgcode}] {e.pgerror or str(e)}")
             raise
     async def list_resources(self) -> list[types.Resource]:
         """列出所有表资源"""
@@ -124,9 +124,9 @@ class PostgresServer(DatabaseServer):
                 inputSchema={
                     "type": "object",
                     "properties": {
-                        "database": {
+                        "connection": {
                             "type": "string",
-                            "description": "数据库配置名称（可选）"
+                            "description": "数据库连接名称（可选）"
                         },
                         "sql": {
                             "type": "string",
@@ -147,16 +147,16 @@ class PostgresServer(DatabaseServer):
         # 仅允许SELECT语句
         if not sql.lower().startswith("select"):
             raise ValueError("仅支持SELECT查询")
-        database = arguments.get("database")
+        connection = arguments.get("connection")
         use_pool = True
         conn = None
         try:
-            if database and self.config_path:
-                # 使用指定的数据库配置
-                config = PostgresConfig.from_yaml(self.config_path, database)
+            if connection and self.config_path:
+                # 使用指定的数据库连接
+                config = PostgreSQLConfig.from_yaml(self.config_path, connection)
                 conn_params = config.get_connection_params()
                 masked_params = config.get_masked_connection_info()
-                self.log("info", f"使用配置 {database} 连接数据库: {masked_params}")
+                self.log("info", f"使用配置 {connection} 连接数据库: {masked_params}")
                 conn = psycopg2.connect(**conn_params)
                 use_pool = False
             else:
@@ -173,7 +173,7 @@ class PostgresServer(DatabaseServer):
                     formatted_results = [dict(zip(columns, row)) for row in results]
                     result_text = str({
                         'type': 'postgres',
-                        'config_name': database or 'default',
+                        'config_name': connection or 'default',
                         'query_result': {
                             'columns': columns,
                             'rows': formatted_results,
@@ -191,7 +191,7 @@ class PostgresServer(DatabaseServer):
                 error = f"查询执行失败: {str(e)}"
             error_msg = str({
                 'type': 'postgres',
-                'config_name': database or 'default',
+                'config_name': connection or 'default',
                 'error': error
             })
             self.log("error", error_msg)
@@ -205,5 +205,5 @@ class PostgresServer(DatabaseServer):
     async def cleanup(self):
         """清理资源"""
         if hasattr(self, 'pool'):
-            self.log("info", "关闭数据库连接池")
+            self.log("info", "关闭连接池")
             self.pool.closeall()

mcp_dbutils/sqlite/__init__.py

@@ -1,6 +1,6 @@
 """SQLite module"""
 
-from .handler import SqliteHandler
-from .config import SqliteConfig
+from .handler import SQLiteHandler
+from .config import SQLiteConfig
 
-__all__ = ['SqliteHandler', 'SqliteConfig']
+__all__ = ['SQLiteHandler', 'SQLiteConfig']

mcp_dbutils/sqlite/config.py

@@ -4,13 +4,13 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, Any, Optional, Literal
 from urllib.parse import urlparse, parse_qs
-from ..config import DatabaseConfig
+from ..config import ConnectionConfig
 
 def parse_jdbc_url(jdbc_url: str) -> Dict[str, str]:
     """Parse JDBC URL into connection parameters
 
     Args:
-        jdbc_url: JDBC URL (e.g. jdbc:sqlite:file:/path/to/database.db or jdbc:sqlite:/path/to/database.db)
+        jdbc_url: JDBC URL (e.g. jdbc:sqlite:file:/path/to/sqlite.db or jdbc:sqlite:/path/to/sqlite.db)
 
     Returns:
         Dictionary of connection parameters
@@ -40,7 +40,7 @@ def parse_jdbc_url(jdbc_url: str) -> Dict[str, str]:
             params[key] = values[0]
 
     if not path:
-        raise ValueError("Database path must be specified in URL")
+        raise ValueError("SQLite file path must be specified in URL")
 
     return {
         'path': path,
@@ -48,22 +48,22 @@ def parse_jdbc_url(jdbc_url: str) -> Dict[str, str]:
     }
 
 @dataclass
-class SqliteConfig(DatabaseConfig):
+class SQLiteConfig(ConnectionConfig):
     path: str
     password: Optional[str] = None
     uri: bool = True  # Enable URI mode to support parameters like password
     type: Literal['sqlite'] = 'sqlite'
 
     @classmethod
-    def from_jdbc_url(cls, jdbc_url: str, password: Optional[str] = None) -> 'SqliteConfig':
+    def from_jdbc_url(cls, jdbc_url: str, password: Optional[str] = None) -> 'SQLiteConfig':
         """Create configuration from JDBC URL
 
         Args:
-            jdbc_url: JDBC URL (e.g. jdbc:sqlite:file:/path/to/database.db)
+            jdbc_url: JDBC URL (e.g. jdbc:sqlite:file:/path/to/sqlite.db)
             password: Optional password for database encryption
 
         Returns:
-            SqliteConfig instance
+            SQLiteConfig instance
 
         Raises:
             ValueError: If URL format is invalid
@@ -80,7 +80,7 @@ class SqliteConfig(DatabaseConfig):
 
     @property
     def absolute_path(self) -> str:
-        """Return absolute path to database file"""
+        """Return absolute path to SQLite database file"""
         return str(Path(self.path).expanduser().resolve())
 
     def get_connection_params(self) -> Dict[str, Any]:
@@ -109,23 +109,23 @@ class SqliteConfig(DatabaseConfig):
         return info
 
     @classmethod
-    def from_yaml(cls, yaml_path: str, db_name: str, **kwargs) -> 'SqliteConfig':
+    def from_yaml(cls, yaml_path: str, db_name: str, **kwargs) -> 'SQLiteConfig':
         """Create SQLite configuration from YAML
 
         Args:
             yaml_path: Path to YAML configuration file
-            db_name: Database configuration name
+            db_name: Connection configuration name
         """
         configs = cls.load_yaml_config(yaml_path)
 
         if db_name not in configs:
             available_dbs = list(configs.keys())
-            raise ValueError(f"Database configuration not found: {db_name}. Available configurations: {available_dbs}")
+            raise ValueError(f"Connection configuration not found: {db_name}. Available configurations: {available_dbs}")
 
         db_config = configs[db_name]
 
         if 'type' not in db_config:
-            raise ValueError("Database configuration must include 'type' field")
+            raise ValueError("Connection configuration must include 'type' field")
         if db_config['type'] != 'sqlite':
             raise ValueError(f"Configuration is not SQLite type: {db_config['type']}")