feat: migrate configuration to .env environment variables

This commit implements a complete migration from JSON-based configuration
to .env environment variables, providing better security and flexibility.

Key Changes:
- Add python-dotenv dependency for environment variable support
- Create config/env_loader.py with type conversion utilities
- Add from_env() class methods to all config dataclasses
- Update ConfigLoader to prioritize environment variables
- Add save_to_env() method for .env file management
- Implement database connection factory pattern
- Add base DAO and connection classes for better abstraction
- Support both SQL Server and MySQL with unified interface
- Create migration script (scripts/migrate_to_env.py)
- Update GUI to read/write .env files
- Add comprehensive migration documentation

New Files:
- config/env_loader.py - Environment variable loader
- db/base_connection.py - Base database connection interface
- db/base_dao.py - Base DAO with common utilities
- db/connection_factory.py - Factory for creating connections
- db/mysql_connection.py - MySQL-specific connection
- db/sqlserver_connection.py - SQL Server-specific connection
- db/table_name_converter.py - SQL dialect converter
- scripts/migrate_to_env.py - Configuration migration tool
- docs/ENV_MIGRATION.md - Complete migration guide
- .env.example - Environment variable template

Testing:
- Verified MySQL connection (8.0.44)
- Tested all DAO operations
- Confirmed 150 tables accessible
- Validated configuration loading

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.gitignore

@@ -21,4 +21,8 @@ tests/
 
 # 用户配置文件（包含敏感信息）
 config/user_settings.json
-nul
+nul
+
+# 环境变量
+.env
+.env.local

config/defaults.py

