mdbq 3.9.2__py3-none-any.whl → 3.9.4__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '3.9.2'
+VERSION = '3.9.4'

mdbq/mysql/mysql.py

@@ -12,10 +12,14 @@ import os
 import logging
 import logging.handlers
 from mdbq.other import otk
-from typing import Union, List, Dict, Optional, Any, Tuple
+from typing import Union, List, Dict, Optional, Any, Tuple, Set
 from dbutils.pooled_db import PooledDB
 import json
-import psutil  # 用于监控资源使用情况
+import psutil
+from collections import OrderedDict
+import threading
+import concurrent.futures
+from collections import defaultdict
 
 
 warnings.filterwarnings('ignore')
@@ -1111,6 +1115,18 @@ class OptimizeDatas:
             self.connection.close()
 
 
+class StatementCache(OrderedDict):
+    """LRU缓存策略"""
+    def __init__(self, maxsize=100):
+        super().__init__()
+        self.maxsize = maxsize
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        if len(self) > self.maxsize:
+            self.popitem(last=False)
+
+
 class MySQLUploader:
     def __init__(
             self,
@@ -1119,7 +1135,7 @@ class MySQLUploader:
             host: str = 'localhost',
             port: int = 3306,
             charset: str = 'utf8mb4',
-            collation: str = 'utf8mb4_0900_ai_ci',
+            collation: str = 'utf8mb4_0900_ai_ci',  # utf8mb4_0900_ai_ci: 该排序规则对大小写不敏感, utf8mb4_0900_as_cs/utf8mb4_bin: 对大小写敏感
             logging_mode: str = 'console',  # 'both'(控制台+文件), 'console'(仅控制台), 'file'(仅文件), 'none'(禁用)
             log_level: str = 'INFO',  # 默认日志级别
             log_file: str = 'mysql_upload.log',  # 日志文件路径
@@ -1127,7 +1143,7 @@ class MySQLUploader:
             backup_count: int = 5,  # 保留的日志文件数量
             max_retries: int = 10,
             retry_interval: int = 10,
-            pool_size: int = 10,
+            pool_size: int = 5,
             connect_timeout: int = 10,
             read_timeout: int = 30,
             write_timeout: int = 30,
@@ -1168,7 +1184,7 @@ class MySQLUploader:
         self.read_timeout = read_timeout
         self.write_timeout = write_timeout
         self.ssl = ssl
-        self._prepared_statements = {}
+        self._prepared_statements = StatementCache(maxsize=100)
         self._max_cached_statements = 100
         self.enable_metrics = enable_metrics
         self.metrics = {
@@ -1184,6 +1200,11 @@ class MySQLUploader:
             'memory_usage': [],
             'cpu_usage': []
         }
+        self._last_metrics_time = 0
+        self._metrics_cache = {}  # 缓存最近一次的系统指标
+        self.metrics_interval = 30  # 指标采集频率控制
+        self._table_metadata_cache = {}  # 元信息缓存
+        self.metadata_cache_ttl = 300  # 元信息缓存频率控制
 
         # 初始化日志系统
         self._init_logging(logging_mode, log_level, log_file, max_log_size, backup_count)
@@ -1224,6 +1245,10 @@ class MySQLUploader:
                 if record.exc_info:
                     log_data['exception'] = self.formatException(record.exc_info)
 
+                # 过滤敏感信息
+                if hasattr(record, 'password'):
+                    log_data['message'] = log_data['message'].replace(self.password, '***')
+
                 return json.dumps(log_data, ensure_ascii=False)
 
         # 创建日志记录器
@@ -1259,6 +1284,11 @@ class MySQLUploader:
         if not self.enable_metrics:
             return
 
+        # 对于频繁调用的指标，使用更高效的数据结构
+        if metric_name in ('total_uploads', 'successful_uploads', 'failed_uploads'):
+            self.metrics[metric_name] = self.metrics.get(metric_name, 0) + value
+            return
+
         if metric_name not in self.metrics:
             self.metrics[metric_name] = []
 
@@ -1309,9 +1339,20 @@ class MySQLUploader:
         if not self.logger:
             return
 
-        # 记录系统指标
-        metrics = self._get_system_metrics()
-        log_extra = {'metrics': metrics}
+        if len(message) > 500:
+            message = message[:500] + '...'
+
+        now = time.time()
+        if now - self._last_metrics_time > self.metrics_interval:
+            self._metrics_cache = self._get_system_metrics()
+            # 使用缓存的指标
+            log_extra = {'metrics': self._metrics_cache}
+            self._last_metrics_time = now
+        else:
+            # 记录系统指标
+            metrics = self._get_system_metrics()
+            log_extra = {'metrics': metrics}
+
         if extra:
             log_extra.update(extra)
 
@@ -1319,6 +1360,9 @@ class MySQLUploader:
 
     def _create_connection_pool(self) -> PooledDB:
         """创建数据库连接池"""
+        if hasattr(self, 'pool') and self.pool is not None and self._check_pool_health():
+            return self.pool
+
         start_time = time.time()
         self.pool = None
 
@@ -1418,7 +1462,7 @@ class MySQLUploader:
                     if attempt < self.max_retries - 1:
                         wait_time = self.retry_interval * (attempt + 1)
                         error_details['wait_time'] = wait_time
-                        self._log_with_metrics('warning', "数据库操作失败，准备重试", error_details)
+                        self._log_with_metrics('warning', f"数据库操作失败，准备重试 {error_details}", )
                         time.sleep(wait_time)
 
                         # 尝试重新连接
@@ -1432,7 +1476,7 @@ class MySQLUploader:
                     else:
                         elapsed = time.time() - start_time
                         error_details['time_elapsed'] = elapsed
-                        self._log_with_metrics('error', "操作最终失败", error_details)
+                        self._log_with_metrics('error', f"操作最终失败 {error_details}")
 
                 except pymysql.IntegrityError as e:
                     elapsed = time.time() - start_time
@@ -1469,7 +1513,7 @@ class MySQLUploader:
             self._log_with_metrics('debug', "获取数据库连接")
             return conn
         except Exception as e:
-            self._log_with_metrics("error", str(e))
+            self._log_with_metrics("error", f'{e}')
             raise ConnectionError(f"连接数据库失败: {str(e)}")
 
     def _check_database_exists(self, db_name: str) -> bool:
@@ -1515,12 +1559,14 @@ class MySQLUploader:
         :raises ValueError: 如果日期格式无效或分表方式无效
         """
         try:
-            date_obj = datetime.datetime.strptime(date_value, '%Y-%m-%d %H:%M:%S')
+            # date_obj = datetime.datetime.strptime(date_value, '%Y-%m-%d %H:%M:%S')
+            date_obj = self._validate_datetime(date_value, True)
         except ValueError:
             try:
-                date_obj = datetime.datetime.strptime(date_value, '%Y-%m-%d')
+                # date_obj = datetime.datetime.strptime(date_value, '%Y-%m-%d')
+                date_obj = self._validate_datetime(date_value, True)
             except ValueError:
-                error_msg = f"无效的日期格式: {date_value}"
+                error_msg = f"无效的日期格式1: {date_value}"
                 self._log_with_metrics('error', error_msg)
                 raise ValueError(error_msg)
 
@@ -1567,24 +1613,33 @@ class MySQLUploader:
 
     def _check_table_exists(self, db_name: str, table_name: str) -> bool:
         """检查表是否存在"""
+        cache_key = f"{db_name}.{table_name}"
+        if cache_key in self._table_metadata_cache:
+            cached_time, result = self._table_metadata_cache[cache_key]
+            if time.time() - cached_time < self.metadata_cache_ttl:
+                return result
+
         db_name = self._validate_identifier(db_name)
         table_name = self._validate_identifier(table_name)
         sql = """
-        SELECT TABLE_NAME 
-        FROM INFORMATION_SCHEMA.TABLES 
-        WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
-        """
+                SELECT TABLE_NAME 
+                FROM INFORMATION_SCHEMA.TABLES 
+                WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
+                """
 
         try:
             with self._get_connection() as conn:
                 with conn.cursor() as cursor:
                     cursor.execute(sql, (db_name, table_name))
-                    exists = bool(cursor.fetchone())
-                    return exists
+                    result = bool(cursor.fetchone())
         except Exception as e:
             self._log_with_metrics('error', f"检查数据表是否存在时发生未知错误: {e}", )
             raise
 
+        # 执行查询并缓存结果
+        self._table_metadata_cache[cache_key] = (time.time(), result)
+        return result
+
     def _create_table(
             self,
             db_name: str,
@@ -1691,7 +1746,8 @@ class MySQLUploader:
             conn.rollback()
             raise
 
-    def _validate_datetime(self, value):
+    def _validate_datetime(self, value, date_type=False):
+        """date_type: 返回字符串类型或者日期类型"""
         formats = [
             '%Y-%m-%d %H:%M:%S',
             '%Y-%m-%d',
@@ -1699,14 +1755,20 @@ class MySQLUploader:
             '%Y/%m/%d',
             '%Y%m%d',
             '%Y-%m-%dT%H:%M:%S',
-            '%Y-%m-%d %H:%M:%S.%f'
+            '%Y-%m-%d %H:%M:%S.%f',
+            '%Y/%-m/%-d',  # 2023/1/8
+            '%Y-%m-%-d',  # 2023-01-8
+            '%Y-%-m-%-d'  # 2023-1-8
         ]
         for fmt in formats:
             try:
-                return datetime.datetime.strptime(value, fmt).strftime('%Y-%m-%d %H:%M:%S')
+                if date_type:
+                    return pd.to_datetime(datetime.datetime.strptime(value, fmt).strftime('%Y-%m-%d'))
+                else:
+                    return datetime.datetime.strptime(value, fmt).strftime('%Y-%m-%d %H:%M:%S')
             except ValueError:
                 continue
-        raise ValueError(f"无效的日期格式: {value}")
+        raise ValueError(f"无效的日期格式2: {value}")
 
     def _validate_value(self, value: Any, column_type: str) -> Any:
         """
@@ -1724,7 +1786,9 @@ class MySQLUploader:
             column_type_lower = column_type.lower()
 
             if 'int' in column_type_lower:
-                return int(value) if value is not None else None
+                if isinstance(value, (str, bytes)) and not value.strip().isdigit():
+                    raise ValueError("非数字字符串无法转换为整数")
+                return int(value)
             elif any(t in column_type_lower for t in ['float', 'double', 'decimal']):
                 return float(value) if value is not None else None
             elif '日期' in column_type_lower or 'time' in column_type_lower:
@@ -1819,6 +1883,58 @@ class MySQLUploader:
             check_duplicate, duplicate_columns
         )
 
+    def _infer_data_type(self, value: Any) -> str:
+        """
+        根据值推断合适的数据类型
+
+        :param value: 要推断的值
+        :return: MySQL数据类型字符串
+        """
+        if value is None:
+            return 'VARCHAR(255)'  # 默认字符串类型
+
+        if isinstance(value, bool):
+            return 'TINYINT(1)'
+        elif isinstance(value, int):
+            # if -128 <= value <= 127:
+            #     return 'TINYINT'
+            # elif -32768 <= value <= 32767:
+            #     return 'SMALLINT'
+            # elif -8388608 <= value <= 8388607:
+            #     return 'MEDIUMINT'
+            if -2147483648 <= value <= 2147483647:
+                return 'INT'
+            else:
+                return 'BIGINT'
+        elif isinstance(value, float):
+            return 'DECIMAL(10,2)'
+        elif isinstance(value, (datetime.datetime, pd.Timestamp)):
+            return 'DATETIME'
+        elif isinstance(value, datetime.date):
+            return 'DATE'
+        elif isinstance(value, (list, dict)):
+            return 'JSON'
+        elif isinstance(value, str):
+            # 尝试判断是否是日期时间
+            try:
+                self._validate_datetime(value)
+                return 'DATETIME'
+            except ValueError:
+                pass
+
+            # 根据字符串长度选择合适类型
+            length = len(value)
+            if length <= 255:
+                return 'VARCHAR(255)'
+            elif length <= 65535:
+                return 'TEXT'
+            elif length <= 16777215:
+                return 'MEDIUMTEXT'
+            else:
+                return 'LONGTEXT'
+        else:
+            return 'VARCHAR(255)'
+
     def _prepare_data(
             self,
             data: Union[Dict, List[Dict], pd.DataFrame],
@@ -1831,27 +1947,57 @@ class MySQLUploader:
         :param data: 输入数据
         :param set_typ: 列名和数据类型字典 {列名: 数据类型}
         :param allow_null: 是否允许空值
-        :return: 准备好的数据列表
+        :return: 待上传的数据列表和对应的数据类型
         :raises ValueError: 如果数据验证失败
         """
         # 统一数据格式为字典列表
         if isinstance(data, pd.DataFrame):
             try:
+                # 将列名转为小写
+                data.columns = [col.lower() for col in data.columns]
                 data = data.replace({pd.NA: None}).to_dict('records')
             except Exception as e:
-                self._log_with_metrics("error", f"转为为字典时发生错误: {e}", )
-                raise ValueError(f"转为为字典时发生错误: {e}")
+                self._log_with_metrics("error", f"数据转字典时发生错误: {e}", )
+                raise ValueError(f"数据转字典时发生错误: {e}")
         elif isinstance(data, dict):
-            data = [data]
-        elif not isinstance(data, list) or not all(isinstance(item, dict) for item in data):
-            error_msg = "Data must be a dict, list of dicts, or DataFrame"
+            data = [{k.lower(): v for k, v in data.items()}]
+        elif isinstance(data, list) and all(isinstance(item, dict) for item in data):
+            # 将列表中的每个字典键转为小写
+            data = [{k.lower(): v for k, v in item.items()} for item in data]
+        else:
+            error_msg = "数据结构必须是字典、列表、字典列表或dataframe"
             self._log_with_metrics('error', error_msg)
             raise ValueError(error_msg)
 
+        # 将set_typ的键转为小写
+        set_typ = {k.lower(): v for k, v in set_typ.items()}
+
+        # 获取数据中实际存在的列名
+        data_columns = set()
+        if data:
+            data_columns = set(data[0].keys())
+
+        # 过滤set_typ，只保留数据中存在的列
+        filtered_set_typ = {}
+        for col in data_columns:
+            if col in set_typ:
+                filtered_set_typ[col] = set_typ[col]
+            else:
+                # 如果列不在set_typ中，尝试推断类型
+                sample_values = [row[col] for row in data if col in row and row[col] is not None][:10]
+                if sample_values:
+                    inferred_type = self._infer_data_type(sample_values[0])
+                    filtered_set_typ[col] = inferred_type
+                    self._log_with_metrics('debug', f"自动推断列'{col}'的数据类型为: {inferred_type}")
+                else:
+                    # 没有样本值，使用默认类型
+                    filtered_set_typ[col] = 'VARCHAR(255)'
+                    self._log_with_metrics('debug', f"为列'{col}'使用默认数据类型: VARCHAR(255)")
+
         prepared_data = []
         for row_idx, row in enumerate(data, 1):
             prepared_row = {}
-            for col_name, col_type in set_typ.items():
+            for col_name in filtered_set_typ:
                 # 跳过id列，不允许外部传入id
                 if col_name.lower() == 'id':
                     continue
@@ -1864,7 +2010,7 @@ class MySQLUploader:
                     prepared_row[col_name] = None
                 else:
                     try:
-                        prepared_row[col_name] = self._validate_value(row[col_name], col_type)
+                        prepared_row[col_name] = self._validate_value(row[col_name], filtered_set_typ[col_name])
                     except ValueError as e:
                         error_msg = f"Row {row_idx}, column '{col_name}': {str(e)}"
                         self._log_with_metrics('error', error_msg)
@@ -1872,7 +2018,7 @@ class MySQLUploader:
             prepared_data.append(prepared_row)
 
         self._log_with_metrics('debug', f"已准备 {len(prepared_data)} 行数据")
-        return prepared_data
+        return prepared_data, filtered_set_typ
 
     def upload_data(
             self,
@@ -1913,7 +2059,7 @@ class MySQLUploader:
         try:
             # 验证参数
             if not set_typ:
-                error_msg = "必须指定列定义"
+                error_msg = "列的数据类型缺失"
                 self._log_with_metrics('error', error_msg)
                 raise ValueError(error_msg)
 
@@ -1923,7 +2069,7 @@ class MySQLUploader:
                 raise ValueError(error_msg)
 
             # 准备数据
-            prepared_data = self._prepare_data(data, set_typ, allow_null)
+            prepared_data, set_typ = self._prepare_data(data, set_typ, allow_null)
 
             # 检查数据库是否存在
             if not self._check_database_exists(db_name):
@@ -2019,7 +2165,17 @@ class MySQLUploader:
             batch_id: Optional[str] = None
     ):
         """
-        插入数据到表中，增强日志记录和性能监控
+        插入数据到表中
+
+        参数:
+        db_name: 数据库名
+        table_name: 表名
+        data: 要插入的数据列表
+        set_typ: 列名和数据类型字典 {列名: 数据类型}
+        check_duplicate: 是否检查重复
+        duplicate_columns: 用于检查重复的列(为空时检查所有列)
+        batch_size: 批量插入大小
+        batch_id: 批次ID用于日志追踪
         """
         if not data:
             return
@@ -2033,27 +2189,40 @@ class MySQLUploader:
         if check_duplicate:
             if not duplicate_columns:
                 duplicate_columns = all_columns
+            else:
+                duplicate_columns = [col for col in duplicate_columns if col != 'id']
+
+            conditions = []
+            for col in duplicate_columns:
+                col_type = set_typ.get(col, '').lower()
+
+                # 处理DECIMAL类型，使用ROUND确保精度一致
+                if col_type.startswith('decimal'):
+                    # 提取小数位数，如DECIMAL(10,2)提取2
+                    scale_match = re.search(r'decimal\(\d+,(\d+)\)', col_type)
+                    scale = int(scale_match.group(1)) if scale_match else 2
+                    conditions.append(f"ROUND(`{self._validate_identifier(col)}`, {scale}) = ROUND(%s, {scale})")
+                else:
+                    conditions.append(f"`{self._validate_identifier(col)}` = %s")
 
-            safe_dup_columns = [self._validate_identifier(col) for col in duplicate_columns]
-            conditions = [f"`{col}` = %s" for col in safe_dup_columns]
             where_clause = " AND ".join(conditions)
 
             sql = f"""
-            INSERT INTO `{db_name}`.`{table_name}` 
-            (`{'`,`'.join(safe_columns)}`) 
-            SELECT {placeholders}
-            FROM DUAL
-            WHERE NOT EXISTS (
-                SELECT 1 FROM `{db_name}`.`{table_name}`
-                WHERE {where_clause}
-            )
-            """
+                    INSERT INTO `{db_name}`.`{table_name}` 
+                    (`{'`,`'.join(safe_columns)}`) 
+                    SELECT {placeholders}
+                    FROM DUAL
+                    WHERE NOT EXISTS (
+                        SELECT 1 FROM `{db_name}`.`{table_name}`
+                        WHERE {where_clause}
+                    )
+                    """
         else:
             sql = f"""
-            INSERT INTO `{db_name}`.`{table_name}` 
-            (`{'`,`'.join(safe_columns)}`) 
-            VALUES ({placeholders})
-            """
+                INSERT INTO `{db_name}`.`{table_name}` 
+                (`{'`,`'.join(safe_columns)}`) 
+                VALUES ({placeholders})
+                """
 
         total_inserted = 0
         total_skipped = 0
@@ -2069,7 +2238,9 @@ class MySQLUploader:
 
                     for row in batch:
                         try:
+                            # 准备参数
                             row_values = [row.get(col) for col in all_columns]
+                            # 如果是排重检查，添加排重列值
                             if check_duplicate:
                                 row_values += [row.get(col) for col in duplicate_columns]
 
@@ -2086,11 +2257,13 @@ class MySQLUploader:
                                 'batch_id': batch_id,
                                 'database': db_name,
                                 'table': table_name,
-                                'row_data': row,
                                 'error_type': type(e).__name__,
-                                'error_message': str(e)
+                                'error_message': str(e),
+                                'column_types': set_typ,
+                                'duplicate_check': check_duplicate,
+                                'duplicate_columns': duplicate_columns
                             }
-                            self._log_with_metrics('error', "单行插入失败", error_details)
+                            self._log_with_metrics('error', f"单行插入失败: {error_details}")
                             continue  # 跳过当前行，继续处理下一行
 
                     # 更新统计信息
@@ -2115,7 +2288,7 @@ class MySQLUploader:
                         'time_elapsed': batch_elapsed,
                         'rows_per_second': successful_rows / batch_elapsed if batch_elapsed > 0 else 0
                     }