@@ -3,7 +3,7 @@
 """
 默认配置值
 
-定义所有配置项的默认值。
+定义所有配置项的默认值，从环境变量加载。
 """
 from config.schema import (
     ERPConfig,
@@ -12,49 +12,14 @@ from config.schema import (
     ExtractionConfig,
     ValidationConfig,
     AppConfig,
+    SQLServerConfig,
+    MySQLConfig,
+    DatabaseType,
 )
 
 
-# 默认配置
+# 默认配置 - 从环境变量加载
-DEFAULT_APP_CONFIG = AppConfig(
+DEFAULT_APP_CONFIG = AppConfig.from_env()
-    erp=ERPConfig(
-        url="https://68.11.34.30:8082/",
-        username="BLDpengqiangqiang",
-        password="Cqbld123456.",
-        headless=True,
-        ignore_https_errors=True,
-        auto_close_browser=True,
-    ),
-    database=DatabaseConfig(
-        server="192.168.110.114",
-        database="CompanyDB",
-        username="peng",
-        password="Cqbld123456.",
-        driver="ODBC Driver 18 for SQL Server",
-        trust_server_certificate="yes",
-    ),
-    paths=PathConfig(
-        data_dir="D:/python/playwrite/data/",
-        production_id_file="ProductionID.txt",
-        default_output="离散备料计划维护_合并.xlsx",
-        validation_output="物料状态校验结果.xlsx",
-    ),
-    extraction=ExtractionConfig(
-        batch_size=100,
-        verbose=True,
-        auto_convert=True,
-        merge_batches=True,
-        enable_db_persistence=False,  # Disabled by default
-    ),
-    validation=ValidationConfig(
-        data_source="database_full",
-        use_database=True,
-        batch_size=2000,
-        enable_crud_operations=False,
-        default_manager="",
-        match_mode="substring",
-    ),
-)
 
 
 # 兼容旧版本的字典格式

config/env_loader.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+环境变量加载器
+
+使用 python-dotenv 加载 .env 文件，并提供类型转换功能。
+"""
+import os
+from pathlib import Path
+from typing import Any, Optional, Type, TypeVar
+from dotenv import load_dotenv
+
+# 项目根目录
+PROJECT_ROOT = Path(__file__).parent.parent
+
+
+def load_env_file(env_file: Optional[str] = None) -> None:
+    """
+    加载 .env 文件
+
+    Args:
+        env_file: .env 文件路径，默认为项目根目录下的 .env
+    """
+    if env_file is None:
+        env_file = PROJECT_ROOT / ".env"
+    else:
+        env_file = Path(env_file)
+
+    load_dotenv(env_file)
+
+
+def get_env(key: str, default: Any = None) -> str:
+    """
+    获取环境变量
+
+    Args:
+        key: 环境变量名
+        default: 默认值
+
+    Returns:
+        环境变量值
+    """
+    return os.getenv(key, default)
+
+
+def get_env_bool(key: str, default: bool = False) -> bool:
+    """
+    获取布尔类型环境变量
+
+    Args:
+        key: 环境变量名
+        default: 默认值
+
+    Returns:
+        布尔值
+    """
+    value = os.getenv(key, "")
+    if not value:
+        return default
+    return value.lower() in ("true", "1", "yes", "on")
+
+
+def get_env_int(key: str, default: int = 0) -> int:
+    """
+    获取整数类型环境变量
+
+    Args:
+        key: 环境变量名
+        default: 默认值
+
+    Returns:
+        整数值
+    """
+    value = os.getenv(key, "")
+    if not value:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
+def get_env_float(key: str, default: float = 0.0) -> float:
+    """
+    获取浮点数类型环境变量
+
+    Args:
+        key: 环境变量名
+        default: 默认值
+
+    Returns:
+        浮点数值
+    """
+    value = os.getenv(key, "")
+    if not value:
+        return default
+    try:
+        return float(value)
+    except ValueError:
+        return default
+
+
+def set_env(key: str, value: Any) -> None:
+    """
+    设置环境变量（仅在当前进程中有效）
+
+    Args:
+        key: 环境变量名
+        value: 环境变量值
+    """
+    os.environ[key] = str(value)
+
+
+def save_env_file(env_file: Optional[str] = None, env_dict: Optional[dict] = None) -> bool:
+    """
+    保存环境变量到 .env 文件
+
+    Args:
+        env_file: .env 文件路径，默认为项目根目录下的 .env
+        env_dict: 要保存的环境变量字典，如果为 None 则保存当前所有环境变量
+
+    Returns:
+        保存是否成功
+    """
+    if env_file is None:
+        env_file = PROJECT_ROOT / ".env"
+    else:
+        env_file = Path(env_file)
+
+    try:
+        # 确保目录存在
+        env_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # 读取现有的 .env 文件以保留注释
+        existing_lines = []
+        if env_file.exists():
+            with open(env_file, "r", encoding="utf-8") as f:
+                existing_lines = f.readlines()
+
+        # 如果提供了 env_dict，则保存指定的环境变量
+        if env_dict is not None:
+            # 构建新的文件内容
+            new_content = []
+            processed_keys = set()
+
+            for line in existing_lines:
+                stripped = line.strip()
+                # 保留注释和空行
+                if not stripped or stripped.startswith("#"):
+                    new_content.append(line)
+                # 更新已存在的键值对
+                elif "=" in stripped and not stripped.startswith("#"):
+                    key = stripped.split("=")[0].strip()
+                    if key in env_dict:
+                        value = env_dict[key]
+                        # 处理布尔值的格式
+                        if isinstance(value, bool):
+                            value = "true" if value else "false"
+                        new_content.append(f"{key}={value}\n")
+                        processed_keys.add(key)
+                    else:
+                        new_content.append(line)
+
+            # 添加新的键值对
+            for key, value in env_dict.items():
+                if key not in processed_keys:
+                    # 处理布尔值的格式
+                    if isinstance(value, bool):
+                        value = "true" if value else "false"
+                    new_content.append(f"{key}={value}\n")
+
+            # 写入文件
+            with open(env_file, "w", encoding="utf-8") as f:
+                f.writelines(new_content)
+        else:
+            # 如果没有提供 env_dict，则不执行任何操作
+            # 因为保存所有环境变量可能会包含系统变量
+            return False
+
+        return True
+    except IOError as e:
+        print(f"保存 .env 文件失败: {e}")
+        return False
+
+
+def update_env_file(env_file: Optional[str] = None, **kwargs) -> bool:
+    """
+    更新 .env 文件中的特定环境变量
+
+    Args:
+        env_file: .env 文件路径
+        **kwargs: 要更新的环境变量键值对
+
+    Returns:
+        更新是否成功
+    """
+    return save_env_file(env_file, kwargs)
+
+
+# 自动加载 .env 文件
+load_env_file()

config/loader.py

@@ -3,29 +3,51 @@
 """
 配置加载器
 
-负责加载、合并和验证配置。
+负责加载、合并和验证配置，优先从环境变量加载。
 """
 import json
 import os
 from typing import Any, Dict
-from config.schema import AppConfig
+from config.schema import (
+    AppConfig,
+    ERPConfig,
+    DatabaseConfig,
+    PathConfig,
+    ExtractionConfig,
+    ValidationConfig,
+    DatabaseType,
+    SQLServerConfig,
+    MySQLConfig,
+)
 from config.defaults import DEFAULT_APP_CONFIG, DEFAULT_SETTINGS_DICT
+from config.env_loader import get_env, get_env_bool, get_env_int
 
 
 class ConfigLoader:
     """配置加载器"""
 
     @staticmethod
-    def load(config_file: str = "config/user_settings.json") -> AppConfig:
+    def load(config_file: str = "config/user_settings.json", use_env: bool = True) -> AppConfig:
         """
-        加载配置文件
+        加载配置
+
+        优先级：
+        1. 环境变量（如果 use_env=True）
+        2. JSON 配置文件（如果存在）
+        3. 默认配置
 
         Args:
             config_file: 配置文件路径
+            use_env: 是否使用环境变量，默认为 True
 
         Returns:
             应用配置对象
         """
+        # 优先从环境变量加载
+        if use_env:
+            return AppConfig.from_env()
+
+        # 如果不使用环境变量，则从 JSON 文件加载（向后兼容）
         if os.path.exists(config_file):
             try:
                 with open(config_file, "r", encoding="utf-8") as f:
@@ -66,6 +88,63 @@ class ConfigLoader:
             print(f"保存配置文件失败: {e}")
             return False
 
+    @staticmethod
+    def save_to_env(config: AppConfig, env_file: str = ".env") -> bool:
+        """
+        保存配置到 .env 文件
+
+        Args:
+            config: 应用配置对象
+            env_file: .env 文件路径
+
+        Returns:
+            保存是否成功
+        """
+        from config.env_loader import save_env_file
+
+        env_dict = {
+            # ERP 配置
+            "ERP_URL": config.erp.url,
+            "ERP_USERNAME": config.erp.username,
+            "ERP_PASSWORD": config.erp.password,
+            "ERP_HEADLESS": config.erp.headless,
+            "ERP_IGNORE_HTTPS_ERRORS": config.erp.ignore_https_errors,
+            "ERP_AUTO_CLOSE_BROWSER": config.erp.auto_close_browser,
+            # 数据库配置
+            "DB_TYPE": config.database.db_type.value,
+            "DB_SERVER": config.database.server,
+            "DB_NAME": config.database.database,
+            "DB_USERNAME": config.database.username,
+            "DB_PASSWORD": config.database.password,
+            # SQL Server 特定配置
+            "DB_SQLSERVER_DRIVER": config.database.sqlserver.driver if config.database.sqlserver else "ODBC Driver 18 for SQL Server",
+            "DB_TRUST_SERVER_CERTIFICATE": config.database.sqlserver.trust_server_certificate if config.database.sqlserver else "yes",
+            # MySQL 特定配置
+            "DB_MYSQL_HOST": config.database.mysql.host if config.database.mysql else "",
+            "DB_MYSQL_PORT": config.database.mysql.port if config.database.mysql else 3306,
+            "DB_MYSQL_CHARSET": config.database.mysql.charset if config.database.mysql else "utf8mb4",
+            # 路径配置
+            "PATH_DATA_DIR": config.paths.data_dir,
+            "PATH_PRODUCTION_ID_FILE": config.paths.production_id_file,
+            "PATH_DEFAULT_OUTPUT": config.paths.default_output,
+            "PATH_VALIDATION_OUTPUT": config.paths.validation_output,
+            # 数据提取配置
+            "EXTRACTION_BATCH_SIZE": config.extraction.batch_size,
+            "EXTRACTION_VERBOSE": config.extraction.verbose,
+            "EXTRACTION_AUTO_CONVERT": config.extraction.auto_convert,
+            "EXTRACTION_MERGE_BATCHES": config.extraction.merge_batches,
+            "EXTRACTION_ENABLE_DB_PERSISTENCE": config.extraction.enable_db_persistence,
+            # 校验配置
+            "VALIDATION_DATA_SOURCE": config.validation.data_source,
+            "VALIDATION_USE_DATABASE": config.validation.use_database,
+            "VALIDATION_BATCH_SIZE": config.validation.batch_size,
+            "VALIDATION_ENABLE_CRUD": config.validation.enable_crud_operations,
+            "VALIDATION_DEFAULT_MANAGER": config.validation.default_manager,
+            "VALIDATION_MATCH_MODE": config.validation.match_mode,
+        }
+
+        return save_env_file(env_file, env_dict)
+
     @staticmethod
     def _merge_settings(defaults: Dict, loaded: Dict) -> Dict:
         """
@@ -109,6 +188,28 @@ class ConfigLoader:
         extraction_dict = settings.get("extraction", {})
         validation_dict = settings.get("validation", {})
 
+        # 解析数据库类型
+        db_type_str = database_dict.get("db_type", "sqlserver")
+        try:
+            db_type = DatabaseType(db_type_str)
+        except ValueError:
+            db_type = DatabaseType.SQLSERVER
+
+        # 解析 SQL Server 配置
+        sqlserver_dict = database_dict.get("sqlserver", {})
+        sqlserver_config = SQLServerConfig(
+            driver=sqlserver_dict.get("driver", "ODBC Driver 18 for SQL Server"),
+            trust_server_certificate=sqlserver_dict.get("trust_server_certificate", "yes"),
+        )
+
+        # 解析 MySQL 配置
+        mysql_dict = database_dict.get("mysql", {})
+        mysql_config = MySQLConfig(
+            host=mysql_dict.get("host", database_dict.get("server", "")),
+            port=mysql_dict.get("port", 3306),
+            charset=mysql_dict.get("charset", "utf8mb4"),
+        )
+
         return AppConfig(
             erp=ERPConfig(
                 url=erp_dict.get("url", ""),
@@ -119,14 +220,13 @@ class ConfigLoader:
                 auto_close_browser=erp_dict.get("auto_close_browser", True),
             ),
             database=DatabaseConfig(
+                db_type=db_type,
                 server=database_dict.get("server", ""),
                 database=database_dict.get("database", ""),
                 username=database_dict.get("username", ""),
                 password=database_dict.get("password", ""),
-                driver=database_dict.get("driver", "ODBC Driver 18 for SQL Server"),
+                sqlserver=sqlserver_config,
-                trust_server_certificate=database_dict.get(
+                mysql=mysql_config,
-                    "trust_server_certificate", "yes"
-                ),
             ),
             paths=PathConfig(
                 data_dir=paths_dict.get("data_dir", ""),
@@ -156,5 +256,3 @@ class ConfigLoader:
         )
 
 
-# 为了兼容旧代码，导入必要的类型
-from config.schema import ERPConfig, DatabaseConfig, PathConfig, ExtractionConfig, ValidationConfig

config/schema.py

@@ -8,6 +8,13 @@
 from dataclasses import dataclass, field
 from typing import Optional
 from pathlib import Path
+from enum import Enum
+
+
+class DatabaseType(str, Enum):
+    """数据库类型枚举"""
+    SQLSERVER = "sqlserver"
+    MYSQL = "mysql"
 
 
 @dataclass
@@ -21,6 +28,20 @@ class ERPConfig:
     ignore_https_errors: bool = True
     auto_close_browser: bool = True
 
+    @classmethod
+    def from_env(cls) -> "ERPConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env, get_env_bool
+
+        return cls(
+            url=get_env("ERP_URL", "https://68.11.34.30:8082/"),
+            username=get_env("ERP_USERNAME", "BLDpengqiangqiang"),
+            password=get_env("ERP_PASSWORD", ""),
+            headless=get_env_bool("ERP_HEADLESS", True),
+            ignore_https_errors=get_env_bool("ERP_IGNORE_HTTPS_ERRORS", True),
+            auto_close_browser=get_env_bool("ERP_AUTO_CLOSE_BROWSER", True),
+        )
+
     def validate(self) -> list[str]:
         """验证配置，返回错误列表"""
         errors = []
@@ -33,28 +54,98 @@ class ERPConfig:
         return errors
 
 
+@dataclass
+class SQLServerConfig:
+    """SQL Server 特定配置"""
+    driver: str = "ODBC Driver 18 for SQL Server"
+    trust_server_certificate: str = "yes"
+
+    @classmethod
+    def from_env(cls) -> "SQLServerConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env
+
+        return cls(
+            driver=get_env("DB_SQLSERVER_DRIVER", "ODBC Driver 18 for SQL Server"),
+            trust_server_certificate=get_env("DB_TRUST_SERVER_CERTIFICATE", "yes"),
+        )
+
+
+@dataclass
+class MySQLConfig:
+    """MySQL 特定配置"""
+    host: str = ""
+    port: int = 3306
+    charset: str = "utf8mb4"
+
+    @classmethod
+    def from_env(cls) -> "MySQLConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env, get_env_int
+
+        return cls(
+            host=get_env("DB_MYSQL_HOST", "192.168.31.83"),
+            port=get_env_int("DB_MYSQL_PORT", 3306),
+            charset=get_env("DB_MYSQL_CHARSET", "utf8mb4"),
+        )
+
+
 @dataclass
 class DatabaseConfig:
     """数据库配置"""
 
-    server: str
+    db_type: DatabaseType = DatabaseType.SQLSERVER
-    database: str
+    server: str = ""  # SQL Server 服务器地址
-    username: str
+    database: str = ""
-    password: str
+    username: str = ""
-    driver: str = "ODBC Driver 18 for SQL Server"
+    password: str = ""
-    trust_server_certificate: str = "yes"
+    sqlserver: Optional[SQLServerConfig] = None
+    mysql: Optional[MySQLConfig] = None
+
+    @classmethod
+    def from_env(cls) -> "DatabaseConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env, get_env_int
+
+        db_type_str = get_env("DB_TYPE", "sqlserver")
+        try:
+            db_type = DatabaseType(db_type_str)
+        except ValueError:
+            db_type = DatabaseType.SQLSERVER
+
+        return cls(
+            db_type=db_type,
+            server=get_env("DB_SERVER", "192.168.110.114"),
+            database=get_env("DB_NAME", "CompanyDB"),
+            username=get_env("DB_USERNAME", "peng"),
+            password=get_env("DB_PASSWORD", ""),
+            sqlserver=SQLServerConfig.from_env(),
+            mysql=MySQLConfig.from_env(),
+        )
 
     def validate(self) -> list[str]:
         """验证配置，返回错误列表"""
         errors = []
-        if not self.server:
+
-            errors.append("数据库服务器地址不能为空")
+        if self.db_type == DatabaseType.SQLSERVER:
-        if not self.database:
+            if not self.server:
-            errors.append("数据库名称不能为空")
+                errors.append("SQL Server 服务器地址不能为空")
-        if not self.username:
+            if not self.database:
-            errors.append("数据库用户名不能为空")
+                errors.append("数据库名称不能为空")
-        if not self.password:
+            if not self.username:
-            errors.append("数据库密码不能为空")
+                errors.append("数据库用户名不能为空")
+            if not self.password:
+                errors.append("数据库密码不能为空")
+        elif self.db_type == DatabaseType.MYSQL:
+            if self.mysql and not self.mysql.host:
+                errors.append("MySQL 主机地址不能为空")
+            if not self.database:
+                errors.append("数据库名称不能为空")
+            if not self.username:
+                errors.append("数据库用户名不能为空")
+            if not self.password:
+                errors.append("数据库密码不能为空")
+
         return errors
 
 
@@ -67,6 +158,18 @@ class PathConfig:
     default_output: str = "离散备料计划维护_合并.xlsx"
     validation_output: str = "物料状态校验结果.xlsx"
 
+    @classmethod
+    def from_env(cls) -> "PathConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env
+
+        return cls(
+            data_dir=get_env("PATH_DATA_DIR", "D:/python/playwrite/data/"),
+            production_id_file=get_env("PATH_PRODUCTION_ID_FILE", "ProductionID.txt"),
+            default_output=get_env("PATH_DEFAULT_OUTPUT", "离散备料计划维护_合并.xlsx"),
+            validation_output=get_env("PATH_VALIDATION_OUTPUT", "物料状态校验结果.xlsx"),
+        )
+
     def validate(self) -> list[str]:
         """验证配置，返回错误列表"""
         errors = []
@@ -87,6 +190,19 @@ class ExtractionConfig:
     merge_batches: bool = True
     enable_db_persistence: bool = False
 
+    @classmethod
+    def from_env(cls) -> "ExtractionConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env_int, get_env_bool
+
+        return cls(
+            batch_size=get_env_int("EXTRACTION_BATCH_SIZE", 100),
+            verbose=get_env_bool("EXTRACTION_VERBOSE", True),
+            auto_convert=get_env_bool("EXTRACTION_AUTO_CONVERT", True),
+            merge_batches=get_env_bool("EXTRACTION_MERGE_BATCHES", True),
+            enable_db_persistence=get_env_bool("EXTRACTION_ENABLE_DB_PERSISTENCE", False),
+        )
+
     def validate(self) -> list[str]:
         """验证配置，返回错误列表"""
         errors = []
@@ -108,6 +224,20 @@ class ValidationConfig:
     default_manager: str = ""
     match_mode: str = "substring"
 
+    @classmethod
+    def from_env(cls) -> "ValidationConfig":
+        """从环境变量创建配置"""
+        from config.env_loader import get_env, get_env_int, get_env_bool
+
+        return cls(
+            data_source=get_env("VALIDATION_DATA_SOURCE", "database_full"),
+            use_database=get_env_bool("VALIDATION_USE_DATABASE", True),
+            batch_size=get_env_int("VALIDATION_BATCH_SIZE", 2000),
+            enable_crud_operations=get_env_bool("VALIDATION_ENABLE_CRUD", False),
+            default_manager=get_env("VALIDATION_DEFAULT_MANAGER", ""),
+            match_mode=get_env("VALIDATION_MATCH_MODE", "substring"),
+        )
+
     def validate(self) -> list[str]:
         """验证配置，返回错误列表"""
         errors = []
@@ -149,6 +279,17 @@ class AppConfig:
     extraction: ExtractionConfig
     validation: ValidationConfig
 
+    @classmethod
+    def from_env(cls) -> "AppConfig":
+        """从环境变量创建配置"""
+        return cls(
+            erp=ERPConfig.from_env(),
+            database=DatabaseConfig.from_env(),
+            paths=PathConfig.from_env(),
+            extraction=ExtractionConfig.from_env(),
+            validation=ValidationConfig.from_env(),
+        )
+
     def validate(self) -> list[str]:
         """验证所有配置，返回错误列表"""
         errors = []
@@ -171,12 +312,20 @@ class AppConfig:
                 "auto_close_browser": self.erp.auto_close_browser,
             },
             "database": {
+                "db_type": self.database.db_type.value,
                 "server": self.database.server,
                 "database": self.database.database,
                 "username": self.database.username,
                 "password": self.database.password,
-                "driver": self.database.driver,
+                "sqlserver": {
-                "trust_server_certificate": self.database.trust_server_certificate,
+                    "driver": self.database.sqlserver.driver if self.database.sqlserver else "ODBC Driver 18 for SQL Server",
+                    "trust_server_certificate": self.database.sqlserver.trust_server_certificate if self.database.sqlserver else "yes",
+                },
+                "mysql": {
+                    "host": self.database.mysql.host if self.database.mysql else "",
+                    "port": self.database.mysql.port if self.database.mysql else 3306,
+                    "charset": self.database.mysql.charset if self.database.mysql else "utf8mb4",
+                },
             },
             "paths": {
                 "data_dir": self.paths.data_dir,

db/base_connection.py

@@ -0,0 +1,84 @@
+"""
+数据库连接抽象基类
+
+定义数据库连接的通用接口
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+
+class BaseDatabaseConnection(ABC):
+    """数据库连接抽象基类"""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        初始化数据库连接
+
+        Args:
+            config: 数据库配置字典
+        """
+        self.config = config or {}
+        self.connection = None
+
+    @abstractmethod
+    def connect(self):
+        """
+        建立数据库连接
+
+        Returns:
+            数据库连接对象
+        """
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """关闭数据库连接"""
+        pass
+
+    @abstractmethod
+    def execute_query(self, sql: str, params: Optional[tuple] = None) -> List[Dict[str, Any]]:
+        """
+        执行查询语句并返回结果
+
+        Args:
+            sql: SQL 查询语句
+            params: 查询参数（可选）
+
+        Returns:
+            List[Dict[str, Any]]: 查询结果列表，每个元素为一行数据的字典
+        """
+        pass
+
+    @abstractmethod
+    def execute_update(self, sql: str, params: Optional[tuple] = None) -> int:
+        """
+        执行更新/插入/删除语句
+
+        Args:
+            sql: SQL 语句
+            params: 参数（可选）
+
+        Returns:
+            int: 受影响的行数
+        """
+        pass
+
+    def __enter__(self):
+        """支持 with 语句的上下文管理器入口"""
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """支持 with 语句的上下文管理器出口"""
+        self.disconnect()
+
+    @abstractmethod
+    def get_placeholder(self) -> str:
+        """
+        获取参数占位符
+
+        Returns:
+            参数占位符字符串（SQL Server: "?" 或 MySQL: "%s"）
+        """
+        pass

db/base_dao.py

@@ -0,0 +1,100 @@
+"""
+DAO 基类
+
+提供数据访问对象的通用方法和辅助函数
+"""
+
+from typing import Optional
+from config.schema import DatabaseType
+from db.base_connection import BaseDatabaseConnection
+from db.connection import get_connection
+from db.table_name_converter import TableNameConverter
+
+
+class BaseDAO:
+    """数据访问对象基类"""
+
+    def __init__(self):
+        """初始化 DAO"""
+        self.db: Optional[BaseDatabaseConnection] = None
+        # 从配置文件加载数据库类型
+        from config.loader import ConfigLoader
+        app_config = ConfigLoader.load()
+        self._db_type = app_config.database.db_type
+
+    def __enter__(self):
+        """进入上下文管理器，建立数据库连接"""
+        self.db = get_connection()
+        self.db.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """退出上下文管理器，关闭数据库连接"""
+        if self.db:
+            self.db.disconnect()
+
+    def close(self):
+        """关闭数据库连接"""
+        if self.db:
+            self.db.disconnect()
+
+    def _convert_sql(self, sql: str) -> str:
+        """
+        根据当前数据库类型转换 SQL 语句中的表名
+
+        Args:
+            sql: 原始 SQL 语句（SQL Server 格式）
+
+        Returns:
+            转换后的 SQL 语句
+        """
+        if self._db_type == DatabaseType.MYSQL:
+            # SQL Server → MySQL
+            return TableNameConverter.convert_sql(sql, 'mysql')
+        return sql
+
+    def _get_placeholder(self) -> str:
+        """
+        获取当前数据库类型的参数占位符
+
+        Returns:
+            SQL Server 返回 "?"，MySQL 返回 "%s"
+        """
+        if self._db_type == DatabaseType.MYSQL:
+            return "%s"
+        return "?"
+
+    def _build_placeholders(self, count: int) -> str:
+        """
+        构建参数占位符字符串
+
+        Args:
+            count: 占位符数量
+
+        Returns:
+            占位符字符串，如 "?, ?, ?" 或 "%s, %s, %s"
+        """
+        placeholder = self._get_placeholder()
+        return ", ".join([placeholder for _ in range(count)])
+
+    def _build_in_clause_placeholders(self, count: int) -> str:
+        """
+        构建 IN 子句的参数占位符字符串
+
+        Args:
+            count: 占位符数量
+
+        Returns:
+            IN 子句占位符字符串，如 "?, ?, ?" 或 "%s, %s, %s"
+        """
+        placeholder = self._get_placeholder()
+        return ", ".join([placeholder for _ in range(count)])
+
+    def _get_connection(self):
+        """
+        获取数据库连接
+
+        Returns:
+            数据库连接对象
+        """
+        return get_connection()

db/bip_users_dao.py

@@ -2,10 +2,12 @@
 BIPUsers DAO - Data access object for user authentication and management
 """
 from typing import Optional, Dict, Any, List
+from db.base_dao import BaseDAO
 from db.connection import get_connection
+from config.schema import DatabaseType
 
 
-class BIPUsersDAO:
+class BIPUsersDAO(BaseDAO):
     """Data access object for BIPUsers table"""
 
     def authenticate(self, username: str, password: str) -> Optional[Dict[str, Any]]:
@@ -20,11 +22,23 @@ class BIPUsersDAO:
             Dict with user info if authentication successful, None otherwise
             Returns: {id, username, user_type}
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        SELECT [ID], [UserName], [UserType]
+        placeholder = self._get_placeholder()
-        FROM [dbo].[BIPUsers]
+
-        WHERE [UserName] = ? AND [Password] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT ID, UserName, UserType
+            FROM {table_name}
+            WHERE UserName = {placeholder} AND Password = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT [ID], [UserName], [UserType]
+            FROM {table_name}
+            WHERE [UserName] = {placeholder} AND [Password] = {placeholder}
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql, (username, password))
             if results:
@@ -42,11 +56,22 @@ class BIPUsersDAO:
         Returns:
             List of user dictionaries: [{id, username, user_type, create_time}]
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        SELECT [ID], [UserName], [UserType], [CreateTime]
+
-        FROM [dbo].[BIPUsers]
+        # 根据数据库类型选择列名格式
-        ORDER BY [UserName]
+        if self._db_type == DatabaseType.MYSQL:
-        """
+            sql = f"""
+            SELECT ID, UserName, UserType, CreateTime
+            FROM {table_name}
+            ORDER BY UserName
+            """
+        else:
+            sql = f"""
+            SELECT [ID], [UserName], [UserType], [CreateTime]
+            FROM {table_name}
+            ORDER BY [UserName]
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql)
             return [
@@ -71,10 +96,21 @@ class BIPUsersDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        INSERT INTO [dbo].[BIPUsers] ([UserName], [Password], [UserType])
+        placeholder = self._get_placeholder()
-        VALUES (?, ?, ?)
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            INSERT INTO {table_name} (UserName, Password, UserType)
+            VALUES ({placeholder}, {placeholder}, {placeholder})
+            """
+        else:
+            sql = f"""
+            INSERT INTO {table_name} ([UserName], [Password], [UserType])
+            VALUES ({placeholder}, {placeholder}, {placeholder})
+            """
+
         try:
             with get_connection() as db:
                 db.execute_update(sql, (username, password, user_type))
@@ -94,11 +130,23 @@ class BIPUsersDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        UPDATE [dbo].[BIPUsers]
+        placeholder = self._get_placeholder()
-        SET [UserType] = ?
+
-        WHERE [UserName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            UPDATE {table_name}
+            SET UserType = {placeholder}
+            WHERE UserName = {placeholder}
+            """
+        else:
+            sql = f"""
+            UPDATE {table_name}
+            SET [UserType] = {placeholder}
+            WHERE [UserName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 db.execute_update(sql, (user_type, username))
@@ -118,11 +166,23 @@ class BIPUsersDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        UPDATE [dbo].[BIPUsers]
+        placeholder = self._get_placeholder()
-        SET [Password] = ?
+
-        WHERE [UserName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            UPDATE {table_name}
+            SET Password = {placeholder}
+            WHERE UserName = {placeholder}
+            """
+        else:
+            sql = f"""
+            UPDATE {table_name}
+            SET [Password] = {placeholder}
+            WHERE [UserName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 db.execute_update(sql, (new_password, username))
@@ -141,10 +201,21 @@ class BIPUsersDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        DELETE FROM [dbo].[BIPUsers]
+        placeholder = self._get_placeholder()
-        WHERE [UserName] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE UserName = {placeholder}
+            """
+        else:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE [UserName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 db.execute_update(sql, (username,))
@@ -163,10 +234,21 @@ class BIPUsersDAO:
         Returns:
             True if username exists, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[BIPUsers]')
-        SELECT COUNT(*) as count FROM [dbo].[BIPUsers]
+        placeholder = self._get_placeholder()
-        WHERE [UserName] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT COUNT(*) as count FROM {table_name}
+            WHERE UserName = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT COUNT(*) as count FROM {table_name}
+            WHERE [UserName] = {placeholder}
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql, (username,))
             return results[0]['count'] > 0 if results else False

db/connection.py

@@ -1,10 +1,9 @@
 """
-SQL Server 数据库连接组件
+数据库连接组件
 
-提供数据库连接和查询接口
+提供数据库连接和查询接口，支持 SQL Server 和 MySQL
 """
 
-import pyodbc
 from typing import List, Dict, Any, Optional
 import sys
 import os
@@ -14,186 +13,78 @@ project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if project_root not in sys.path:
     sys.path.insert(0, project_root)
 
-from config.defaults import DEFAULT_APP_CONFIG
+from config.schema import DatabaseType
-
+from db.connection_factory import ConnectionFactory
-# 从默认配置获取数据库配置
+from db.base_connection import BaseDatabaseConnection
-SQL_SERVER_CONFIG = {
-    "driver": DEFAULT_APP_CONFIG.database.driver,
-    "server": DEFAULT_APP_CONFIG.database.server,
-    "database": DEFAULT_APP_CONFIG.database.database,
-    "username": DEFAULT_APP_CONFIG.database.username,
-    "password": DEFAULT_APP_CONFIG.database.password,
-    "TrustServerCertificate": DEFAULT_APP_CONFIG.database.trust_server_certificate,
-}
 
 
-class DatabaseConnection:
+def get_connection(config=None) -> BaseDatabaseConnection:
-    """SQL Server 数据库连接类"""
+    """
+    获取数据库连接实例
 
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
+    Args:
-        """
+        config: 可选的数据库配置对象，默认从用户配置文件加载
-        初始化数据库连接
 
-        Args:
+    Returns:
-            config: 数据库配置字典，默认使用 SQL_SERVER_CONFIG
+        BaseDatabaseConnection: 数据库连接对象
-        """
+    """
-        self.config = config or SQL_SERVER_CONFIG
+    if config is not None:
-        self.connection = None
+        # 使用提供的配置
+        database_config = config
+    else:
+        # 从用户配置文件加载
+        from config.loader import ConfigLoader
+        app_config = ConfigLoader.load()
+        database_config = app_config.database
 
-    def connect(self) -> pyodbc.Connection:
+    return ConnectionFactory.create_from_config(database_config)
-        """
-        建立数据库连接
-
-        Returns:
-            pyodbc.Connection: 数据库连接对象
-        """
-        if self.connection is not None:
-            return self.connection
-
-        # 构建连接字符串
-        conn_str = (
-            f"DRIVER={{{self.config['driver']}}};"
-            f"SERVER={self.config['server']};"
-            f"DATABASE={self.config['database']};"
-            f"UID={self.config['username']};"
-            f"PWD={self.config['password']};"
-            f"TrustServerCertificate={self.config['TrustServerCertificate']};"
-        )
-
-        try:
-            self.connection = pyodbc.connect(conn_str)
-            print(
-                f"成功连接到数据库: {self.config['server']}/{self.config['database']}"
-            )
-            return self.connection
-        except pyodbc.Error as e:
-            print(f"数据库连接失败: {e}")
-            raise
-
-    def disconnect(self):
-        """关闭数据库连接"""
-        if self.connection:
-            self.connection.close()
-            self.connection = None
-            print("数据库连接已关闭")
-
-    def execute_query(
-        self, sql: str, params: Optional[tuple] = None
-    ) -> List[Dict[str, Any]]:
-        """
-        执行查询语句并返回结果
-
-        Args:
-            sql: SQL 查询语句
-            params: 查询参数（可选）
-
-        Returns:
-            List[Dict[str, Any]]: 查询结果列表，每个元素为一行数据的字典
-        """
-        if not self.connection:
-            self.connect()
-
-        cursor = self.connection.cursor()
-
-        try:
-            if params:
-                cursor.execute(sql, params)
-            else:
-                cursor.execute(sql)
-
-            # 获取列名
-            columns = [column[0] for column in cursor.description]
-
-            # 将结果转换为字典列表
-            results = []
-            for row in cursor.fetchall():
-                results.append(dict(zip(columns, row)))
-
-            return results
-
-        except pyodbc.Error as e:
-            print(f"查询执行失败: {e}")
-            raise
-        finally:
-            cursor.close()
-
-    def execute_update(self, sql: str, params: Optional[tuple] = None) -> int:
-        """
-        执行更新/插入/删除语句
-
-        Args:
-            sql: SQL 语句
-            params: 参数（可选）
-
-        Returns:
-            int: 受影响的行数
-        """
-        if not self.connection:
-            self.connect()
-
-        cursor = self.connection.cursor()
-
-        try:
-            if params:
-                cursor.execute(sql, params)
-            else:
-                cursor.execute(sql)
-
-            self.connection.commit()
-            return cursor.rowcount
-
-        except pyodbc.Error as e:
-            self.connection.rollback()
-            print(f"执行失败，已回滚: {e}")
-            raise
-        finally:
-            cursor.close()
-
-    def __enter__(self):
-        """支持 with 语句的上下文管理器入口"""
-        self.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """支持 with 语句的上下文管理器出口"""
-        self.disconnect()
 
 
-# 便捷函数
 def query_production_orders(总排号_list: List[str]) -> List[Dict[str, Any]]:
     """
     根据总排号列表查询生产订单号
 
+    支持两种数据库格式：
+    - SQL Server: [productionContractData].[26年压力表合同数据]
+    - MySQL: productionContractData_26年压力表合同数据
+
     Args:
         总排号_list: 总排号列表
 
     Returns:
         List[Dict[str, Any]]: 查询结果
     """
-    db = DatabaseConnection()
+    from db.table_name_converter import TableNameConverter
+    from config.loader import ConfigLoader
 
-    # 构建占位符字符串
+    # 获取当前数据库类型
-    placeholders = ",".join(["?" for _ in 总排号_list])
+    app_config = ConfigLoader.load()
+    db_type = app_config.database.db_type
 
-    sql = f"""
+    with get_connection() as db:
-    SELECT [总排号], [生产订单号], [序号], [订单号], [客户名称], [产品型号]
+        # 获取正确的占位符
-    FROM [productionContractData].[26年压力表合同数据]
+        placeholder = db.get_placeholder()
-    WHERE [总排号] IN ({placeholders})
+
-    ORDER BY [序号]
+        # 构建占位符字符串
-    """
+        placeholders = ",".join([placeholder for _ in 总排号_list])
+
+        # 根据数据库类型选择表名格式
+        if db_type == DatabaseType.MYSQL:
+            table_name = "productionContractData_26年压力表合同数据"
+            sql = f"""
+            SELECT 总排号, 生产订单号, 序号, 订单号, 客户名称, 产品型号
+            FROM {table_name}
+            WHERE 总排号 IN ({placeholders})
+            ORDER BY 序号
+            """
+        else:
+            table_name = "[productionContractData].[26年压力表合同数据]"
+            sql = f"""
+            SELECT [总排号], [生产订单号], [序号], [订单号], [客户名称], [产品型号]
+            FROM {table_name}
+            WHERE [总排号] IN ({placeholders})
+            ORDER BY [序号]
+            """
 
-    try:
         results = db.execute_query(sql, tuple(总排号_list))
         return results
-    finally:
-        db.disconnect()
-
-
-def get_connection() -> DatabaseConnection:
-    """
-    获取数据库连接实例
-
-    Returns:
-        DatabaseConnection: 数据库连接对象
-    """
-    return DatabaseConnection()

db/connection_factory.py

@@ -0,0 +1,90 @@
+"""
+数据库连接工厂
+
+根据配置创建对应数据库类型的连接实例
+"""
+
+from typing import Dict, Any, Optional
+from config.schema import DatabaseType
+from db.base_connection import BaseDatabaseConnection
+from db.sqlserver_connection import SQLServerConnection
+from db.mysql_connection import MySQLConnection
+
+
+class ConnectionFactory:
+    """数据库连接工厂类"""
+
+    @staticmethod
+    def create_connection(
+        db_type: DatabaseType,
+        config: Optional[Dict[str, Any]] = None
+    ) -> BaseDatabaseConnection:
+        """
+        根据数据库类型创建对应的连接实例
+
+        Args:
+            db_type: 数据库类型（SQLSERVER 或 MYSQL）
+            config: 数据库配置字典
+
+        Returns:
+            对应数据库的连接实例
+
+        Raises:
+            ValueError: 不支持的数据库类型
+        """
+        if db_type == DatabaseType.SQLSERVER:
+            return SQLServerConnection(config)
+        elif db_type == DatabaseType.MYSQL:
+            return MySQLConnection(config)
+        else:
+            raise ValueError(f"不支持的数据库类型: {db_type}")
+
+    @staticmethod
+    def create_from_config(database_config) -> BaseDatabaseConnection:
+        """
+        从 DatabaseConfig 配置对象创建连接
+
+        Args:
+            database_config: DatabaseConfig 配置对象
+
+        Returns:
+            对应数据库的连接实例
+
+        Raises:
+            ValueError: 不支持的数据库类型
+        """
+        db_type = database_config.db_type
+
+        if db_type == DatabaseType.SQLSERVER:
+            # 构建 SQL Server 配置字典
+            config = {
+                'server': database_config.server,
+                'database': database_config.database,
+                'username': database_config.username,
+                'password': database_config.password,
+            }
+            if database_config.sqlserver:
+                config['driver'] = database_config.sqlserver.driver
+                config['trust_server_certificate'] = (
+                    database_config.sqlserver.trust_server_certificate
+                )
+            return SQLServerConnection(config)
+
+        elif db_type == DatabaseType.MYSQL:
+            # 构建 MySQL 配置字典
+            config = {
+                'database': database_config.database,
+                'username': database_config.username,
+                'password': database_config.password,
+            }
+            if database_config.mysql:
+                config['host'] = database_config.mysql.host
+                config['port'] = database_config.mysql.port
+                config['charset'] = database_config.mysql.charset
+            else:
+                # 回退到 server 字段（兼容旧配置）
+                config['host'] = database_config.server
+            return MySQLConnection(config)
+
+        else:
+            raise ValueError(f"不支持的数据库类型: {db_type}")

db/discrete_material_plan_dao.py

@@ -2,37 +2,20 @@
 Data Access Object for DiscreteMaterialPlanData table.
 
 This module provides CRUD operations for persisting discrete material plan
-data to SQL Server database. It handles mapping between Chinese DataFrame
+data to SQL Server/MySQL database. It handles mapping between Chinese DataFrame
 columns (from ExcelConverter) and English database columns.
 """
 
+from db.base_dao import BaseDAO
 from db.connection import get_connection
 from typing import List, Dict, Any
 import pandas as pd
+from config.schema import DatabaseType
 
 
-class DiscreteMaterialPlanDAO:
+class DiscreteMaterialPlanDAO(BaseDAO):
     """Data Access Object for DiscreteMaterialPlanData table"""
 
-    def __init__(self):
-        self.db = None
-
-    def __enter__(self):
-        """Enter context manager and establish database connection"""
-        self.db = get_connection()
-        self.db.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit context manager and close database connection"""
-        if self.db:
-            self.db.disconnect()
-
-    def close(self):
-        """Close database connection"""
-        if self.db:
-            self.db.disconnect()
-
     def save_dataframe_with_replace(self, df: pd.DataFrame) -> Dict[str, int]:
         """
         Save DataFrame using REPLACE strategy (DELETE + INSERT).
@@ -97,8 +80,13 @@ class DiscreteMaterialPlanDAO:
 
         for i in range(0, len(plan_numbers), batch_size):
             batch = plan_numbers[i:i + batch_size]
-            placeholders = ','.join(['?' for _ in batch])
+            placeholder = self._get_placeholder()
-            sql = f"DELETE FROM DiscreteMaterialPlanData WHERE PlanNumber IN ({placeholders})"
+            placeholders = ','.join([placeholder for _ in batch])
+
+            # 根据数据库类型选择表名
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            sql = f"DELETE FROM {table_name} WHERE PlanNumber IN ({placeholders})"
+
             deleted = db.execute_update(sql, tuple(batch))
             total_deleted += deleted
 
@@ -119,15 +107,19 @@ class DiscreteMaterialPlanDAO:
         Returns:
             Total number of records inserted
         """
-        sql = """
+        # 根据数据库类型选择表名
-        INSERT INTO DiscreteMaterialPlanData (
+        table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+        placeholder = self._get_placeholder()
+
+        sql = f"""
+        INSERT INTO {table_name} (
             Factory, MaterialStatus, PlanNumber, SourceNumber, MaterialType,
             ProductCode, ProductName, ProductUnit, ProductPlanQuantity,
             UseDepartment, Remark, Creator, CreateDate, Approver, ApproveDate,
             SequenceNumber, MaterialCode, MaterialName, Specification, Model,
             DrawingNumber, MaterialQuality, PlanQuantity, Unit, RequiredDate,
             Warehouse, UnitUsage, CumulativeOutputQuantity, BOMVersion
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ) VALUES ({self._build_placeholders(28)})
         """
 
         total_inserted = 0
@@ -217,7 +209,9 @@ class DiscreteMaterialPlanDAO:
             List of dictionaries representing records
         """
         with get_connection() as db:
-            sql = "SELECT * FROM DiscreteMaterialPlanData WHERE PlanNumber = ?"
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            placeholder = self._get_placeholder()
+            sql = f"SELECT * FROM {table_name} WHERE PlanNumber = {placeholder}"
             return db.execute_query(sql, (plan_number,))
 
     def query_by_plan_numbers(self, plan_numbers: List[str]) -> List[Dict]:
@@ -232,8 +226,10 @@ class DiscreteMaterialPlanDAO:
         """
         if not plan_numbers:
             return []
-        placeholders = ','.join(['?' for _ in plan_numbers])
+        placeholder = self._get_placeholder()
-        sql = f"SELECT * FROM DiscreteMaterialPlanData WHERE PlanNumber IN ({placeholders})"
+        placeholders = ','.join([placeholder for _ in plan_numbers])
+        table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+        sql = f"SELECT * FROM {table_name} WHERE PlanNumber IN ({placeholders})"
         with get_connection() as db:
             return db.execute_query(sql, tuple(plan_numbers))
 
@@ -248,7 +244,9 @@ class DiscreteMaterialPlanDAO:
             List of dictionaries representing records
         """
         with get_connection() as db:
-            sql = "SELECT * FROM DiscreteMaterialPlanData WHERE SourceNumber = ?"
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            placeholder = self._get_placeholder()
+            sql = f"SELECT * FROM {table_name} WHERE SourceNumber = {placeholder}"
             return db.execute_query(sql, (order_id,))
 
     def count_by_plan_number(self, plan_number: str) -> int:
@@ -262,7 +260,9 @@ class DiscreteMaterialPlanDAO:
             Number of records
         """
         with get_connection() as db:
-            sql = "SELECT COUNT(*) as count FROM DiscreteMaterialPlanData WHERE PlanNumber = ?"
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            placeholder = self._get_placeholder()
+            sql = f"SELECT COUNT(*) as count FROM {table_name} WHERE PlanNumber = {placeholder}"
             result = db.execute_query(sql, (plan_number,))
             return result[0]['count'] if result else 0
 
@@ -274,7 +274,8 @@ class DiscreteMaterialPlanDAO:
             Total number of records
         """
         with get_connection() as db:
-            sql = "SELECT COUNT(*) as count FROM DiscreteMaterialPlanData"
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            sql = f"SELECT COUNT(*) as count FROM {table_name}"
             result = db.execute_query(sql)
             return result[0]['count'] if result else 0
 
@@ -300,14 +301,15 @@ class DiscreteMaterialPlanDAO:
             unique plans, unique orders, and date range
         """
         with get_connection() as db:
-            sql = """
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            sql = f"""
             SELECT
                 COUNT(*) as total_records,
                 COUNT(DISTINCT PlanNumber) as unique_plans,
                 COUNT(DISTINCT SourceNumber) as unique_orders,
                 MIN(CreateDate) as earliest_record,
                 MAX(CreateDate) as latest_record
-            FROM DiscreteMaterialPlanData
+            FROM {table_name}
             """
             result = db.execute_query(sql)
             return result[0] if result else {}
@@ -322,7 +324,8 @@ class DiscreteMaterialPlanDAO:
             List of dictionaries representing all records
         """
         with get_connection() as db:
-            sql = "SELECT * FROM DiscreteMaterialPlanData"
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            sql = f"SELECT * FROM {table_name}"
             return db.execute_query(sql)
 
     def query_by_source_numbers(self, source_numbers: List[str]) -> List[Dict]:
@@ -344,8 +347,10 @@ class DiscreteMaterialPlanDAO:
 
         for i in range(0, len(source_numbers), batch_size):
             batch = source_numbers[i:i + batch_size]
-            placeholders = ','.join(['?' for _ in batch])
+            placeholder = self._get_placeholder()
-            sql = f"SELECT * FROM DiscreteMaterialPlanData WHERE SourceNumber IN ({placeholders})"
+            placeholders = ','.join([placeholder for _ in batch])
+            table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+            sql = f"SELECT * FROM {table_name} WHERE SourceNumber IN ({placeholders})"
             with get_connection() as db:
                 results = db.execute_query(sql, tuple(batch))
                 all_results.extend(results)
@@ -362,9 +367,11 @@ class DiscreteMaterialPlanDAO:
         Returns:
             List of unique material names
         """
+        table_name = self._convert_sql('[dbo].[DiscreteMaterialPlanData]')
+
         if source_numbers is None or not source_numbers:
             # No filter - get all unique material names
-            sql = "SELECT DISTINCT MaterialName FROM DiscreteMaterialPlanData WHERE MaterialName IS NOT NULL"
+            sql = f"SELECT DISTINCT MaterialName FROM {table_name} WHERE MaterialName IS NOT NULL"
             with get_connection() as db:
                 results = db.execute_query(sql)
                 return [r['MaterialName'] for r in results if r.get('MaterialName')]
@@ -375,10 +382,11 @@ class DiscreteMaterialPlanDAO:
 
             for i in range(0, len(source_numbers), batch_size):
                 batch = source_numbers[i:i + batch_size]
-                placeholders = ','.join(['?' for _ in batch])
+                placeholder = self._get_placeholder()
+                placeholders = ','.join([placeholder for _ in batch])
                 sql = f"""
                 SELECT DISTINCT MaterialName
-                FROM DiscreteMaterialPlanData
+                FROM {table_name}
                 WHERE SourceNumber IN ({placeholders})
                   AND MaterialName IS NOT NULL
                 """

db/materials_to_be_deleted_dao.py

@@ -6,31 +6,14 @@ which tracks materials that need to be deleted by their managers.
 """
 
 from typing import List, Dict, Any, Tuple, Optional
+from db.base_dao import BaseDAO
 from db.connection import get_connection
+from config.schema import DatabaseType
 
 
-class MaterialsTypeToBeDeletedDAO:
+class MaterialsTypeToBeDeletedDAO(BaseDAO):
     """Data Access Object for MaterialsTypeToBeDeleted table CRUD operations"""
 
-    def __init__(self):
-        self.db = None
-
-    def __enter__(self):
-        """Enter context manager and establish database connection"""
-        self.db = get_connection()
-        self.db.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit context manager and close database connection"""
-        if self.db:
-            self.db.disconnect()
-
-    def close(self):
-        """Close database connection"""
-        if self.db:
-            self.db.disconnect()
-
     # ==================== CREATE ====================
 
     def insert_material(
@@ -46,10 +29,21 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        INSERT INTO [dbo].[MaterialsTypeToBeDeleted] ([MaterialName], [ManagerName])
+        placeholder = self._get_placeholder()
-        VALUES (?, ?)
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            INSERT INTO {table_name} (MaterialName, ManagerName)
+            VALUES ({placeholder}, {placeholder})
+            """
+        else:
+            sql = f"""
+            INSERT INTO {table_name} ([MaterialName], [ManagerName])
+            VALUES ({placeholder}, {placeholder})
+            """
+
         try:
             with get_connection() as db:
                 db.execute_update(sql, (material_name, manager_name))
@@ -71,10 +65,20 @@ class MaterialsTypeToBeDeletedDAO:
         if not materials:
             return 0
 
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        INSERT INTO [dbo].[MaterialsTypeToBeDeleted] ([MaterialName], [ManagerName])
+        placeholder = self._get_placeholder()
-        VALUES (?, ?)
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            INSERT INTO {table_name} (MaterialName, ManagerName)
+            VALUES ({placeholder}, {placeholder})
+            """
+        else:
+            sql = f"""
+            INSERT INTO {table_name} ([MaterialName], [ManagerName])
+            VALUES ({placeholder}, {placeholder})
+            """
 
         inserted_count = 0
         try:
@@ -96,12 +100,24 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             List of all materials with MaterialName and ManagerName
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT [MaterialName], [ManagerName]
+
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+        # 根据数据库类型选择列名格式
-        WHERE [MaterialName] IS NOT NULL
+        if self._db_type == DatabaseType.MYSQL:
-        ORDER BY [ManagerName], [MaterialName]
+            sql = f"""
-        """
+            SELECT MaterialName, ManagerName
+            FROM {table_name}
+            WHERE MaterialName IS NOT NULL
+            ORDER BY ManagerName, MaterialName
+            """
+        else:
+            sql = f"""
+            SELECT [MaterialName], [ManagerName]
+            FROM {table_name}
+            WHERE [MaterialName] IS NOT NULL
+            ORDER BY [ManagerName], [MaterialName]
+            """
+
         with get_connection() as db:
             return db.execute_query(sql)
 
@@ -115,12 +131,25 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             List of materials for the specified manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT [MaterialName], [ManagerName]
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+
-        WHERE [ManagerName] = ? AND [MaterialName] IS NOT NULL
+        # 根据数据库类型选择列名格式
-        ORDER BY [MaterialName]
+        if self._db_type == DatabaseType.MYSQL:
-        """
+            sql = f"""
+            SELECT MaterialName, ManagerName
+            FROM {table_name}
+            WHERE ManagerName = {placeholder} AND MaterialName IS NOT NULL
+            ORDER BY MaterialName
+            """
+        else:
+            sql = f"""
+            SELECT [MaterialName], [ManagerName]
+            FROM {table_name}
+            WHERE [ManagerName] = {placeholder} AND [MaterialName] IS NOT NULL
+            ORDER BY [MaterialName]
+            """
+
         with get_connection() as db:
             return db.execute_query(sql, (manager_name,))
 
@@ -131,12 +160,24 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             List of unique manager names
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT DISTINCT [ManagerName]
+
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+        # 根据数据库类型选择列名格式
-        WHERE [ManagerName] IS NOT NULL
+        if self._db_type == DatabaseType.MYSQL:
-        ORDER BY [ManagerName]
+            sql = f"""
-        """
+            SELECT DISTINCT ManagerName
+            FROM {table_name}
+            WHERE ManagerName IS NOT NULL
+            ORDER BY ManagerName
+            """
+        else:
+            sql = f"""
+            SELECT DISTINCT [ManagerName]
+            FROM {table_name}
+            WHERE [ManagerName] IS NOT NULL
+            ORDER BY [ManagerName]
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql)
             return [r['ManagerName'] for r in results if r.get('ManagerName')]
@@ -173,11 +214,23 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        UPDATE [dbo].[MaterialsTypeToBeDeleted]
+        placeholder = self._get_placeholder()
-        SET [ManagerName] = ?
+
-        WHERE [MaterialName] = ? AND [ManagerName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            UPDATE {table_name}
+            SET ManagerName = {placeholder}
+            WHERE MaterialName = {placeholder} AND ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            UPDATE {table_name}
+            SET [ManagerName] = {placeholder}
+            WHERE [MaterialName] = {placeholder} AND [ManagerName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 affected = db.execute_update(sql, (new_manager, material_name, old_manager))
@@ -203,10 +256,21 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        DELETE FROM [dbo].[MaterialsTypeToBeDeleted]
+        placeholder = self._get_placeholder()
-        WHERE [MaterialName] = ? AND [ManagerName] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE MaterialName = {placeholder} AND ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE [MaterialName] = {placeholder} AND [ManagerName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 affected = db.execute_update(sql, (material_name, manager_name))
@@ -225,10 +289,21 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             Number of records deleted
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        DELETE FROM [dbo].[MaterialsTypeToBeDeleted]
+        placeholder = self._get_placeholder()
-        WHERE [ManagerName] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE [ManagerName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 return db.execute_update(sql, (manager_name,))
@@ -243,7 +318,9 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             Number of records deleted
         """
-        sql = "DELETE FROM [dbo].[MaterialsTypeToBeDeleted]"
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
+        sql = f"DELETE FROM {table_name}"
+
         try:
             with get_connection() as db:
                 return db.execute_update(sql)
@@ -263,11 +340,23 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             True if material exists, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT COUNT(*) as count
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+
-        WHERE [MaterialName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE MaterialName = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE [MaterialName] = {placeholder}
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql, (material_name,))
             return result[0]['count'] > 0 if result else False
@@ -282,11 +371,23 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             Number of materials for the manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT COUNT(*) as count
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+
-        WHERE [ManagerName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE [ManagerName] = {placeholder}
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql, (manager_name,))
             return result[0]['count'] if result else 0
@@ -299,25 +400,47 @@ class MaterialsTypeToBeDeletedDAO:
             Dictionary with statistics including total materials,
             unique managers, and materials per manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT
+
-            COUNT(*) as total_materials,
+        # 根据数据库类型选择列名格式
-            COUNT(DISTINCT ManagerName) as unique_managers
+        if self._db_type == DatabaseType.MYSQL:
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+            sql = f"""
-        WHERE [MaterialName] IS NOT NULL
+            SELECT
-        """
+                COUNT(*) as total_materials,
+                COUNT(DISTINCT ManagerName) as unique_managers
+            FROM {table_name}
+            WHERE MaterialName IS NOT NULL
+            """
+
+            manager_sql = f"""
+            SELECT ManagerName, COUNT(*) as count
+            FROM {table_name}
+            WHERE ManagerName IS NOT NULL
+            GROUP BY ManagerName
+            ORDER BY count DESC
+            """
+        else:
+            sql = f"""
+            SELECT
+                COUNT(*) as total_materials,
+                COUNT(DISTINCT ManagerName) as unique_managers
+            FROM {table_name}
+            WHERE [MaterialName] IS NOT NULL
+            """
+
+            manager_sql = f"""
+            SELECT [ManagerName], COUNT(*) as count
+            FROM {table_name}
+            WHERE [ManagerName] IS NOT NULL
+            GROUP BY [ManagerName]
+            ORDER BY count DESC
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql)
             stats = result[0] if result else {}
 
             # Get materials per manager
-            manager_sql = """
-            SELECT [ManagerName], COUNT(*) as count
-            FROM [dbo].[MaterialsTypeToBeDeleted]
-            WHERE [ManagerName] IS NOT NULL
-            GROUP BY [ManagerName]
-            ORDER BY count DESC
-            """
             manager_results = db.execute_query(manager_sql)
             stats['materials_per_manager'] = [
                 {r['ManagerName']: r['count']} for r in manager_results
@@ -335,11 +458,24 @@ class MaterialsTypeToBeDeletedDAO:
         Returns:
             List of matching materials
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsTypeToBeDeleted]')
-        SELECT [MaterialName], [ManagerName]
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsTypeToBeDeleted]
+
-        WHERE [MaterialName] LIKE ?
+        # 根据数据库类型选择列名格式
-        ORDER BY [ManagerName], [MaterialName]
+        if self._db_type == DatabaseType.MYSQL:
-        """
+            sql = f"""
+            SELECT MaterialName, ManagerName
+            FROM {table_name}
+            WHERE MaterialName LIKE {placeholder}
+            ORDER BY ManagerName, MaterialName
+            """
+        else:
+            sql = f"""
+            SELECT [MaterialName], [ManagerName]
+            FROM {table_name}
+            WHERE [MaterialName] LIKE {placeholder}
+            ORDER BY [ManagerName], [MaterialName]
+            """
+
         with get_connection() as db:
             return db.execute_query(sql, (f'%{keyword}%',))

db/materials_to_be_deleted_records_dao.py

@@ -7,35 +7,18 @@ This table is different from MaterialsTypeToBeDeleted which matches by MaterialN
 """
 
 from typing import List, Dict, Any, Set, Optional
+from db.base_dao import BaseDAO
 from db.connection import get_connection
+from config.schema import DatabaseType
 
 
-class MaterialsToBeDeletedDAO:
+class MaterialsToBeDeletedDAO(BaseDAO):
     """Data Access Object for MaterialsToBeDeleted table CRUD operations
 
     This table stores material records identified by MaterialCode (exact match),
     unlike MaterialsTypeToBeDeleted which uses MaterialName (partial match).
     """
 
-    def __init__(self):
-        self.db = None
-
-    def __enter__(self):
-        """Enter context manager and establish database connection"""
-        self.db = get_connection()
-        self.db.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit context manager and close database connection"""
-        if self.db:
-            self.db.disconnect()
-
-    def close(self):
-        """Close database connection"""
-        if self.db:
-            self.db.disconnect()
-
     # ==================== UPSERT (MERGE) ====================
 
     def upsert_material(self, material_code: str, manager_name: str) -> bool:
@@ -53,18 +36,39 @@ class MaterialsToBeDeletedDAO:
             print("[ERROR] MaterialCode cannot be empty")
             return False
 
-        sql = """
-        MERGE [dbo].[MaterialsToBeDeleted] AS target
-        USING (SELECT ? AS MaterialCode, ? AS ManagerName) AS source
-        ON (target.MaterialCode = source.MaterialCode)
-        WHEN MATCHED THEN
-            UPDATE SET ManagerName = source.ManagerName
-        WHEN NOT MATCHED THEN
-            INSERT (MaterialCode, ManagerName)
-            VALUES (source.MaterialCode, source.ManagerName);
-        """
         try:
             with get_connection() as db:
+                if self._db_type == DatabaseType.MYSQL:
+                    # MySQL 使用 INSERT ... ON DUPLICATE KEY UPDATE
+                    table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+                    placeholder = self._get_placeholder()
+
+                    if self._db_type == DatabaseType.MYSQL:
+                        sql = f"""
+                        INSERT INTO {table_name} (MaterialCode, ManagerName)
+                        VALUES ({placeholder}, {placeholder})
+                        ON DUPLICATE KEY UPDATE ManagerName = VALUES(ManagerName)
+                        """
+                    else:
+                        sql = f"""
+                        INSERT INTO {table_name} ([MaterialCode], [ManagerName])
+                        VALUES ({placeholder}, {placeholder})
+                        ON DUPLICATE KEY UPDATE [ManagerName] = VALUES([ManagerName])
+                        """
+                else:
+                    # SQL Server 使用 MERGE
+                    table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+                    sql = f"""
+                    MERGE {table_name} AS target
+                    USING (SELECT {self._get_placeholder()} AS MaterialCode, {self._get_placeholder()} AS ManagerName) AS source
+                    ON (target.MaterialCode = source.MaterialCode)
+                    WHEN MATCHED THEN
+                        UPDATE SET ManagerName = source.ManagerName
+                    WHEN NOT MATCHED THEN
+                        INSERT (MaterialCode, ManagerName)
+                        VALUES (source.MaterialCode, source.ManagerName);
+                    """
+
                 db.execute_update(sql, (material_code.strip(), manager_name.strip() if manager_name else None))
                 return True
         except Exception as e:
@@ -84,17 +88,6 @@ class MaterialsToBeDeletedDAO:
         if not materials:
             return {'total': 0, 'success': 0, 'failed': 0}
 
-        sql = """
-        MERGE [dbo].[MaterialsToBeDeleted] AS target
-        USING (SELECT ? AS MaterialCode, ? AS ManagerName) AS source
-        ON (target.MaterialCode = source.MaterialCode)
-        WHEN MATCHED THEN
-            UPDATE SET ManagerName = source.ManagerName
-        WHEN NOT MATCHED THEN
-            INSERT (MaterialCode, ManagerName)
-            VALUES (source.MaterialCode, source.ManagerName);
-        """
-
         stats = {'total': len(materials), 'success': 0, 'failed': 0}
 
         try:
@@ -108,6 +101,37 @@ class MaterialsToBeDeletedDAO:
                         continue
 
                     try:
+                        if self._db_type == DatabaseType.MYSQL:
+                            # MySQL 使用 INSERT ... ON DUPLICATE KEY UPDATE
+                            table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+                            placeholder = self._get_placeholder()
+
+                            if self._db_type == DatabaseType.MYSQL:
+                                sql = f"""
+                                INSERT INTO {table_name} (MaterialCode, ManagerName)
+                                VALUES ({placeholder}, {placeholder})
+                                ON DUPLICATE KEY UPDATE ManagerName = VALUES(ManagerName)
+                                """
+                            else:
+                                sql = f"""
+                                INSERT INTO {table_name} ([MaterialCode], [ManagerName])
+                                VALUES ({placeholder}, {placeholder})
+                                ON DUPLICATE KEY UPDATE [ManagerName] = VALUES([ManagerName])
+                                """
+                        else:
+                            # SQL Server 使用 MERGE
+                            table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+                            sql = f"""
+                            MERGE {table_name} AS target
+                            USING (SELECT {self._get_placeholder()} AS MaterialCode, {self._get_placeholder()} AS ManagerName) AS source
+                            ON (target.MaterialCode = source.MaterialCode)
+                            WHEN MATCHED THEN
+                                UPDATE SET ManagerName = source.ManagerName
+                            WHEN NOT MATCHED THEN
+                                INSERT (MaterialCode, ManagerName)
+                                VALUES (source.MaterialCode, source.ManagerName);
+                            """
+
                         db.execute_update(sql, (material_code, manager_name.strip() if manager_name else None))
                         stats['success'] += 1
                     except Exception as e:
@@ -129,11 +153,22 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Set of material codes
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT [MaterialCode]
+
-        FROM [dbo].[MaterialsToBeDeleted]
+        # 根据数据库类型选择列名格式
-        WHERE [MaterialCode] IS NOT NULL
+        if self._db_type == DatabaseType.MYSQL:
-        """
+            sql = f"""
+            SELECT MaterialCode
+            FROM {table_name}
+            WHERE MaterialCode IS NOT NULL
+            """
+        else:
+            sql = f"""
+            SELECT [MaterialCode]
+            FROM {table_name}
+            WHERE [MaterialCode] IS NOT NULL
+            """
+
         try:
             with get_connection() as db:
                 results = db.execute_query(sql)
@@ -149,12 +184,24 @@ class MaterialsToBeDeletedDAO:
         Returns:
             List of all material records with all fields
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT [ID], [MaterialCode], [ManagerName]
+
-        FROM [dbo].[MaterialsToBeDeleted]
+        # 根据数据库类型选择列名格式
-        WHERE [MaterialCode] IS NOT NULL
+        if self._db_type == DatabaseType.MYSQL:
-        ORDER BY [ManagerName], [MaterialCode]
+            sql = f"""
-        """
+            SELECT ID, MaterialCode, ManagerName
+            FROM {table_name}
+            WHERE MaterialCode IS NOT NULL
+            ORDER BY ManagerName, MaterialCode
+            """
+        else:
+            sql = f"""
+            SELECT [ID], [MaterialCode], [ManagerName]
+            FROM {table_name}
+            WHERE [MaterialCode] IS NOT NULL
+            ORDER BY [ManagerName], [MaterialCode]
+            """
+
         with get_connection() as db:
             return db.execute_query(sql)
 
@@ -168,12 +215,25 @@ class MaterialsToBeDeletedDAO:
         Returns:
             List of materials for the specified manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT [ID], [MaterialCode], [ManagerName]
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsToBeDeleted]
+
-        WHERE [ManagerName] = ? AND [MaterialCode] IS NOT NULL
+        # 根据数据库类型选择列名格式
-        ORDER BY [MaterialCode]
+        if self._db_type == DatabaseType.MYSQL:
-        """
+            sql = f"""
+            SELECT ID, MaterialCode, ManagerName
+            FROM {table_name}
+            WHERE ManagerName = {placeholder} AND MaterialCode IS NOT NULL
+            ORDER BY MaterialCode
+            """
+        else:
+            sql = f"""
+            SELECT [ID], [MaterialCode], [ManagerName]
+            FROM {table_name}
+            WHERE [ManagerName] = {placeholder} AND [MaterialCode] IS NOT NULL
+            ORDER BY [MaterialCode]
+            """
+
         with get_connection() as db:
             return db.execute_query(sql, (manager_name,))
 
@@ -184,12 +244,24 @@ class MaterialsToBeDeletedDAO:
         Returns:
             List of unique manager names
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT DISTINCT [ManagerName]
+
-        FROM [dbo].[MaterialsToBeDeleted]
+        # 根据数据库类型选择列名格式
-        WHERE [ManagerName] IS NOT NULL
+        if self._db_type == DatabaseType.MYSQL:
-        ORDER BY [ManagerName]
+            sql = f"""
-        """
+            SELECT DISTINCT ManagerName
+            FROM {table_name}
+            WHERE ManagerName IS NOT NULL
+            ORDER BY ManagerName
+            """
+        else:
+            sql = f"""
+            SELECT DISTINCT [ManagerName]
+            FROM {table_name}
+            WHERE [ManagerName] IS NOT NULL
+            ORDER BY [ManagerName]
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql)
             return [r['ManagerName'] for r in results if r.get('ManagerName')]
@@ -218,11 +290,23 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Dictionary representing the record, or None if not found
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT [ID], [MaterialCode], [ManagerName]
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsToBeDeleted]
+
-        WHERE [MaterialCode] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT ID, MaterialCode, ManagerName
+            FROM {table_name}
+            WHERE MaterialCode = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT [ID], [MaterialCode], [ManagerName]
+            FROM {table_name}
+            WHERE [MaterialCode] = {placeholder}
+            """
+
         with get_connection() as db:
             results = db.execute_query(sql, (material_code.strip(),))
             return results[0] if results else None
@@ -239,10 +323,21 @@ class MaterialsToBeDeletedDAO:
         Returns:
             True if successful, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        DELETE FROM [dbo].[MaterialsToBeDeleted]
+        placeholder = self._get_placeholder()
-        WHERE [MaterialCode] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE MaterialCode = {placeholder}
+            """
+        else:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE [MaterialCode] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 affected = db.execute_update(sql, (material_code.strip(),))
@@ -261,10 +356,21 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Number of records deleted
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        DELETE FROM [dbo].[MaterialsToBeDeleted]
+        placeholder = self._get_placeholder()
-        WHERE [ManagerName] = ?
+
-        """
+        # 根据数据库类型选择列名格式
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE [ManagerName] = {placeholder}
+            """
+
         try:
             with get_connection() as db:
                 return db.execute_update(sql, (manager_name,))
@@ -279,7 +385,9 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Number of records deleted
         """
-        sql = "DELETE FROM [dbo].[MaterialsToBeDeleted]"
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+        sql = f"DELETE FROM {table_name}"
+
         try:
             with get_connection() as db:
                 return db.execute_update(sql)
@@ -305,8 +413,15 @@ class MaterialsToBeDeletedDAO:
 
         for i in range(0, len(material_codes), batch_size):
             batch = material_codes[i:i + batch_size]
-            placeholders = ','.join(['?' for _ in batch])
+            placeholder = self._get_placeholder()
-            sql = f"DELETE FROM [dbo].[MaterialsToBeDeleted] WHERE [MaterialCode] IN ({placeholders})"
+            placeholders = ','.join([placeholder for _ in batch])
+            table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+
+            # 根据数据库类型选择列名格式
+            if self._db_type == DatabaseType.MYSQL:
+                sql = f"DELETE FROM {table_name} WHERE MaterialCode IN ({placeholders})"
+            else:
+                sql = f"DELETE FROM {table_name} WHERE [MaterialCode] IN ({placeholders})"
 
             try:
                 with get_connection() as db:
@@ -329,11 +444,23 @@ class MaterialsToBeDeletedDAO:
         Returns:
             True if material exists, False otherwise
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT COUNT(*) as count
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsToBeDeleted]
+
-        WHERE [MaterialCode] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE MaterialCode = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE [MaterialCode] = {placeholder}
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql, (material_code.strip(),))
             return result[0]['count'] > 0 if result else False
@@ -345,7 +472,9 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Total number of records
         """
-        sql = "SELECT COUNT(*) as count FROM [dbo].[MaterialsToBeDeleted]"
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
+        sql = f"SELECT COUNT(*) as count FROM {table_name}"
+
         with get_connection() as db:
             result = db.execute_query(sql)
             return result[0]['count'] if result else 0
@@ -360,11 +489,23 @@ class MaterialsToBeDeletedDAO:
         Returns:
             Number of materials for the manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT COUNT(*) as count
+        placeholder = self._get_placeholder()
-        FROM [dbo].[MaterialsToBeDeleted]
+
-        WHERE [ManagerName] = ?
+        # 根据数据库类型选择列名格式
-        """
+        if self._db_type == DatabaseType.MYSQL:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE ManagerName = {placeholder}
+            """
+        else:
+            sql = f"""
+            SELECT COUNT(*) as count
+            FROM {table_name}
+            WHERE [ManagerName] = {placeholder}
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql, (manager_name,))
             return result[0]['count'] if result else 0
@@ -377,25 +518,47 @@ class MaterialsToBeDeletedDAO:
             Dictionary with statistics including total materials,
             unique managers, and materials per manager
         """
-        sql = """
+        table_name = self._convert_sql('[dbo].[MaterialsToBeDeleted]')
-        SELECT
+
-            COUNT(*) as total_materials,
+        # 根据数据库类型选择列名格式
-            COUNT(DISTINCT ManagerName) as unique_managers
+        if self._db_type == DatabaseType.MYSQL:
-        FROM [dbo].[MaterialsToBeDeleted]
+            sql = f"""
-        WHERE [MaterialCode] IS NOT NULL
+            SELECT
-        """
+                COUNT(*) as total_materials,
+                COUNT(DISTINCT ManagerName) as unique_managers
+            FROM {table_name}
+            WHERE MaterialCode IS NOT NULL
+            """
+
+            manager_sql = f"""
+            SELECT ManagerName, COUNT(*) as count
+            FROM {table_name}
+            WHERE ManagerName IS NOT NULL
+            GROUP BY ManagerName
+            ORDER BY count DESC
+            """
+        else:
+            sql = f"""
+            SELECT
+                COUNT(*) as total_materials,
+                COUNT(DISTINCT ManagerName) as unique_managers
+            FROM {table_name}
+            WHERE [MaterialCode] IS NOT NULL
+            """
+
+            manager_sql = f"""
+            SELECT [ManagerName], COUNT(*) as count
+            FROM {table_name}
+            WHERE [ManagerName] IS NOT NULL
+            GROUP BY [ManagerName]
+            ORDER BY count DESC
+            """
+
         with get_connection() as db:
             result = db.execute_query(sql)
             stats = result[0] if result else {}
 
             # Get materials per manager
-            manager_sql = """
-            SELECT [ManagerName], COUNT(*) as count
-            FROM [dbo].[MaterialsToBeDeleted]
-            WHERE [ManagerName] IS NOT NULL
-            GROUP BY [ManagerName]
-            ORDER BY count DESC
-            """
             manager_results = db.execute_query(manager_sql)
             stats['materials_per_manager'] = [
                 {r['ManagerName']: r['count']} for r in manager_results

db/mysql_connection.py

@@ -0,0 +1,142 @@
+"""
+MySQL 数据库连接组件
+
+提供 MySQL 数据库连接和查询接口
+"""
+
+import mysql.connector
+from mysql.connector import Error
+from typing import List, Dict, Any, Optional
+from db.base_connection import BaseDatabaseConnection
+
+
+class MySQLConnection(BaseDatabaseConnection):
+    """MySQL 数据库连接类"""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        初始化数据库连接
+
+        Args:
+            config: 数据库配置字典
+                - host: 服务器地址
+                - port: 端口号（默认 3306）
+                - database: 数据库名称
+                - username: 用户名
+                - password: 密码
+                - charset: 字符集（默认 utf8mb4）
+        """
+        super().__init__(config)
+
+    def connect(self):
+        """
+        建立数据库连接
+
+        Returns:
+            mysql.connector.connection.MySQLConnection: 数据库连接对象
+        """
+        if self.connection is not None:
+            return self.connection
+
+        try:
+            self.connection = mysql.connector.connect(
+                host=self.config.get('host', 'localhost'),
+                port=self.config.get('port', 3306),
+                database=self.config['database'],
+                user=self.config['username'],
+                password=self.config['password'],
+                charset=self.config.get('charset', 'utf8mb4'),
+                autocommit=False
+            )
+            print(
+                f"成功连接到 MySQL 数据库: {self.config.get('host', 'localhost')}"
+                f":{self.config.get('port', 3306)}/{self.config['database']}"
+            )
+            return self.connection
+        except Error as e:
+            print(f"MySQL 数据库连接失败: {e}")
+            raise
+
+    def disconnect(self):
+        """关闭数据库连接"""
+        if self.connection and self.connection.is_connected():
+            self.connection.close()
+            self.connection = None
+            print("MySQL 数据库连接已关闭")
+
+    def execute_query(
+        self, sql: str, params: Optional[tuple] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        执行查询语句并返回结果
+
+        Args:
+            sql: SQL 查询语句
+            params: 查询参数（可选）
+
+        Returns:
+            List[Dict[str, Any]]: 查询结果列表，每个元素为一行数据的字典
+        """
+        if not self.connection or not self.connection.is_connected():
+            self.connect()
+
+        cursor = None
+        try:
+            cursor = self.connection.cursor(dictionary=True)
+            if params:
+                cursor.execute(sql, params)
+            else:
+                cursor.execute(sql)
+
+            # 直接获取字典列表
+            results = cursor.fetchall()
+            return results
+
+        except Error as e:
+            print(f"查询执行失败: {e}")
+            raise
+        finally:
+            if cursor:
+                cursor.close()
+
+    def execute_update(self, sql: str, params: Optional[tuple] = None) -> int:
+        """
+        执行更新/插入/删除语句
+
+        Args:
+            sql: SQL 语句
+            params: 参数（可选）
+
+        Returns:
+            int: 受影响的行数
+        """
+        if not self.connection or not self.connection.is_connected():
+            self.connect()
+
+        cursor = None
+        try:
+            cursor = self.connection.cursor()
+            if params:
+                cursor.execute(sql, params)
+            else:
+                cursor.execute(sql)
+
+            self.connection.commit()
+            return cursor.rowcount
+
+        except Error as e:
+            self.connection.rollback()
+            print(f"执行失败，已回滚: {e}")
+            raise
+        finally:
+            if cursor:
+                cursor.close()
+
+    def get_placeholder(self) -> str:
+        """
+        获取参数占位符
+
+        Returns:
+            MySQL 使用 "%s" 作为参数占位符
+        """
+        return "%s"

db/production_contract_data_dao.py

@@ -6,31 +6,14 @@ from the [productionContractData].[26年压力表合同数据] table.
 """
 
 from typing import List, Dict, Any
+from db.base_dao import BaseDAO
 from db.connection import get_connection
+from config.schema import DatabaseType
 
 
-class ProductionContractDataDAO:
+class ProductionContractDataDAO(BaseDAO):
     """Data Access Object for production contract data queries"""
 
-    def __init__(self):
-        self.db = None
-
-    def __enter__(self):
-        """Enter context manager and establish database connection"""
-        self.db = get_connection()
-        self.db.connect()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit context manager and close database connection"""
-        if self.db:
-            self.db.disconnect()
-
-    def close(self):
-        """Close database connection"""
-        if self.db:
-            self.db.disconnect()
-
     def query_by_总排号(self, 总排号_list: List[str]) -> List[Dict[str, Any]]:
         """
         Query production contract data by 总排号 list.
@@ -50,13 +33,27 @@ class ProductionContractDataDAO:
 
         for i in range(0, len(总排号_list), batch_size):
             batch = 总排号_list[i:i + batch_size]
-            placeholders = ','.join(['?' for _ in batch])
+            placeholder = self._get_placeholder()
-            sql = f"""
+            placeholders = ','.join([placeholder for _ in batch])
-            SELECT [总排号], [生产订单号], [序号], [订单号], [客户名称], [产品型号]
+
-            FROM [productionContractData].[26年压力表合同数据]
+            # 根据数据库类型选择表名
-            WHERE [总排号] IN ({placeholders})
+            table_name = self._convert_sql('[productionContractData].[26年压力表合同数据]')
-            ORDER BY [序号]
+
-            """
+            # 根据数据库类型选择列名格式
+            if self._db_type == DatabaseType.MYSQL:
+                sql = f"""
+                SELECT 总排号, 生产订单号, 序号, 订单号, 客户名称, 产品型号
+                FROM {table_name}
+                WHERE 总排号 IN ({placeholders})
+                ORDER BY 序号
+                """
+            else:
+                sql = f"""
+                SELECT [总排号], [生产订单号], [序号], [订单号], [客户名称], [产品型号]
+                FROM {table_name}
+                WHERE [总排号] IN ({placeholders})
+                ORDER BY [序号]
+                """
 
             with get_connection() as db:
                 results = db.execute_query(sql, tuple(batch))

db/sqlserver_connection.py

@@ -0,0 +1,147 @@
+"""
+SQL Server 数据库连接组件
+
+提供 SQL Server 数据库连接和查询接口
+"""
+
+import pyodbc
+from typing import List, Dict, Any, Optional
+from db.base_connection import BaseDatabaseConnection
+
+
+class SQLServerConnection(BaseDatabaseConnection):
+    """SQL Server 数据库连接类"""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        初始化数据库连接
+
+        Args:
+            config: 数据库配置字典
+                - server: 服务器地址
+                - database: 数据库名称
+                - username: 用户名
+                - password: 密码
+                - driver: ODBC 驱动名称
+                - trust_server_certificate: 是否信任服务器证书
+        """
+        super().__init__(config)
+
+    def connect(self) -> pyodbc.Connection:
+        """
+        建立数据库连接
+
+        Returns:
+            pyodbc.Connection: 数据库连接对象
+        """
+        if self.connection is not None:
+            return self.connection
+
+        # 构建连接字符串
+        driver = self.config.get('driver', 'ODBC Driver 18 for SQL Server')
+        conn_str = (
+            f"DRIVER={{{driver}}};"
+            f"SERVER={self.config['server']};"
+            f"DATABASE={self.config['database']};"
+            f"UID={self.config['username']};"
+            f"PWD={self.config['password']};"
+            f"TrustServerCertificate={self.config.get('trust_server_certificate', 'yes')};"
+        )
+
+        try:
+            self.connection = pyodbc.connect(conn_str)
+            print(
+                f"成功连接到 SQL Server 数据库: {self.config['server']}/{self.config['database']}"
+            )
+            return self.connection
+        except pyodbc.Error as e:
+            print(f"SQL Server 数据库连接失败: {e}")
+            raise
+
+    def disconnect(self):
+        """关闭数据库连接"""
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+            print("SQL Server 数据库连接已关闭")
+
+    def execute_query(
+        self, sql: str, params: Optional[tuple] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        执行查询语句并返回结果
+
+        Args:
+            sql: SQL 查询语句
+            params: 查询参数（可选）
+
+        Returns:
+            List[Dict[str, Any]]: 查询结果列表，每个元素为一行数据的字典
+        """
+        if not self.connection:
+            self.connect()
+
+        cursor = self.connection.cursor()
+
+        try:
+            if params:
+                cursor.execute(sql, params)
+            else:
+                cursor.execute(sql)
+
+            # 获取列名
+            columns = [column[0] for column in cursor.description]
+
+            # 将结果转换为字典列表
+            results = []
+            for row in cursor.fetchall():
+                results.append(dict(zip(columns, row)))
+
+            return results
+
+        except pyodbc.Error as e:
+            print(f"查询执行失败: {e}")
+            raise
+        finally:
+            cursor.close()
+
+    def execute_update(self, sql: str, params: Optional[tuple] = None) -> int:
+        """
+        执行更新/插入/删除语句
+
+        Args:
+            sql: SQL 语句
+            params: 参数（可选）
+
+        Returns:
+            int: 受影响的行数
+        """
+        if not self.connection:
+            self.connect()
+
+        cursor = self.connection.cursor()
+
+        try:
+            if params:
+                cursor.execute(sql, params)
+            else:
+                cursor.execute(sql)
+
+            self.connection.commit()
+            return cursor.rowcount
+
+        except pyodbc.Error as e:
+            self.connection.rollback()
+            print(f"执行失败，已回滚: {e}")
+            raise
+        finally:
+            cursor.close()
+
+    def get_placeholder(self) -> str:
+        """
+        获取参数占位符
+
+        Returns:
+            SQL Server 使用 "?" 作为参数占位符
+        """
+        return "?"

db/table_name_converter.py

@@ -0,0 +1,140 @@
+"""
+表名转换工具
+
+处理 SQL Server 和 MySQL 之间的表名格式转换
+"""
+
+import re
+from typing import List
+
+
+class TableNameConverter:
+    """表名转换工具类"""
+
+    # 匹配 SQL Server 表名格式：[schema].[tablename] 或 [schema].[table name]
+    SQLSERVER_PATTERN = re.compile(r'\[([^\]]+)\]\.\[([^\]]+)\]')
+
+    @staticmethod
+    def to_mysql(table_name: str) -> str:
+        """
+        将 SQL Server 表名格式转换为 MySQL 格式
+
+        SQL Server: [schema].[tablename] → MySQL: schema_tablename
+        SQL Server: tablename → MySQL: dbo_tablename (默认 dbo)
+
+        Args:
+            table_name: SQL Server 格式的表名
+
+        Returns:
+            MySQL 格式的表名
+
+        Examples:
+            >>> TableNameConverter.to_mysql('[dbo].[BIPUsers]')
+            'dbo_BIPUsers'
+            >>> TableNameConverter.to_mysql('DiscreteMaterialPlanData')
+            'dbo_DiscreteMaterialPlanData'
+            >>> TableNameConverter.to_mysql('[productionContractData].[26年压力表合同数据]')
+            'productionContractData_26年压力表合同数据'
+        """
+        # 尝试匹配 [schema].[tablename] 格式
+        match = TableNameConverter.SQLSERVER_PATTERN.match(table_name.strip())
+        if match:
+            schema = match.group(1)
+            table = match.group(2)
+            return f"{schema}_{table}"
+
+        # 如果没有匹配到，使用默认 schema dbo
+        return f"dbo_{table_name}"
+
+    @staticmethod
+    def to_sqlserver(table_name: str) -> str:
+        """
+        将 MySQL 表名格式转换为 SQL Server 格式
+
+        MySQL: schema_tablename → SQL Server: [schema].[tablename]
+
+        Args:
+            table_name: MySQL 格式的表名
+
+        Returns:
+            SQL Server 格式的表名
+
+        Examples:
+            >>> TableNameConverter.to_sqlserver('dbo_BIPUsers')
+            '[dbo].[BIPUsers]'
+            >>> TableNameConverter.to_sqlserver('productionContractData_26年压力表合同数据')
+            '[productionContractData].[26年压力表合同数据]'
+        """
+        # 分割第一个下划线
+        parts = table_name.split('_', 1)
+        if len(parts) == 2:
+            schema = parts[0]
+            table = parts[1]
+            return f"[{schema}].[{table}]"
+
+        # 如果没有下划线，使用默认 schema dbo
+        return f"[dbo].[{table_name}]"
+
+    @staticmethod
+    def convert_sql(sql: str, db_type: str) -> str:
+        """
+        批量转换 SQL 语句中的表名
+
+        Args:
+            sql: SQL 语句
+            db_type: 目标数据库类型 ('sqlserver' 或 'mysql')
+
+        Returns:
+            转换后的 SQL 语句
+
+        Examples:
+            >>> sql = "SELECT * FROM [dbo].[BIPUsers] WHERE ID = ?"
+            >>> TableNameConverter.convert_sql(sql, 'mysql')
+            'SELECT * FROM dbo_BIPUsers WHERE ID = ?'
+        """
+        if db_type == 'mysql':
+            # SQL Server → MySQL
+            def replace_to_mysql(match):
+                schema = match.group(1)
+                table = match.group(2)
+                return f"{schema}_{table}"
+            result = TableNameConverter.SQLSERVER_PATTERN.sub(replace_to_mysql, sql)
+            return result
+        elif db_type == 'sqlserver':
+            # MySQL → SQL Server
+            # 首先查找可能的 MySQL 格式表名（schema_table 格式）
+            # 这是一个简化版本，可能无法处理所有边缘情况
+            result = sql
+            # 查找单词字符_单词字符 的模式（可能是表名）
+            mysql_pattern = re.compile(r'\b([a-zA-Z_][a-zA-Z0-9_]*)_([a-zA-Z0-9_\u4e00-\u9fff]+)\b')
+            matches = mysql_pattern.findall(result)
+            for schema, table in set(matches):
+                mysql_name = f"{schema}_{table}"
+                sqlserver_name = f"[{schema}].[{table}]"
+                result = result.replace(mysql_name, sqlserver_name)
+            return result
+        return sql
+
+    @staticmethod
+    def extract_table_names(sql: str) -> List[str]:
+        """
+        从 SQL 语句中提取所有表名
+
+        Args:
+            sql: SQL 语句
+
+        Returns:
+            表名列表
+        """
+        tables = []
+        # 查找 SQL Server 格式
+        sqlserver_matches = TableNameConverter.SQLSERVER_PATTERN.findall(sql)
+        for schema, table in sqlserver_matches:
+            tables.append(f"{schema}_{table}")
+
+        # 查找可能的 MySQL 格式
+        mysql_pattern = re.compile(r'\b[a-zA-Z_][a-zA-Z0-9_]*_[a-zA-Z0-9_]+\b')
+        mysql_matches = mysql_pattern.findall(sql)
+        tables.extend(mysql_matches)
+
+        return list(set(tables))

docs/ENV_MIGRATION.md

@@ -0,0 +1,262 @@
+# .env 配置迁移指南
+
+本文档说明如何将现有的 JSON 配置迁移到 .env 环境变量配置。
+
+## 迁移原因
+
+使用 .env 环境变量配置的优势：
+
+1. **更好的安全性**: .env 文件不会被提交到版本控制（已添加到 .gitignore）
+2. **更灵活的配置**: 可以在不同环境（开发、测试、生产）中使用不同的配置
+3. **标准化**: 遵循 12-factor 应用配置最佳实践
+4. **更简单**: 配置格式更简洁，易于维护
+
+## 迁移步骤
+
+### 方法 1: 从现有 JSON 配置迁移（推荐）
+
+如果你已经有 `config/user_settings.json` 配置文件，可以使用迁移脚本自动转换：
+
+```bash
+python scripts/migrate_to_env.py migrate
+```
+
+该脚本会：
+- 读取 `config/user_settings.json` 文件
+- 创建 `.env` 文件
+- 备份原 JSON 配置到 `config/user_settings.json.backup`
+
+### 方法 2: 从模板创建新的配置
+
+如果是首次配置，从模板创建：
+
+```bash
+python scripts/migrate_to_env.py from-example
+```
+
+该脚本会：
+- 复制 `.env.example` 到 `.env`
+- 提示你编辑 `.env` 文件填入实际配置
+
+### 手动配置
+
+1. 复制 `.env.example` 到 `.env`:
+
+```bash
+cp .env.example .env
+```
+
+2. 编辑 `.env` 文件，填入实际的配置值：
+
+```bash
+# ERP 系统配置
+ERP_URL=https://your-erp-system.com/
+ERP_USERNAME=your_username
+ERP_PASSWORD=your_password
+
+# 数据库配置
+DB_TYPE=sqlserver  # 或 mysql
+DB_SERVER=192.168.1.100
+DB_NAME=YourDatabase
+DB_USERNAME=your_db_username
+DB_PASSWORD=your_db_password
+```
+
+## 配置验证
+
+运行测试脚本验证配置是否正确加载：
+
+```bash
+python tests/test_env_config.py
+```
+
+## 环境变量参考
+
+### ERP 系统配置
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `ERP_URL` | ERP 系统地址 | `https://68.11.34.30:8082/` |
+| `ERP_USERNAME` | ERP 用户名 | `BLDpengqiangqiang` |
+| `ERP_PASSWORD` | ERP 密码 | (必填) |
+| `ERP_HEADLESS` | 无头模式 | `true` |
+| `ERP_IGNORE_HTTPS_ERRORS` | 忽略 HTTPS 错误 | `true` |
+| `ERP_AUTO_CLOSE_BROWSER` | 自动关闭浏览器 | `true` |
+
+### 数据库配置（SQL Server）
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `DB_TYPE` | 数据库类型 | `sqlserver` |
+| `DB_SERVER` | SQL Server 地址 | `192.168.110.114` |
+| `DB_NAME` | 数据库名称 | `CompanyDB` |
+| `DB_USERNAME` | 数据库用户名 | `peng` |
+| `DB_PASSWORD` | 数据库密码 | (必填) |
+| `DB_SQLSERVER_DRIVER` | ODBC 驱动 | `ODBC Driver 18 for SQL Server` |
+| `DB_TRUST_SERVER_CERTIFICATE` | 信任服务器证书 | `yes` |
+
+### 数据库配置（MySQL）
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `DB_TYPE` | 数据库类型 | `mysql` |
+| `DB_MYSQL_HOST` | MySQL 主机地址 | `192.168.31.83` |
+| `DB_MYSQL_PORT` | MySQL 端口 | `3306` |
+| `DB_MYSQL_CHARSET` | 字符集 | `utf8mb4` |
+
+### 路径配置
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `PATH_DATA_DIR` | 数据目录 | `D:/python/playwrite/data/` |
+| `PATH_PRODUCTION_ID_FILE` | Production ID 文件名 | `ProductionID.txt` |
+| `PATH_DEFAULT_OUTPUT` | 默认输出文件名 | `离散备料计划维护_合并.xlsx` |
+| `PATH_VALIDATION_OUTPUT` | 校验输出文件名 | `物料状态校验结果.xlsx` |
+
+### 数据提取配置
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `EXTRACTION_BATCH_SIZE` | 批次大小 | `100` |
+| `EXTRACTION_VERBOSE` | 详细日志 | `true` |
+| `EXTRACTION_AUTO_CONVERT` | 自动转换 Excel | `true` |
+| `EXTRACTION_MERGE_BATCHES` | 合并批次 | `true` |
+| `EXTRACTION_ENABLE_DB_PERSISTENCE` | 保存到数据库 | `false` |
+
+### 校验配置
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| `VALIDATION_DATA_SOURCE` | 数据源类型 | `database_full` |
+| `VALIDATION_USE_DATABASE` | 使用数据库 | `true` |
+| `VALIDATION_BATCH_SIZE` | 数据库批次大小 | `2000` |
+| `VALIDATION_ENABLE_CRUD` | 启用 CRUD 操作 | `false` |
+| `VALIDATION_DEFAULT_MANAGER` | 默认负责人 | (空) |
+| `VALIDATION_MATCH_MODE` | 匹配模式 | `substring` |
+
+## 切换数据库类型
+
+要切换数据库类型，修改 `.env` 文件中的 `DB_TYPE` 变量：
+
+### 切换到 MySQL
+
+```bash
+# 编辑 .env 文件
+DB_TYPE=mysql
+DB_NAME=BLD_DB
+DB_USERNAME=remote_user
+DB_PASSWORD=your_mysql_password
+DB_MYSQL_HOST=192.168.31.83
+DB_MYSQL_PORT=3306
+```
+
+### 切换到 SQL Server
+
+```bash
+# 编辑 .env 文件
+DB_TYPE=sqlserver
+DB_NAME=CompanyDB
+DB_USERNAME=peng
+DB_PASSWORD=your_sqlserver_password
+DB_SERVER=192.168.110.114
+```
+
+## 在代码中使用配置
+
+### 使用 ConfigLoader（推荐）
+
+```python
+from config.loader import ConfigLoader
+
+# 加载配置（自动从环境变量）
+config = ConfigLoader.load()
+
+# 访问配置
+erp_url = config.erp.url
+db_type = config.database.db_type
+```
+
+### 直接从环境变量创建配置
+
+```python
+from config.schema import AppConfig
+
+# 从环境变量创建配置
+config = AppConfig.from_env()
+```
+
+### 使用 ConfigManager（GUI）
+
+```python
+from gui.config_manager import ConfigManager
+
+# 创建配置管理器
+config_manager = ConfigManager(use_env=True)
+
+# 访问配置
+erp_url = config_manager.get("erp.url")
+```
+
+## GUI 设置界面
+
+GUI 设置界面已更新为读写 .env 文件。所有通过界面修改的配置会自动保存到 `.env` 文件。
+
+## 回滚方案
+
+如果迁移后出现问题，可以回滚：
+
+1. 恢复 JSON 配置:
+   ```bash
+   cp config/user_settings.json.backup config/user_settings.json
+   ```
+
+2. 删除 .env 文件:
+   ```bash
+   rm .env
+   ```
+
+3. 修改代码使用 JSON 配置（需要修改 `ConfigManager` 初始化参数）:
+   ```python
+   config_manager = ConfigManager(use_env=False)
+   ```
+
+## 安全注意事项
+
+1. **永远不要将 .env 文件提交到版本控制**
+   - `.env` 已添加到 `.gitignore`
+   - 只提交 `.env.example` 模板文件
+
+2. **保护敏感信息**
+   - 不要在代码中硬编码密码
+   - 使用强密码
+   - 定期更换密码
+
+3. **文件权限**
+   - 确保 .env 文件只有你本人可读
+   - 在 Linux/Mac 上: `chmod 600 .env`
+
+## 故障排除
+
+### 配置未生效
+
+1. 确认 `.env` 文件存在于项目根目录
+2. 检查环境变量名称是否正确（区分大小写）
+3. 重启应用程序以重新加载配置
+
+### 迁移脚本错误
+
+1. 检查 Python 版本（需要 Python 3.8+）
+2. 确保已安装 `python-dotenv`: `pip install python-dotenv`
+3. 查看错误信息并相应解决
+
+### 数据库连接失败
+
+1. 验证数据库配置是否正确
+2. 检查数据库服务是否运行
+3. 确认网络连接正常
+4. 查看数据库驱动是否已安装
+
+## 进一步阅读
+
+- [12-factor App: Config](https://12factor.net/config)
+- [python-dotenv 文档](https://github.com/theskumar/python-dotenv)

gui/config_manager.py

@@ -4,6 +4,7 @@
 配置管理器
 
 负责加载、保存和管理用户配置。
+支持从环境变量和 .env 文件加载配置。
 """
 import os
 from typing import TYPE_CHECKING
@@ -19,15 +20,17 @@ if TYPE_CHECKING:
 class ConfigManager:
     """配置管理器"""
 
-    def __init__(self, config_file: str = "config/user_settings.json"):
+    def __init__(self, config_file: str = "config/user_settings.json", use_env: bool = True):
         """
         初始化配置管理器
 
         Args:
-            config_file: 配置文件路径
+            config_file: 配置文件路径（向后兼容）
+            use_env: 是否使用环境变量，默认为 True
         """
         self.config_file = config_file
-        self.config: AppConfig = ConfigLoader.load(config_file)
+        self.use_env = use_env
+        self.config: AppConfig = ConfigLoader.load(config_file, use_env=use_env)
 
         # 验证配置
         errors = self.config.validate()
@@ -40,10 +43,16 @@ class ConfigManager:
         """
         保存配置到文件
 
+        如果使用环境变量，则保存到 .env 文件
+        否则保存到 JSON 文件（向后兼容）
+
         Returns:
             保存是否成功
         """
-        return ConfigLoader.save(self.config, self.config_file)
+        if self.use_env:
+            return ConfigLoader.save_to_env(self.config, ".env")
+        else:
+            return ConfigLoader.save(self.config, self.config_file)
 
     def get(self, key: str, default=None):
         """
@@ -90,7 +99,7 @@ class ConfigManager:
 
     def reset_to_defaults(self) -> None:
         """重置为默认配置"""
-        self.config = ConfigLoader.load("default")  # 重新加载默认配置
+        self.config = AppConfig.from_env()  # 重新从环境变量加载默认配置
         self.save()
 
     @property

gui/settings_tab.py

@@ -10,6 +10,7 @@ import tkinter as tk
 from tkinter import ttk, messagebox
 import pyodbc
 from gui.config_manager import ConfigManager
+from config.schema import DatabaseType
 
 
 class SettingsTab(ttk.Frame):
@@ -116,35 +117,74 @@ class SettingsTab(ttk.Frame):
         group = ttk.LabelFrame(parent, text="数据库配置", padding=10)
         group.grid(row=1, column=0, columnspan=2, pady=10, padx=10, sticky="ew")
 
-        # 服务器
+        # 数据库类型选择
-        ttk.Label(group, text="服务器:").grid(row=0, column=0, sticky="w", pady=5)
+        ttk.Label(group, text="数据库类型:").grid(row=0, column=0, sticky="w", pady=5)
+        self.db_type_var = tk.StringVar()
+        db_type_combo = ttk.Combobox(
+            group,
+            textvariable=self.db_type_var,
+            values=["sqlserver", "mysql"],
+            state="readonly",
+            width=30,
+        )
+        db_type_combo.grid(row=0, column=1, sticky="w", pady=5)
+        db_type_combo.bind("<<ComboboxSelected>>", self._on_db_type_changed)
+
+        # SQL Server 配置
+        self.sqlserver_frame = ttk.Frame(group)
+        self.sqlserver_frame.grid(row=1, column=0, columnspan=2, sticky="ew", pady=5)
+
+        ttk.Label(self.sqlserver_frame, text="服务器:").grid(row=0, column=0, sticky="w", pady=5)
         self.db_server_var = tk.StringVar()
-        ttk.Entry(group, textvariable=self.db_server_var, width=50).grid(
+        ttk.Entry(self.sqlserver_frame, textvariable=self.db_server_var, width=50).grid(
             row=0, column=1, pady=5, sticky="ew"
         )
 
-        # 数据库名
+        # MySQL 配置
-        ttk.Label(group, text="数据库:").grid(row=1, column=0, sticky="w", pady=5)
+        self.mysql_frame = ttk.Frame(group)
-        self.db_name_var = tk.StringVar()
+
-        ttk.Entry(group, textvariable=self.db_name_var, width=50).grid(
+        ttk.Label(self.mysql_frame, text="主机:").grid(row=0, column=0, sticky="w", pady=5)
-            row=1, column=1, pady=5, sticky="ew"
+        self.mysql_host_var = tk.StringVar()
+        ttk.Entry(self.mysql_frame, textvariable=self.mysql_host_var, width=50).grid(
+            row=0, column=1, pady=5, sticky="ew"
         )
 
-        # 用户名
+        ttk.Label(self.mysql_frame, text="端口:").grid(row=1, column=0, sticky="w", pady=5)
-        ttk.Label(group, text="用户名:").grid(row=2, column=0, sticky="w", pady=5)
+        self.mysql_port_var = tk.IntVar(value=3306)
-        self.db_username_var = tk.StringVar()
+        ttk.Spinbox(
-        ttk.Entry(group, textvariable=self.db_username_var, width=50).grid(
+            self.mysql_frame, from_=1, to=65535, textvariable=self.mysql_port_var, width=10
+        ).grid(row=1, column=1, sticky="w", pady=5)
+
+        # 通用配置（两种数据库都需要）
+        ttk.Label(group, text="数据库:").grid(row=2, column=0, sticky="w", pady=5)
+        self.db_name_var = tk.StringVar()
+        ttk.Entry(group, textvariable=self.db_name_var, width=50).grid(
             row=2, column=1, pady=5, sticky="ew"
         )
 
-        # 密码
+        ttk.Label(group, text="用户名:").grid(row=3, column=0, sticky="w", pady=5)
-        ttk.Label(group, text="密码:").grid(row=3, column=0, sticky="w", pady=5)
+        self.db_username_var = tk.StringVar()
+        ttk.Entry(group, textvariable=self.db_username_var, width=50).grid(
+            row=3, column=1, pady=5, sticky="ew"
+        )
+
+        ttk.Label(group, text="密码:").grid(row=4, column=0, sticky="w", pady=5)
         self.db_password_var = tk.StringVar()
         entry = ttk.Entry(group, textvariable=self.db_password_var, width=50, show="*")
-        entry.grid(row=3, column=1, pady=5, sticky="ew")
+        entry.grid(row=4, column=1, pady=5, sticky="ew")
 
         group.columnconfigure(1, weight=1)
 
+    def _on_db_type_changed(self, event=None):
+        """数据库类型改变时的回调"""
+        db_type = self.db_type_var.get()
+        if db_type == "mysql":
+            self.sqlserver_frame.grid_forget()
+            self.mysql_frame.grid(row=1, column=0, columnspan=2, sticky="ew", pady=5)
+        else:
+            self.mysql_frame.grid_forget()
+            self.sqlserver_frame.grid(row=1, column=0, columnspan=2, sticky="ew", pady=5)
+
     def _create_browser_group(self, parent):
         """创建浏览器配置组"""
         group = ttk.LabelFrame(parent, text="浏览器设置", padding=10)
@@ -224,7 +264,7 @@ class SettingsTab(ttk.Frame):
         # 数据库持久化
         self.enable_db_persistence_var = tk.BooleanVar()
         ttk.Checkbutton(
-            group, text="保存到数据库 (同时写入 SQL Server)", variable=self.enable_db_persistence_var
+            group, text="保存到数据库", variable=self.enable_db_persistence_var
         ).grid(row=4, column=0, columnspan=2, sticky="w", pady=5)
 
     def _create_validation_group(self, parent):
@@ -292,11 +332,23 @@ class SettingsTab(ttk.Frame):
         self.erp_password_var.set(self.config.get("erp.password", ""))
 
         # 数据库设置
-        self.db_server_var.set(self.config.get("database.server", ""))
+        db_type = self.config.get("database.db_type", "sqlserver")
+        self.db_type_var.set(db_type)
+
+        if db_type == "mysql":
+            self.db_server_var.set(self.config.get("database.server", ""))
+            self.mysql_host_var.set(self.config.get("database.mysql.host", ""))
+            self.mysql_port_var.set(self.config.get("database.mysql.port", 3306))
+        else:
+            self.db_server_var.set(self.config.get("database.server", ""))
+
         self.db_name_var.set(self.config.get("database.database", ""))
         self.db_username_var.set(self.config.get("database.username", ""))
         self.db_password_var.set(self.config.get("database.password", ""))
 
+        # 更新界面显示
+        self._on_db_type_changed()
+
         # 浏览器设置（已合并到 ERP 配置中）
         self.browser_headless_var.set(self.config.get("erp.headless", True))
         self.browser_ignore_https_var.set(
@@ -331,7 +383,18 @@ class SettingsTab(ttk.Frame):
         self.config.set("erp.password", self.erp_password_var.get())
 
         # 数据库设置
-        self.config.set("database.server", self.db_server_var.get())
+        db_type = self.db_type_var.get()
+        self.config.set("database.db_type", db_type)
+
+        if db_type == "mysql":
+            # MySQL: 使用 host 字段
+            self.config.set("database.server", self.mysql_host_var.get())
+            self.config.set("database.mysql.host", self.mysql_host_var.get())
+            self.config.set("database.mysql.port", self.mysql_port_var.get())
+        else:
+            # SQL Server: 使用 server 字段
+            self.config.set("database.server", self.db_server_var.get())
+
         self.config.set("database.database", self.db_name_var.get())
         self.config.set("database.username", self.db_username_var.get())
         self.config.set("database.password", self.db_password_var.get())
@@ -368,20 +431,41 @@ class SettingsTab(ttk.Frame):
 
     def test_db_connection(self):
         """测试数据库连接"""
+        db_type = self.db_type_var.get()
+
         try:
-            conn_str = (
+            if db_type == "mysql":
-                f"DRIVER={{ODBC Driver 18 for SQL Server}};"
+                import mysql.connector
-                f"SERVER={self.db_server_var.get()};"
+                from mysql.connector import Error
-                f"DATABASE={self.db_name_var.get()};"
-                f"UID={self.db_username_var.get()};"
-                f"PWD={self.db_password_var.get()};"
-                f"TrustServerCertificate=yes;"
-            )
 
-            conn = pyodbc.connect(conn_str, timeout=5)
+                conn = mysql.connector.connect(
-            conn.close()
+                    host=self.mysql_host_var.get(),
-            messagebox.showinfo("成功", "数据库连接测试成功！")
+                    port=self.mysql_port_var.get(),
+                    database=self.db_name_var.get(),
+                    user=self.db_username_var.get(),
+                    password=self.db_password_var.get(),
+                    connection_timeout=5
+                )
+                conn.close()
+                messagebox.showinfo("成功", "MySQL 数据库连接测试成功！")
+            else:
+                conn_str = (
+                    f"DRIVER={{ODBC Driver 18 for SQL Server}};"
+                    f"SERVER={self.db_server_var.get()};"
+                    f"DATABASE={self.db_name_var.get()};"
+                    f"UID={self.db_username_var.get()};"
+                    f"PWD={self.db_password_var.get()};"
+                    f"TrustServerCertificate=yes;"
+                )
+                conn = pyodbc.connect(conn_str, timeout=5)
+                conn.close()
+                messagebox.showinfo("成功", "SQL Server 数据库连接测试成功！")
 
+        except ImportError:
+            if db_type == "mysql":
+                messagebox.showerror("错误", "未安装 mysql-connector-python，请运行：\npip install mysql-connector-python")
+            else:
+                messagebox.showerror("错误", "未安装 pyodbc，请运行：\npip install pyodbc")
         except Exception as e:
             messagebox.showerror("错误", f"数据库连接失败：\n{str(e)}")
 
@@ -392,7 +476,9 @@ class SettingsTab(ttk.Frame):
 
     def reset_defaults(self):
         """恢复默认设置"""
-        if messagebox.askyesno("确认", "确定要恢复默认设置吗？"):
+        if messagebox.askyesno("确认", "确定要恢复默认设置吗？这将覆盖 .env 文件中的所有配置。"):
-            self.config.reset_to_defaults()
+            from config.schema import AppConfig
+            self.config.config = AppConfig.from_env()  # 重新加载默认配置
+            self.config.save()
             self.load_settings()
             messagebox.showinfo("成功", "已恢复默认设置")

requirements.txt

@@ -8,6 +8,7 @@ playwright==1.57.0
 
 # --- Database ---
 pyodbc>=5.0.0
+mysql-connector-python>=8.0.0
 
 # --- Excel/Data Processing ---
 pandas>=2.0.0
@@ -17,3 +18,4 @@ numpy>=1.24.0
 # --- System Utilities (installed via pip) ---
 python-dateutil>=2.8.0
 pytz>=2023.0
+python-dotenv>=1.0.0

scripts/migrate_to_env.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+配置迁移脚本
+
+将现有的 JSON 配置文件迁移到 .env 环境变量文件
+"""
+import os
+import sys
+import json
+import shutil
+from pathlib import Path
+
+# 添加项目根目录到 sys.path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from config.schema import AppConfig
+
+
+def migrate_json_to_env(
+    json_file: str = "config/user_settings.json",
+    env_file: str = ".env",
+    backup: bool = True
+) -> bool:
+    """
+    迁移 JSON 配置到 .env 文件
+
+    Args:
+        json_file: JSON 配置文件路径
+        env_file: .env 文件路径
+        backup: 是否备份原 JSON 文件
+
+    Returns:
+        迁移是否成功
+    """
+    json_path = project_root / json_file
+    env_path = project_root / env_file
+
+    # 检查 JSON 文件是否存在
+    if not json_path.exists():
+        print(f"❌ JSON 配置文件不存在: {json_path}")
+        print(f"💡 提示: 如果这是首次运行，请复制 .env.example 到 .env 并填入配置")
+        return False
+
+    # 检查 .env 文件是否已存在
+    if env_path.exists():
+        response = input(f"⚠️  .env 文件已存在: {env_path}\n是否覆盖? (y/N): ")
+        if response.lower() != 'y':
+            print("❌ 迁移已取消")
+            return False
+
+        # 备份现有的 .env 文件
+        backup_path = env_path.with_suffix(".env.backup")
+        shutil.copy(env_path, backup_path)
+        print(f"✅ 已备份现有 .env 文件到: {backup_path}")
+
+    try:
+        # 读取 JSON 配置
+        print(f"📖 读取 JSON 配置: {json_path}")
+        with open(json_path, "r", encoding="utf-8") as f:
+            json_data = json.load(f)
+
+        # 使用 ConfigLoader 将字典转换为配置对象
+        from config.loader import ConfigLoader
+        config = ConfigLoader._dict_to_config(json_data)
+
+        # 保存到 .env 文件
+        print(f"💾 保存配置到 .env 文件: {env_path}")
+        success = ConfigLoader.save_to_env(config, env_file)
+
+        if not success:
+            print("❌ 保存 .env 文件失败")
+            return False
+
+        # 备份原 JSON 文件
+        if backup:
+            backup_path = json_path.with_suffix(".json.backup")
+            shutil.copy(json_path, backup_path)
+            print(f"✅ 已备份 JSON 配置到: {backup_path}")
+
+        print("\n✅ 配置迁移成功!")
+        print(f"\n📝 新配置文件: {env_path}")
+        print(f"📦 备份文件: {backup_path if backup else '无'}")
+        print("\n💡 提示:")
+        print("  1. 请检查 .env 文件中的配置是否正确")
+        print("  2. 确保 .env 文件不会被提交到版本控制")
+        print("  3. 可以删除原 JSON 配置文件: " + str(json_path))
+
+        return True
+
+    except json.JSONDecodeError as e:
+        print(f"❌ JSON 解析失败: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ 迁移失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def create_env_from_example(
+    example_file: str = ".env.example",
+    env_file: str = ".env"
+) -> bool:
+    """
+    从 .env.example 创建 .env 文件
+
+    Args:
+        example_file: .env.example 文件路径
+        env_file: .env 文件路径
+
+    Returns:
+        创建是否成功
+    """
+    example_path = project_root / example_file
+    env_path = project_root / env_file
+
+    if not example_path.exists():
+        print(f"❌ .env.example 文件不存在: {example_path}")
+        return False
+
+    if env_path.exists():
+        response = input(f"⚠️  .env 文件已存在: {env_path}\n是否覆盖? (y/N): ")
+        if response.lower() != 'y':
+            print("❌ 操作已取消")
+            return False
+
+    try:
+        shutil.copy(example_path, env_path)
+        print(f"✅ 已从 {example_file} 创建 {env_file}")
+        print("\n💡 提示:")
+        print("  1. 请编辑 .env 文件，填入实际的配置值")
+        print("  2. 特别注意敏感信息（密码、密钥等）")
+        print("  3. 确保 .env 文件不会被提交到版本控制")
+        return True
+    except Exception as e:
+        print(f"❌ 创建失败: {e}")
+        return False
+
+
+def main():
+    """主函数"""
+    print("=" * 60)
+    print("🔄 配置迁移工具 - JSON → .env")
+    print("=" * 60)
+
+    # 检查命令行参数
+    if len(sys.argv) > 1:
+        command = sys.argv[1].lower()
+
+        if command == "from-example":
+            # 从 .env.example 创建
+            print("\n📋 模式: 从 .env.example 创建配置文件")
+            example_file = sys.argv[2] if len(sys.argv) > 2 else ".env.example"
+            env_file = sys.argv[3] if len(sys.argv) > 3 else ".env"
+            create_env_from_example(example_file, env_file)
+            return
+
+        elif command == "migrate":
+            # 从 JSON 迁移
+            print("\n📋 模式: 从 JSON 配置迁移")
+            json_file = sys.argv[2] if len(sys.argv) > 2 else "config/user_settings.json"
+            env_file = sys.argv[3] if len(sys.argv) > 3 else ".env"
+            migrate_json_to_env(json_file, env_file)
+            return
+
+        elif command == "help":
+            print("""
+用法:
+  python scripts/migrate_to_env.py <命令> [参数]
+
+命令:
+  migrate [json_file] [env_file]    从 JSON 配置迁移到 .env
+  from-example [example] [env_file] 从 .env.example 创建配置文件
+  help                              显示此帮助信息
+
+示例:
+  python scripts/migrate_to_env.py migrate
+  python scripts/migrate_to_env.py migrate config/user_settings.json .env
+  python scripts/migrate_to_env.py from-example
+  python scripts/migrate_to_env.py from-example .env.example .env.local
+""")
+            return
+
+    # 交互模式
+    print("\n请选择操作:")
+    print("  1. 从 JSON 配置迁移到 .env")
+    print("  2. 从 .env.example 创建配置文件")
+    print("  3. 退出")
+
+    choice = input("\n请输入选项 (1-3): ").strip()
+
+    if choice == "1":
+        json_file = input("JSON 配置文件路径 (默认: config/user_settings.json): ").strip()
+        if not json_file:
+            json_file = "config/user_settings.json"
+
+        env_file = input(".env 文件路径 (默认: .env): ").strip()
+        if not env_file:
+            env_file = ".env"
+
+        backup_choice = input("是否备份原 JSON 文件? (Y/n): ").strip().lower()
+        backup = backup_choice != 'n'
+
+        migrate_json_to_env(json_file, env_file, backup)
+
+    elif choice == "2":
+        example_file = input(".env.example 文件路径 (默认: .env.example): ").strip()
+        if not example_file:
+            example_file = ".env.example"
+
+        env_file = input(".env 文件路径 (默认: .env): ").strip()
+        if not env_file:
+            env_file = ".env"
+
+        create_env_from_example(example_file, env_file)
+
+    elif choice == "3":
+        print("👋 再见!")
+    else:
+        print("❌ 无效的选项")
+
+
+if __name__ == "__main__":
+    main()