-                    self._log_with_metrics('debug', "批次处理完成", batch_info)
+                    self._log_with_metrics('debug', f"批次处理完成 {batch_info}")
 
         # 更新全局指标
         self.metrics['failed_rows'] += total_failed
@@ -2178,37 +2351,681 @@ class MySQLUploader:
             if hasattr(self, 'logger') and self.logger and self.enable_metrics:
                 self._log_with_metrics('debug', "最终性能指标", self.get_metrics())
 
-def __main__():
-    pass
+    def _check_pool_health(self):
+        """定期检查连接池健康状态"""
+        try:
+            conn = self.pool.connection()
+            conn.ping(reconnect=True)
+            conn.close()
+            return True
+        except Exception:
+            self._log_with_metrics('warning', "连接池健康检查失败", {
+                'error': str(e)
+            })
+            return False
+
+    def retry_on_failure(max_retries=3, delay=1):
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                last_exception = None
+                for attempt in range(max_retries):
+                    try:
+                        return func(*args, **kwargs)
+                    except (pymysql.OperationalError, pymysql.InterfaceError) as e:
+                        last_exception = e
+                        if attempt < max_retries - 1:
+                            time.sleep(delay * (attempt + 1))
+                            continue
+                        raise MySQLUploaderError(f"操作重试{max_retries}次后失败") from e
+                    except Exception as e:
+                        raise MySQLUploaderError(f"操作失败: {str(e)}") from e
+                raise last_exception if last_exception else MySQLUploaderError("未知错误")
 
+            return wrapper
 
-if __name__ == '__main__':
-    pass
+        return decorator
+
+
+class MySQLDeduplicator:
+    """
+    MySQL数据去重
+
+    功能：
+    1. 自动检测并删除MySQL数据库中的重复数据
+    2. 支持全库扫描或指定表处理
+    3. 支持多线程/多进程安全处理
+    4. 完善的错误处理和日志记录
+
+    使用示例：
+    deduplicator = MySQLDeduplicator(
+        username='root',
+        password='password',
+        host='localhost',
+        port=3306
+    )
+
+    # 全库去重
+    deduplicator.deduplicate_all()
+
+    # 指定数据库去重(多线程)
+    deduplicator.deduplicate_database('my_db', parallel=True)
+
+    # 指定表去重(使用特定列)
+    deduplicator.deduplicate_table('my_db', 'my_table', columns=['name', 'date'])
+
+    # 关闭连接
+    deduplicator.close()
+    """
+
+    def __init__(
+            self,
+            username: str,
+            password: str,
+            host: str = 'localhost',
+            port: int = 3306,
+            charset: str = 'utf8mb4',
+            max_workers: int = 1,
+            batch_size: int = 1000,
+            skip_system_dbs: bool = True,
+            logging_mode: str = 'console',
+            log_level: str = 'INFO',
+            log_file: str = 'mysql_deduplicate.log',
+            max_retries: int = 3,
+            retry_interval: int = 5,
+            pool_size: int = 5
+    ):
+        """
+        初始化去重处理器
+
+        :param username: 数据库用户名
+        :param password: 数据库密码
+        :param host: 数据库主机，默认为localhost
+        :param port: 数据库端口，默认为3306
+        :param charset: 字符集，默认为utf8mb4
+        :param max_workers: 最大工作线程数，默认为1(单线程)
+        :param batch_size: 批量处理大小，默认为1000
+        :param skip_system_dbs: 是否跳过系统数据库，默认为True
+        :param logging_mode: 日志模式('console', 'file', 'both', 'none')
+        :param log_level: 日志级别('DEBUG', 'INFO', 'WARNING', 'ERROR')
+        :param log_file: 日志文件路径
+        :param max_retries: 最大重试次数
+        :param retry_interval: 重试间隔(秒)
+        :param pool_size: 连接池大小
+        """
+        # 初始化连接池
+        self.pool = PooledDB(
+            creator=pymysql,
+            host=host,
+            port=port,
+            user=username,
+            password=password,
+            charset=charset,
+            maxconnections=pool_size,
+            cursorclass=pymysql.cursors.DictCursor
+        )
+
+        # 配置参数
+        self.max_workers = max(1, min(max_workers, 20))  # 限制最大线程数
+        self.batch_size = batch_size
+        self.skip_system_dbs = skip_system_dbs
+        self.max_retries = max_retries
+        self.retry_interval = retry_interval
+
+        # 线程安全控制
+        self._lock = threading.Lock()
+        self._processing_tables = set()  # 正在处理的表集合
+
+        # 初始化日志
+        self._init_logging(logging_mode, log_level, log_file)
+
+        # 系统数据库列表
+        self.SYSTEM_DATABASES = {
+            'information_schema', 'mysql',
+            'performance_schema', 'sys'
+        }
+
+    def _init_logging(
+            self,
+            logging_mode: str,
+            log_level: str,
+            log_file: str
+    ):
+        """初始化日志配置"""
+        self.logger = logging.getLogger('mysql_deduplicator')
+        self.logger.setLevel(log_level.upper())
+
+        # 防止重复添加handler
+        if self.logger.handlers:
+            for handler in self.logger.handlers[:]:
+                self.logger.removeHandler(handler)
+
+        formatter = logging.Formatter(
+            '%(asctime)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+
+        mode = logging_mode.lower()
+        if mode in ('both', 'console'):
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+
+        if mode in ('both', 'file'):
+            file_handler = logging.FileHandler(
+                filename=log_file,
+                encoding='utf-8'
+            )
+            file_handler.setFormatter(formatter)
+            self.logger.addHandler(file_handler)
+
+    def _log(self, level: str, message: str, extra: Optional[Dict] = None):
+        """统一的日志记录方法"""
+        if not hasattr(self.logger, level.lower()):
+            return
+
+        # 简化日志内容，避免过长
+        if len(message) > 500:
+            message = message[:500] + '...'
+
+        log_method = getattr(self.logger, level.lower())
+        log_method(message, extra=extra)
+
+    def _get_connection(self):
+        """从连接池获取连接"""
+        try:
+            conn = self.pool.connection()
+            self._log('debug', "成功获取数据库连接")
+            return conn
+        except Exception as e:
+            self._log('error', f"获取数据库连接失败: {str(e)}")
+            raise ConnectionError(f"连接数据库失败: {str(e)}")
+
+    @staticmethod
+    def _retry_on_failure(func):
+        """重试装饰器"""
+
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            last_exception = None
+            for attempt in range(self.max_retries + 1):
+                try:
+                    return func(self, *args, **kwargs)
+                except (pymysql.OperationalError, pymysql.InterfaceError) as e:
+                    last_exception = e
+                    if attempt < self.max_retries:
+                        wait_time = self.retry_interval * (attempt + 1)
+                        self._log('warning',
+                                  f"数据库操作失败，准备重试 (尝试 {attempt + 1}/{self.max_retries})",
+                                  {'error': str(e), 'wait_time': wait_time})
+                        time.sleep(wait_time)
+                        continue
+                except Exception as e:
+                    last_exception = e
+                    self._log('error',
+                              f"操作失败: {str(e)}",
+                              {'error_type': type(e).__name__})
+                    break
+
+            if last_exception:
+                raise last_exception
+            raise Exception("未知错误")
+
+        return wrapper
+
+    @_retry_on_failure
+    def _get_databases(self) -> List[str]:
+        """获取所有非系统数据库列表"""
+        sql = "SHOW DATABASES"
+
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(sql)
+                all_dbs = [row['Database'] for row in cursor.fetchall()]
+
+                if self.skip_system_dbs:
+                    return [db for db in all_dbs if db.lower() not in self.SYSTEM_DATABASES]
+                return all_dbs
+
+    @_retry_on_failure
+    def _get_tables(self, database: str) -> List[str]:
+        """获取指定数据库的所有表"""
+        sql = "SHOW TABLES"
+
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(f"USE `{database}`")
+                cursor.execute(sql)
+                return [row[f'Tables_in_{database}'] for row in cursor.fetchall()]
+
+    @_retry_on_failure
+    def _get_table_columns(self, database: str, table: str) -> List[str]:
+        """获取表的列名(排除id列)"""
+        sql = """
+        SELECT COLUMN_NAME 
+        FROM INFORMATION_SCHEMA.COLUMNS 
+        WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
+        ORDER BY ORDINAL_POSITION
+        """
+
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(sql, (database, table))
+                return [row['COLUMN_NAME'] for row in cursor.fetchall()
+                        if row['COLUMN_NAME'].lower() != 'id']
+
+    def _acquire_table_lock(self, database: str, table: str) -> bool:
+        """获取表处理锁，防止并发处理同一张表"""
+        key = f"{database}.{table}"
+
+        with self._lock:
+            if key in self._processing_tables:
+                self._log('debug', f"表 {key} 正在被其他线程处理，跳过")
+                return False
+            self._processing_tables.add(key)
+            return True
+
+    def _release_table_lock(self, database: str, table: str):
+        """释放表处理锁"""
+        key = f"{database}.{table}"
+
+        with self._lock:
+            if key in self._processing_tables:
+                self._processing_tables.remove(key)
+
+    def _deduplicate_table(
+            self,
+            database: str,
+            table: str,
+            columns: Optional[List[str]] = None,
+            dry_run: bool = False
+    ) -> Tuple[int, int]:
+        """
+        执行单表去重
+
+        :param database: 数据库名
+        :param table: 表名
+        :param columns: 用于去重的列(为None时使用所有列)
+        :param dry_run: 是否模拟运行(只统计不实际删除)
+        :return: (重复行数, 删除行数)
+        """
+        if not self._acquire_table_lock(database, table):
+            return (0, 0)
+
+        try:
+            self._log('info', f"开始处理表: {database}.{table}")
+
+            # 获取实际列名
+            all_columns = self._get_table_columns(database, table)
+            if not all_columns:
+                self._log('warning', f"表 {database}.{table} 没有有效列(可能只有id列)，跳过")
+                return (0, 0)
+
+            # 使用指定列或所有列
+            use_columns = columns or all_columns
+            invalid_columns = set(use_columns) - set(all_columns)
+
+            if invalid_columns:
+                self._log('warning',
+                          f"表 {database}.{table} 中不存在以下列: {invalid_columns}，使用有效列",
+                          {'invalid_columns': invalid_columns}
+                          )
+                use_columns = [col for col in use_columns if col in all_columns]
+
+            if not use_columns:
+                self._log('error', f"表 {database}.{table} 没有有效的去重列")
+                return (0, 0)
+
+            # 构建去重SQL
+            column_list = ', '.join([f'`{col}`' for col in use_columns])
+            temp_table = f"temp_{table}_{int(time.time())}"
+
+            # 使用临时表方案处理去重，避免锁表问题
+            create_temp_sql = f"""
+            CREATE TABLE `{database}`.`{temp_table}` AS
+            SELECT MIN(`id`) as `min_id`, {column_list}, COUNT(*) as `dup_count`
+            FROM `{database}`.`{table}`
+            GROUP BY {column_list}
+            HAVING COUNT(*) > 1
+            """
+
+            delete_dup_sql = f"""
+            DELETE FROM `{database}`.`{table}`
+            WHERE `id` NOT IN (
+                SELECT `min_id` FROM `{database}`.`{temp_table}`
+            ) AND ({' OR '.join([f'`{col}` IS NOT NULL' for col in use_columns])})
+            """
+
+            drop_temp_sql = f"DROP TABLE IF EXISTS `{database}`.`{temp_table}`"
+
+            with self._get_connection() as conn:
+                with conn.cursor() as cursor:
+                    # 创建临时表统计重复数据
+                    cursor.execute(create_temp_sql)
+                    cursor.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{temp_table}`")
+                    dup_count = cursor.fetchone()['cnt']
+
+                    if dup_count == 0:
+                        self._log('info', f"表 {database}.{table} 没有重复数据")
+                        cursor.execute(drop_temp_sql)
+                        conn.commit()
+                        return (0, 0)
+
+                    self._log('info',
+                              f"表 {database}.{table} 发现 {dup_count} 组重复数据",
+                              {'columns': use_columns}
+                              )
+
+                    if not dry_run:
+                        # 执行实际删除
+                        cursor.execute(delete_dup_sql)
+                        affected_rows = cursor.rowcount
+                        conn.commit()
+                        self._log('info',
+                                  f"表 {database}.{table} 已删除 {affected_rows} 行重复数据",
+                                  {'columns': use_columns}
+                                  )
+                    else:
+                        affected_rows = 0
+                        self._log('info',
+                                  f"[模拟运行] 表 {database}.{table} 将删除 {dup_count} 组重复数据",
+                                  {'columns': use_columns}
+                                  )
+
+                    # 清理临时表
+                    cursor.execute(drop_temp_sql)
+                    conn.commit()
+
+                    return (dup_count, affected_rows)
+
+        except Exception as e:
+            self._log('error',
+                      f"处理表 {database}.{table} 时出错: {str(e)}",
+                      {'error_type': type(e).__name__}
+                      )
+            return (0, 0)
+        finally:
+            self._release_table_lock(database, table)
+
+    def deduplicate_table(
+            self,
+            database: str,
+            table: str,
+            columns: Optional[List[str]] = None,
+            dry_run: bool = False
+    ) -> Tuple[int, int]:
+        """
+        对指定表进行去重
+
+        :param database: 数据库名
+        :param table: 表名
+        :param columns: 用于去重的列(为None时使用所有列)
+        :param dry_run: 是否模拟运行(只统计不实际删除)
+        :return: (重复行数, 删除行数)
+        """
+        try:
+            # 检查表是否存在
+            if not self._check_table_exists(database, table):
+                self._log('warning', f"表 {database}.{table} 不存在，跳过")
+                return (0, 0)
+
+            return self._deduplicate_table(database, table, columns, dry_run)
+        except Exception as e:
+            self._log('error',
+                      f"处理表 {database}.{table} 时发生全局错误: {str(e)}",
+                      {'error_type': type(e).__name__}
+                      )
+            return (0, 0)
+
+    def deduplicate_database(
+            self,
+            database: str,
+            tables: Optional[List[str]] = None,
+            columns_map: Optional[Dict[str, List[str]]] = None,
+            dry_run: bool = False,
+            parallel: bool = False
+    ) -> Dict[str, Tuple[int, int]]:
+        """
+        对指定数据库的所有表进行去重
+
+        :param database: 数据库名
+        :param tables: 要处理的表列表(为None时处理所有表)
+        :param columns_map: 各表使用的去重列 {表名: [列名]}
+        :param dry_run: 是否模拟运行
+        :param parallel: 是否并行处理
+        :return: 字典 {表名: (重复行数, 删除行数)}
+        """
+        results = {}
+
+        try:
+            # 检查数据库是否存在
+            if not self._check_database_exists(database):
+                self._log('warning', f"数据库 {database} 不存在，跳过")
+                return results
+
+            # 获取要处理的表
+            target_tables = tables or self._get_tables(database)
+            if not target_tables:
+                self._log('info', f"数据库 {database} 中没有表，跳过")
+                return results
+
+            self._log('info',
+                      f"开始处理数据库 {database} 中的 {len(target_tables)} 张表",
+                      {'tables': target_tables}
+                      )
+
+            if parallel and self.max_workers > 1:
+                # 并行处理
+                with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=self.max_workers
+                ) as executor:
+                    futures = {}
+                    for table in target_tables:
+                        columns = columns_map.get(table) if columns_map else None
+                        futures[executor.submit(
+                            self.deduplicate_table,
+                            database, table, columns, dry_run
+                        )] = table
+
+                    for future in concurrent.futures.as_completed(futures):
+                        table = futures[future]
+                        try:
+                            dup_count, affected_rows = future.result()
+                            results[table] = (dup_count, affected_rows)
+                        except Exception as e:
+                            self._log('error',
+                                      f"处理表 {database}.{table} 时出错: {str(e)}",
+                                      {'error_type': type(e).__name__}
+                                      )
+                            results[table] = (0, 0)
+            else:
+                # 串行处理
+                for table in target_tables:
+                    columns = columns_map.get(table) if columns_map else None
+                    dup_count, affected_rows = self.deduplicate_table(
+                        database, table, columns, dry_run
+                    )
+                    results[table] = (dup_count, affected_rows)
 
-    # 初始化上传器
+            # 统计结果
+            total_dup = sum(r[0] for r in results.values())
+            total_del = sum(r[1] for r in results.values())
+
+            self._log('info',
+                      f"数据库 {database} 处理完成 - 共发现 {total_dup} 组重复数据，删除 {total_del} 行",
+                      {'results': results}
+                      )
+
+            return results
+
+        except Exception as e:
+            self._log('error',
+                      f"处理数据库 {database} 时发生全局错误: {str(e)}",
+                      {'error_type': type(e).__name__}
+                      )
+            return results
+
+    def deduplicate_all(
+            self,
+            databases: Optional[List[str]] = None,
+            tables_map: Optional[Dict[str, List[str]]] = None,
+            columns_map: Optional[Dict[str, Dict[str, List[str]]]] = None,
+            dry_run: bool = False,
+            parallel: bool = False
+    ) -> Dict[str, Dict[str, Tuple[int, int]]]:
+        """
+        对所有数据库进行去重
+
+        :param databases: 要处理的数据库列表(为None时处理所有非系统数据库)
+        :param tables_map: 各数据库要处理的表 {数据库名: [表名]}
+        :param columns_map: 各表使用的去重列 {数据库名: {表名: [列名]}}
+        :param dry_run: 是否模拟运行
+        :param parallel: 是否并行处理
+        :return: 嵌套字典 {数据库名: {表名: (重复行数, 删除行数)}}
+        """
+        all_results = defaultdict(dict)
+
+        try:
+            # 获取要处理的数据库
+            target_dbs = databases or self._get_databases()
+            if not target_dbs:
+                self._log('warning', "没有可处理的数据库")
+                return all_results
+
+            self._log('info',
+                      f"开始处理 {len(target_dbs)} 个数据库",
+                      {'databases': target_dbs}
+                      )
+
+            if parallel and self.max_workers > 1:
+                # 并行处理数据库
+                with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=self.max_workers
+                ) as executor:
+                    futures = {}
+                    for db in target_dbs:
+                        tables = tables_map.get(db) if tables_map else None
+                        db_columns_map = columns_map.get(db) if columns_map else None
+                        futures[executor.submit(
+                            self.deduplicate_database,
+                            db, tables, db_columns_map, dry_run, False
+                        )] = db
+
+                    for future in concurrent.futures.as_completed(futures):
+                        db = futures[future]
+                        try:
+                            db_results = future.result()
+                            all_results[db] = db_results
+                        except Exception as e:
+                            self._log('error',
+                                      f"处理数据库 {db} 时出错: {str(e)}",
+                                      {'error_type': type(e).__name__}
+                                      )
+                            all_results[db] = {}
+            else:
+                # 串行处理数据库
+                for db in target_dbs:
+                    tables = tables_map.get(db) if tables_map else None
+                    db_columns_map = columns_map.get(db) if columns_map else None
+                    db_results = self.deduplicate_database(
+                        db, tables, db_columns_map, dry_run, parallel
+                    )
+                    all_results[db] = db_results
+
+            # 统计总体结果
+            total_dup = sum(
+                r[0] for db in all_results.values()
+                for r in db.values()
+            )
+            total_del = sum(
+                r[1] for db in all_results.values()
+                for r in db.values()
+            )
+
+            self._log('info',
+                      f"所有数据库处理完成 - 共发现 {total_dup} 组重复数据，删除 {total_del} 行",
+                      {'total_results': all_results}
+                      )
+
+            return all_results
+
+        except Exception as e:
+            self._log('error',
+                      f"全局处理时发生错误: {str(e)}",
+                      {'error_type': type(e).__name__}
+                      )
+            return all_results
+
+    @_retry_on_failure
+    def _check_database_exists(self, database: str) -> bool:
+        """检查数据库是否存在"""
+        sql = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = %s"
+
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(sql, (database,))
+                return bool(cursor.fetchone())
+
+    @_retry_on_failure
+    def _check_table_exists(self, database: str, table: str) -> bool:
+        """检查表是否存在"""
+        sql = """
+        SELECT TABLE_NAME 
+        FROM INFORMATION_SCHEMA.TABLES 
+        WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
+        """
+
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(sql, (database, table))
+                return bool(cursor.fetchone())
+
+    def close(self):
+        """关闭连接池"""
+        try:
+            if hasattr(self, 'pool') and self.pool:
+                self.pool.close()
+                self._log('info', "数据库连接池已关闭")
+        except Exception as e:
+            self._log('error',
+                      f"关闭连接池时出错: {str(e)}",
+                      {'error_type': type(e).__name__}
+                      )
+        finally:
+            self.pool = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+def main():
     uploader = MySQLUploader(
         username='root',
         password='1',
         host='localhost',
         port=3306,
-        logging_mode='both',
+        logging_mode='console',
         log_level='info'
     )
 
     # 定义列和数据类型
     set_typ = {
-        'id': 'INT',
         'name': 'VARCHAR(255)',
         'age': 'INT',
         'salary': 'DECIMAL(10,2)',
-        '日期': 'DATE'
+        '日期': 'DATE',
+        'shop': None,
     }
 
     # 准备数据
     data = [
-        {'日期': '2023-01-15', 'name': 'Alice', 'age': 35, 'salary': 100},
-        {'日期': '2023-01-15', 'name': 'Alice', 'age': 30, 'salary': 0.0},
-        {'日期': '2023-02-20', 'name': 'Bob', 'age': 25, 'salary': 45000.75}
+        {'日期': '2023-01-8', 'name': 'JACk', 'AGE': '24', 'salary': 555.1545},
+        {'日期': '2023-01-15', 'name': 'Alice', 'AGE': 35, 'salary': 100},
+        {'日期': '2023-01-15', 'name': 'Alice', 'AGE': 30, 'salary': 0.0},
+        {'日期': '2023-02-20', 'name': 'Bob', 'AGE': 25, 'salary': 45000.75}
     ]
 
     # 上传数据
@@ -2217,15 +3034,40 @@ if __name__ == '__main__':
         table_name='测试表',
         data=data,
         set_typ=set_typ,  # 定义列和数据类型
-        primary_keys=[],  # 指定主键
-        check_duplicate=True,  # 检查重复数据
-        duplicate_columns=['name', 'age'],  #
+        primary_keys=[],  # 创建唯一主键
+        check_duplicate=False,  # 检查重复数据
+        duplicate_columns=[],  # 指定排重的组合键
         allow_null=False,  # 允许插入空值
         partition_by='year',  # 按月分表
-        partition_date_column = '日期',  # 用于分表的日期列名，默认为'日期'
-        auto_create = True,  # 表不存在时自动创建, 默认参数不要更改
-        indexes = ['name'],  #  指定索引列
+        partition_date_column='日期',  # 用于分表的日期列名，默认为'日期'
+        auto_create=True,  # 表不存在时自动创建, 默认参数不要更改
+        indexes=[],  # 指定索引列
     )
 
-    # 关闭上传器
     uploader.close()
+
+
+def main2():
+    deduplicator = MySQLDeduplicator(
+        username='root',
+        password='1',
+        host='localhost',
+        port=3306
+    )
+
+    # # 全库去重(单线程)
+    # deduplicator.deduplicate_all()
+
+    # # 指定数据库去重(多线程)
+    # deduplicator.deduplicate_database('my_db', parallel=True)
+
+    # 指定表去重(使用特定列)
+    deduplicator.deduplicate_table('my_db', 'my_table', columns=['name', 'date'])
+
+    # 关闭连接
+    deduplicator.close()
+
+if __name__ == '__main__':
+    pass
+
+    main2()

{mdbq-3.9.2.dist-info → mdbq-3.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mdbq
-Version: 3.9.2
+Version: 3.9.4
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

{mdbq-3.9.2.dist-info → mdbq-3.9.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=x030kSR5wz8nf_l9kAxmL-5kk7A84GeAWO_CGB1N2Cw,17
+mdbq/__version__.py,sha256=44Qvc6l4hjIIQuGixaBICZNZB9jeL2ztNkT4fkONEBc,17
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
 mdbq/aggregation/optimize.py,sha256=2oalzD9weZhDclUC22OLxYa8Zj7KnmsGUoUau_Jlyc4,19796
 mdbq/aggregation/query_data.py,sha256=5_OzjGR5Sq00q-EgAYmSE5V9i4Solw9y4hkldl4mvt8,179808
@@ -8,7 +8,7 @@ mdbq/config/config.py,sha256=eaTfrfXQ65xLqjr5I8-HkZd_jEY1JkGinEgv3TSLeoQ,3170
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
 mdbq/log/spider_logging.py,sha256=-ozWWEGm3HVv604ozs_OOvVwumjokmUPwbaodesUrPY,1664
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
-mdbq/mysql/mysql.py,sha256=9e1mT12gWE8-Vld-E52EAtoAxKqQVmTlG7aGUXO17vo,99908
+mdbq/mysql/mysql.py,sha256=ylGvSzFE2B78y77wG266tf_RaEuETnngqDKUTqjQCjs,132378
 mdbq/mysql/s_query.py,sha256=X055aLRAgxVvueXx4NbfNjp6MyBI02_XBb1pTKw09L0,8660
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/other/download_sku_picture.py,sha256=YU8DxKMXbdeE1OOKEA848WVp62jYHw5O4tXTjUdq9H0,44832
@@ -22,7 +22,7 @@ mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=Uk8-cOWT0JU1qRyIVqdbYokSLvkDIAfcokmYj1ebw8k,24104
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=OhyEv1VyAKTOHjLDM37iNDQeRg5OnrNoKODoG2VxHes,19806
-mdbq-3.9.2.dist-info/METADATA,sha256=6Swdffh2m_pfD0XyeKyJGbehkwcuhWFiJtHakbCuBDQ,363
-mdbq-3.9.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-3.9.2.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.9.2.dist-info/RECORD,,
+mdbq-3.9.4.dist-info/METADATA,sha256=1FQB3vRRNlxontQEXd6gE-RhnHbjAPOZcnc_Xh9I4B0,363
+mdbq-3.9.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-3.9.4.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.9.4.dist-info/RECORD,,