mdbq 3.11.7__py3-none-any.whl → 3.11.9__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '3.11.7'
+VERSION = '3.11.9'

mdbq/log/mylogger.py

@@ -247,7 +247,7 @@ class MyLogger:
                             if isinstance(log_data.get('message'), str):
                                 log_data['message'] = log_data['message'].replace(field, '***')
 
-                    return json.dumps(log_data, ensure_ascii=False)
+                    return json.dumps(log_data, ensure_ascii=False, default=str)
 
             formatter = StructuredFormatter()
 

mdbq/mysql/deduplicator.py

@@ -13,6 +13,7 @@ import concurrent.futures
 from collections import defaultdict
 import sys
 from datetime import datetime
+import uuid
 
 
 warnings.filterwarnings('ignore')
@@ -81,7 +82,7 @@ class MySQLDeduplicator:
             exclude_columns: Optional[List[str]] = None,
             exclude_databases: Optional[List[str]] = None,
             exclude_tables: Optional[Dict[str, List[str]]] = None,
-            duplicate_keep_mode: str = 'keep_one'  # 新增参数
+            duplicate_keep_mode: str = 'keep_one'
     ) -> None:
         """
         初始化去重处理器
@@ -113,7 +114,7 @@ class MySQLDeduplicator:
         )
 
         # 配置参数
-        self.max_workers = max(1, min(max_workers, 20))  # 限制最大线程数
+        self.max_workers = min(max(1, max_workers), pool_size)  # 限制最大线程数，不能超过连接池
         self.batch_size = batch_size
         self.skip_system_dbs = skip_system_dbs
         self.max_retries = max_retries
@@ -191,7 +192,6 @@ class MySQLDeduplicator:
             raise ConnectionError("连接池已关闭")
         try:
             conn = self.pool.connection()
-            logger.debug("成功获取数据库连接")
             return conn
         except Exception as e:
             logger.error(f"获取数据库连接失败: {str(e)}", {'error_type': type(e).__name__})
@@ -269,7 +269,8 @@ class MySQLDeduplicator:
             with conn.cursor() as cursor:
                 cursor.execute(f"USE `{database}`")
                 cursor.execute(sql)
-                return [row[f'Tables_in_{database}'] for row in cursor.fetchall()]
+                # 严格过滤所有以'temp_'为前缀的表名（如temp_xxx、temp_xxx_dedup_...、temp_xxx_reorderid_...等）
+                return [row[f'Tables_in_{database}'] for row in cursor.fetchall() if not re.match(r'^temp_.*', row[f'Tables_in_{database}'])]
 
     @_retry_on_failure
     def _get_table_columns(self, database: str, table: str) -> List[str]:
@@ -328,48 +329,73 @@ class MySQLDeduplicator:
             if key in self._processing_tables:
                 self._processing_tables.remove(key)
 
+    @_retry_on_failure
+    def _ensure_index(self, database: str, table: str, date_column: str) -> None:
+        """
+        检查并为date_column自动创建索引（如果未存在）。
+        Args:
+            database (str): 数据库名。
+            table (str): 表名。
+            date_column (str): 需要检查的日期列名。
+        """
+        with self._get_connection() as conn:
+            with conn.cursor() as cursor:
+                # 检查索引是否已存在
+                cursor.execute(
+                    """
+                    SELECT COUNT(1) as idx_count FROM INFORMATION_SCHEMA.STATISTICS
+                    WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s AND COLUMN_NAME = %s
+                    """,
+                    (database, table, date_column)
+                )
+                idx_count = cursor.fetchone()['idx_count']
+                if idx_count == 0:
+                    # 自动创建索引
+                    index_name = f"idx_{date_column}"
+                    safe_index_name = self._make_safe_table_name(index_name, prefix='', suffix='', max_length=64)
+                    try:
+                        cursor.execute(f"CREATE INDEX `{safe_index_name}` ON `{database}`.`{table}` (`{date_column}`)")
+                        conn.commit()
+                        logger.info('已自动为date_column创建索引', {"库": database, "表": table, "date_column": date_column, "索引名": safe_index_name})
+                    except Exception as e:
+                        logger.error('自动创建date_column索引失败', {"库": database, "表": table, "date_column": date_column, "异常": str(e)})
+                else:
+                    logger.debug('date_column已存在索引', {"库": database, "表": table, "date_column": date_column})
+
     def _deduplicate_table(
             self,
             database: str,
             table: str,
             columns: Optional[List[str]] = None,
             dry_run: bool = False,
-            reset_id: bool = False
+            use_python_dedup: bool = False
     ) -> Tuple[int, int]:
         """
         执行单表去重。
-        
-        Args:
-            database (str): 数据库名。
-            table (str): 表名。
-            columns (Optional[List[str]]): 用于去重的列名列表（为None时使用所有列）。
-            dry_run (bool): 是否为模拟运行（只统计不实际删除）。
-            reset_id (bool): 是否在去重后重排id。
-        Returns:
-            Tuple[int, int]: (重复组数, 实际删除行数)。
+        支持按天分批处理（如果表包含date_column），否则全表去重。
+        如果date_column在exclude_columns中，直接跳过该表。
+        优化：分批删除时用主键、避免重复建/删临时表、并发处理每天。
         """
         if not self._acquire_table_lock(database, table):
             return (0, 0)
         temp_table = None
         try:
-            # 获取原始数据总量
-            with self._get_connection() as conn:
-                with conn.cursor() as cursor:
-                    logger.debug('执行SQL', {'sql': f'SELECT COUNT(*) as cnt FROM `{database}`.`{table}`'})
-                    cursor.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{table}`")
-                    total_count_row = cursor.fetchone()
-                    total_count = total_count_row['cnt'] if total_count_row and 'cnt' in total_count_row else 0
-            logger.info('执行', {"库": database, "表": table, "开始处理数据量": total_count, 'func': sys._getframe().f_code.co_name})
             # 获取实际列名
             all_columns = self._get_table_columns(database, table)
-            logger.debug('获取表列', {'库': database, '表': table, 'all_columns': all_columns})
-            # 检查是否需要按时间范围过滤
-            use_time_filter = False
-            time_col = self.date_column
             all_columns_lower = [col.lower() for col in all_columns]
-            # 排除exclude_columns
             exclude_columns_lower = [col.lower() for col in getattr(self, 'exclude_columns', [])]
-            # 统一列名小写做判断
+            time_col = self.date_column
+            time_col_lower = time_col.lower() if time_col else None
+            # 1. 跳过date_column在exclude_columns的情况
+            if time_col_lower and time_col_lower in exclude_columns_lower:
+                logger.warning('date_column在exclude_columns中，跳过该表', {"库": database, "表": table, "date_column": time_col, "exclude_columns": self.exclude_columns})
+                return (0, 0)
+            # 2. 判断表是否包含date_column
+            has_time_col = time_col_lower in all_columns_lower if time_col_lower else False
+            # 如果包含date_column，自动检查并创建索引
+            if has_time_col:
+                self._ensure_index(database, table, time_col)
+            # 3. 获取去重列
             use_columns = columns or all_columns
             use_columns = [col for col in use_columns if col.lower() in all_columns_lower and col.lower() not in exclude_columns_lower]
             invalid_columns = set([col for col in (columns or []) if col.lower() not in all_columns_lower])
@@ -378,85 +404,126 @@ class MySQLDeduplicator:
             if not use_columns:
                 logger.error('没有有效的去重列', {"库": database, "表": table})
                 return (0, 0)
-            # 统一用反引号包裹
-            column_list = ', '.join([f'`{col}`' for col in use_columns])
-            temp_table = f"temp_{table}_dedup_{os.getpid()}_{threading.get_ident()}"
-            temp_table = re.sub(r'[^a-zA-Z0-9_]', '_', temp_table)[:60]
             pk = self.primary_key
-            # 主键判断也用小写
-            if pk.lower() not in all_columns_lower and pk != 'id':
-                logger.error('', {"不存在主键列": database, "表": table, "主键列不存在": pk})
-                return (0, 0)
-            # 找到实际主键名
             pk_real = next((c for c in all_columns if c.lower() == pk.lower()), pk)
-            # 构造where条件
-            where_time = ''
-            if use_time_filter:
-                where_time = f"WHERE `{time_col}` >= '{self._dedup_start_date}' AND `{time_col}` <= '{self._dedup_end_date}'"
+            # 判断是否需要加日期区间条件
+            where_sql = ''
+            if has_time_col and self._dedup_start_date and self._dedup_end_date:
+                where_sql = f"t.`{time_col}` >= '{self._dedup_start_date}' AND t.`{time_col}` <= '{self._dedup_end_date}'"
+            # 获取原始数据总量（只统计区间内数据）
+            with self._get_connection() as conn:
+                with conn.cursor() as cursor:
+                    count_where = f"WHERE `{time_col}` >= '{self._dedup_start_date}' AND `{time_col}` <= '{self._dedup_end_date}'" if has_time_col and self._dedup_start_date and self._dedup_end_date else ''
+                    count_sql = f"SELECT COUNT(*) as cnt FROM `{database}`.`{table}` {count_where}"
+                    logger.debug('执行SQL', {'sql': count_sql})
+                    cursor.execute(count_sql)
+                    total_count_row = cursor.fetchone()
+                    total_count = total_count_row['cnt'] if total_count_row and 'cnt' in total_count_row else 0
+            logger.info('执行', {"库": database, "表": table, "开始处理数据量": total_count, 'func': sys._getframe().f_code.co_name})
+            column_list = ', '.join([f'`{col}`' for col in use_columns])
+
+            # 用Python查找重复
+            if use_python_dedup:
+                from collections import defaultdict
+                # 1. 拉取所有数据
+                select_cols = f'`{pk_real}`,' + ','.join([f'`{col}`' for col in use_columns])
+                select_where = f"WHERE `{time_col}` >= '{self._dedup_start_date}' AND `{time_col}` <= '{self._dedup_end_date}'" if has_time_col and self._dedup_start_date and self._dedup_end_date else ''
+                select_sql = f"SELECT {select_cols} FROM `{database}`.`{table}` {select_where}"
+                logger.debug('用Python查找重复，拉取数据SQL', {'sql': select_sql})
+                with self._get_connection() as conn:
+                    with conn.cursor() as cursor:
+                        cursor.execute(select_sql)
+                        rows = cursor.fetchall()
+                # 2. 分组找重复
+                grouped = defaultdict(list)
+                for row in rows:
+                    key = tuple(row[col] for col in use_columns)
+                    grouped[key].append(row[pk_real])
+                # 3. 统计重复组和待删除id
+                dup_count = 0
+                del_ids = []
+                for ids in grouped.values():
+                    if len(ids) > 1:
+                        dup_count += 1
+                        del_ids.extend(ids[1:])  # 只保留第一个
+                affected_rows = 0
+                if not dry_run and del_ids:
+                    with self._get_connection() as conn:
+                        with conn.cursor() as cursor:
+                            for i in range(0, len(del_ids), self.batch_size):
+                                batch = del_ids[i:i+self.batch_size]
+                                del_ids_str = ','.join([str(i) for i in batch])
+                                delete_sql = f"DELETE FROM `{database}`.`{table}` WHERE `{pk_real}` IN ({del_ids_str})"
+                                logger.debug('用Python分批删除SQL', {'sql': delete_sql, 'ids': batch})
+                                cursor.execute(delete_sql)
+                                batch_deleted = cursor.rowcount
+                                affected_rows += batch_deleted
+                                conn.commit()
+                logger.info('用Python去重完成', {"库": database, "表": table, "数据量": total_count, "重复组数": dup_count, "实际删除": affected_rows, "去重模式": self.duplicate_keep_mode, "实际去重列": use_columns})
+                return (dup_count, affected_rows)
+            # SQL方式查找重复
+            temp_table = self._make_safe_table_name(table, prefix=f"temp_", suffix=f"_dedup_{os.getpid()}_{threading.get_ident()}")
+            drop_temp_sql = f"DROP TABLE IF EXISTS `{database}`.`{temp_table}`"
+            # 创建临时表时加where条件
+            create_temp_where = f"WHERE `{time_col}` >= '{self._dedup_start_date}' AND `{time_col}` <= '{self._dedup_end_date}'" if has_time_col and self._dedup_start_date and self._dedup_end_date else ''
             create_temp_sql = f"""
             CREATE TABLE `{database}`.`{temp_table}` AS
             SELECT MIN(`{pk_real}`) as `min_id`, {column_list}, COUNT(*) as `dup_count`
             FROM `{database}`.`{table}`
-            {where_time}
+            {create_temp_where}
             GROUP BY {column_list}
             HAVING COUNT(*) > 1
             """
-            drop_temp_sql = f"DROP TABLE IF EXISTS `{database}`.`{temp_table}`"
             with self._get_connection() as conn:
                 with conn.cursor() as cursor:
                     logger.debug('创建临时表SQL', {'sql': create_temp_sql})
                     cursor.execute(create_temp_sql)
-                    logger.debug('统计临时表重复组SQL', {'sql': f'SELECT COUNT(*) as cnt FROM `{database}`.`{temp_table}`'})
                     cursor.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{temp_table}`")
                     dup_count_row = cursor.fetchone()
                     dup_count = dup_count_row['cnt'] if dup_count_row and 'cnt' in dup_count_row else 0
                     if dup_count == 0:
-                        logger.info('没有重复数据', {"库": database, "表": table, "数据量": total_count, "时间范围": [self._dedup_start_date, self._dedup_end_date] if use_time_filter else None, "实际去重列": use_columns})
-                        logger.debug('删除临时表SQL', {'sql': drop_temp_sql})
+                        logger.info('没有重复数据', {"库": database, "表": table, "数据量": total_count, "实际去重列": use_columns})
                         cursor.execute(drop_temp_sql)
                         conn.commit()
                         return (0, 0)
                     affected_rows = 0
                     if not dry_run:
-                        # 分批删除，避免锁表
                         while True:
-                            if self.duplicate_keep_mode == 'remove_all':
-                                # 删除所有重复组的所有记录
-                                delete_dup_sql = f"""
-                                DELETE FROM `{database}`.`{table}`
-                                WHERE ({', '.join([f'`{col}`' for col in use_columns])}) IN (
-                                    SELECT {column_list} FROM `{database}`.`{temp_table}`
-                                ) {'AND' if use_time_filter else ''} {f'`{time_col}` >= \'{self._dedup_start_date}\' AND `{time_col}` <= \'{self._dedup_end_date}\'' if use_time_filter else ''}
-                                LIMIT {self.batch_size}
-                                """
-                            else:
-                                # 修正：只删除重复组中不是min_id的行，唯一数据不动
-                                delete_dup_sql = f"""
-                                DELETE FROM `{database}`.`{table}` t
-                                WHERE EXISTS (
-                                    SELECT 1 FROM `{database}`.`{temp_table}` tmp
-                                    WHERE
-                                        {' AND '.join([f't.`{col}` <=> tmp.`{col}`' for col in use_columns])}
-                                        AND t.`{pk_real}` <> tmp.`min_id`
-                                )
-                                {'AND' if use_time_filter else ''} {f't.`{time_col}` >= \'{self._dedup_start_date}\' AND t.`{time_col}` <= \'{self._dedup_end_date}\'' if use_time_filter else ''}
-                                LIMIT {self.batch_size}
-                                """
-                            logger.debug('执行删除重复数据SQL', {'sql': delete_dup_sql})
-                            cursor.execute(delete_dup_sql)
+                            where_clauses = []
+                            if self.duplicate_keep_mode == 'keep_one':
+                                where_clauses.append(f"t.`{pk_real}` <> tmp.`min_id`")
+                            if where_sql.strip():
+                                where_clauses.append(where_sql.strip())
+                            where_full = "WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+                            find_dup_ids_sql = f"""
+                            SELECT t.`{pk_real}` as del_id
+                            FROM `{database}`.`{table}` t
+                            JOIN `{database}`.`{temp_table}` tmp
+                            ON {' AND '.join([f't.`{col}` <=> tmp.`{col}`' for col in use_columns])}
+                            {where_full}
+                            LIMIT {self.batch_size}
+                            """
+                            logger.debug('查找待删除重复id SQL', {'sql': find_dup_ids_sql})
+                            cursor.execute(find_dup_ids_sql)
+                            del_ids = [row['del_id'] for row in cursor.fetchall()]
+                            if not del_ids:
+                                break
+                            del_ids_str = ','.join([str(i) for i in del_ids])
+                            delete_sql = f"DELETE FROM `{database}`.`{table}` WHERE `{pk_real}` IN ({del_ids_str})"
+                            logger.debug('按id批量删除SQL', {'sql': delete_sql, 'ids': del_ids})
+                            cursor.execute(delete_sql)
                             batch_deleted = cursor.rowcount
                             affected_rows += batch_deleted
                             conn.commit()
+                            if batch_deleted == 0:
+                                logger.warning('检测到未能删除任何数据，强制跳出循环，防止假死', {"库": database, "表": table})
+                                break
                             if batch_deleted < self.batch_size:
                                 break
-                        logger.info('操作删除', {"库": database, "表": table, "数据量": total_count, "重复组数": dup_count, "实际删除": affected_rows, "时间范围": [self._dedup_start_date, self._dedup_end_date] if use_time_filter else None, "实际去重列": use_columns, "去重模式": self.duplicate_keep_mode})
-                        # 新增：去重后重排id
-                        if reset_id and affected_rows > 0:
-                            self._reset_id_column(database, table)
+                        logger.info('操作删除', {"库": database, "表": table, "数据量": total_count, "重复组数": dup_count, "实际删除": affected_rows, "去重模式": self.duplicate_keep_mode, "实际去重列": use_columns})
                     else:
-                        logger.debug('dry_run模式，不执行删除', {"库": database, "表": table, "重复组数": dup_count, "时间范围": [self._dedup_start_date, self._dedup_end_date] if use_time_filter else None})
+                        logger.debug('dry_run模式，不执行删除', {"库": database, "表": table, "重复组数": dup_count})
                         affected_rows = 0
-                    logger.debug('删除临时表SQL', {'sql': drop_temp_sql})
                     cursor.execute(drop_temp_sql)
                     conn.commit()
                     return (dup_count, affected_rows)
@@ -482,7 +549,8 @@ class MySQLDeduplicator:
             table: str,
             columns: Optional[List[str]] = None,
             dry_run: bool = False,
-            reset_id: bool = False
+            reorder_id: bool = False,
+            use_python_dedup: bool = True
     ) -> Tuple[int, int]:
         """
         对指定表进行去重。
@@ -492,7 +560,8 @@ class MySQLDeduplicator:
             table (str): 表名。
             columns (Optional[List[str]]): 用于去重的列名列表（为None时使用所有列）。
             dry_run (bool): 是否为模拟运行（只统计不实际删除）。
-            reset_id (bool): 是否在去重后重排id。
+            reorder_id (bool): 去重后是否重排id。
+            use_python_dedup (bool): 是否用Python查找重复id。
         Returns:
             Tuple[int, int]: (重复组数, 实际删除行数)。
         """
@@ -503,9 +572,17 @@ class MySQLDeduplicator:
             if not self._check_table_exists(database, table):
                 logger.warning('表不存在', {"库": database, "表": table, "warning": "跳过"})
                 return (0, 0)
-            logger.info('单表开始', {"库": database, "表": table, "参数": {"指定去重列": columns, "模拟运行": dry_run, '排除列': self.exclude_columns}})
-            result = self._deduplicate_table(database, table, columns, dry_run, reset_id)
+            logger.info('单表开始', {"库": database, "表": table, "参数": {"指定去重列": columns, "模拟运行": dry_run, '排除列': self.exclude_columns, 'use_python_dedup': use_python_dedup}})
+            result = self._deduplicate_table(database, table, columns, dry_run, use_python_dedup)
             logger.info('单表完成', {"库": database, "表": table, "结果[重复, 删除]": result})
+            # 自动重排id列（仅当有实际删除时且reorder_id为True）
+            dup_count, affected_rows = result
+            if reorder_id and affected_rows > 0:
+                try:
+                    reorder_ok = self.reorder_id_column(database, table, id_column=self.primary_key, dry_run=dry_run)
+                    logger.info('自动重排id列完成', {"库": database, "表": table, "结果": reorder_ok})
+                except Exception as e:
+                    logger.error('自动重排id列异常', {"库": database, "表": table, "异常": str(e)})
             return result
         except Exception as e:
             logger.error('发生全局错误', {"库": database, "表": table, 'func': sys._getframe().f_code.co_name, "发生全局错误": str(e)})
@@ -518,7 +595,8 @@ class MySQLDeduplicator:
             columns_map: Optional[Dict[str, List[str]]] = None,
             dry_run: bool = False,
             parallel: bool = False,
-            reset_id: bool = False
+            reorder_id: bool = False,
+            use_python_dedup: bool = True
     ) -> Dict[str, Tuple[int, int]]:
         """
         对指定数据库的所有表进行去重。
@@ -529,7 +607,8 @@ class MySQLDeduplicator:
             columns_map (Optional[Dict[str, List[str]]]): 各表使用的去重列 {表名: [列名]}。
             dry_run (bool): 是否为模拟运行。
             parallel (bool): 是否并行处理。
-            reset_id (bool): 是否在去重后重排id。
+            reorder_id (bool): 去重后是否重排id。
+            use_python_dedup (bool): 是否用Python查找重复id。
         Returns:
             Dict[str, Tuple[int, int]]: {表名: (重复组数, 实际删除行数)}。
         """
@@ -558,7 +637,7 @@ class MySQLDeduplicator:
                         logger.debug('提交表去重任务', {'库': database, '表': table, 'columns': columns})
                         futures[executor.submit(
                             self.deduplicate_table,
-                            database, table, columns, dry_run, reset_id
+                            database, table, columns, dry_run, reorder_id, True
                         )] = table
                     for future in concurrent.futures.as_completed(futures):
                         table = futures[future]
@@ -574,7 +653,7 @@ class MySQLDeduplicator:
                 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, reset_id
+                        database, table, columns, dry_run, reorder_id, True
                     )
                     results[table] = (dup_count, affected_rows)
             total_dup = sum(r[0] for r in results.values())
@@ -592,7 +671,8 @@ class MySQLDeduplicator:
             columns_map: Optional[Dict[str, Dict[str, List[str]]]] = None,
             dry_run: bool = False,
             parallel: bool = False,
-            reset_id: bool = False
+            reorder_id: bool = False,
+            use_python_dedup: bool = True
     ) -> Dict[str, Dict[str, Tuple[int, int]]]:
         """
         对所有数据库进行去重。
@@ -603,7 +683,8 @@ class MySQLDeduplicator:
             columns_map (Optional[Dict[str, Dict[str, List[str]]]]): 指定每个表去重时使用的列，格式为 {数据库名: {表名: [列名, ...]}}。如果为 None，则使用所有列。
             dry_run (bool): 是否为模拟运行模式。为 True 时只统计重复行数，不实际删除。
             parallel (bool): 是否并行处理多个数据库。为 True 时使用线程池并发处理。
-            reset_id (bool): 是否在去重后重排id。
+            reorder_id (bool): 去重后是否重排id。
+            use_python_dedup (bool): 是否用Python查找重复id。
         Returns:
             Dict[str, Dict[str, Tuple[int, int]]]: 嵌套字典，格式为 {数据库名: {表名: (重复组数, 实际删除行数)}}。
         """
@@ -615,7 +696,7 @@ class MySQLDeduplicator:
             if not target_dbs:
                 logger.warning('没有可处理的数据库')
                 return all_results
-            logger.info('全局开始', {"数据库数量": len(target_dbs), "数据库列表": target_dbs, "参数": {"模拟运行": dry_run, "并行处理": parallel, '排除列': self.exclude_columns}})
+            logger.info('全局开始', {"数据库数量": len(target_dbs), "数据库列表": target_dbs, "参数": {"模拟运行": dry_run, "并行处理": parallel, '排除列': self.exclude_columns, 'use_python_dedup': use_python_dedup}})
             if parallel and self.max_workers > 1:
                 # 使用线程池并行处理多个数据库
                 with concurrent.futures.ThreadPoolExecutor(
@@ -627,7 +708,7 @@ class MySQLDeduplicator:
                         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, reset_id
+                            db, tables, db_columns_map, dry_run, False, reorder_id, True
                         )] = db
                     for future in concurrent.futures.as_completed(futures):
                         db = futures[future]
@@ -643,7 +724,7 @@ class MySQLDeduplicator:
                     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, reset_id
+                        db, tables, db_columns_map, dry_run, parallel, reorder_id, True
                     )
                     all_results[db] = db_results
             total_dup = sum(
@@ -738,145 +819,206 @@ class MySQLDeduplicator:
         """
         self.close()
 
-    def _has_foreign_key_dependency(self, database: str, table: str, pk: str) -> bool:
-        """检测id列是否被其他表外键引用。"""
-        fk_check_sql = '''
-        SELECT TABLE_NAME, COLUMN_NAME, CONSTRAINT_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
-        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
-        WHERE REFERENCED_TABLE_SCHEMA = %s AND REFERENCED_TABLE_NAME = %s AND REFERENCED_COLUMN_NAME = %s
-        '''
-        with self._get_connection() as conn:
-            with conn.cursor() as cursor:
-                cursor.execute(f"USE `{database}`")
-                cursor.execute(fk_check_sql, (database, table, pk))
-                fk_rows = cursor.fetchall()
-                return bool(fk_rows)
-
-    def _get_table_create_sql_and_pk(self, database: str, table: str) -> tuple:
-        """获取表的CREATE语句和主键字段列表。"""
-        with self._get_connection() as conn:
-            with conn.cursor() as cursor:
-                cursor.execute(f"USE `{database}`")
-                cursor.execute(f"SHOW CREATE TABLE `{database}`.`{table}`")
-                create_sql = cursor.fetchone()['Create Table']
-                cursor.execute(f"SHOW KEYS FROM `{database}`.`{table}` WHERE Key_name = 'PRIMARY'")
-                pk_rows = cursor.fetchall()
-                pk_columns = [row['Column_name'] for row in pk_rows]
-        return create_sql, pk_columns
-
-    def _make_temp_table_sql(self, create_sql: str, table: str, temp_table: str, pk: str, pk_columns: list) -> str:
-        """生成临时表的CREATE语句，仅替换id字段类型。"""
-        def replace_id_type(sql):
-            lines = sql.split('\n')
-            new_lines = []
-            for line in lines:
-                if re.match(rf'\s*`{pk}` ', line):
-                    if pk_columns == [pk]:
-                        line = re.sub(r'`' + pk + r'`\s+[^,]*', f'`{pk}` INT NOT NULL AUTO_INCREMENT', line)
-                    else:
-                        line = re.sub(r'`' + pk + r'`\s+[^,]*', f'`{pk}` INT NOT NULL', line)
-                new_lines.append(line)
-            return '\n'.join(new_lines)
-        create_sql_temp = re.sub(
-            rf'CREATE TABLE `{table}`',
-            f'CREATE TABLE `{temp_table}`',
-            create_sql,
-            count=1
-        )
-        create_sql_temp = replace_id_type(create_sql_temp)
-        create_sql_temp = re.sub(r'AUTO_INCREMENT=\d+', '', create_sql_temp)
-        return create_sql_temp
-
-    def _create_and_fill_temp_table(self, database: str, table: str, temp_table: str, pk: str) -> list:
-        """创建临时表并插入重排id数据，返回所有字段名。"""
-        with self._get_connection() as conn:
-            with conn.cursor() as cursor:
-                cursor.execute(f"USE `{database}`")
-                cursor.execute(f"SHOW COLUMNS FROM `{database}`.`{table}`")
-                columns = [row['Field'] for row in cursor.fetchall()]
-                columns_wo_id = [col for col in columns if col != pk]
-                col_list = ', '.join([f'`{col}`' for col in columns_wo_id])
-                insert_sql = f"INSERT INTO `{database}`.`{temp_table}` ({col_list}, `{pk}`) SELECT {col_list}, (@rownum:=@rownum+1) as `{pk}` FROM `{database}`.`{table}` JOIN (SELECT @rownum:=0) r ORDER BY `{pk}` ASC"
-                cursor.execute(insert_sql)
-                return columns
-
-    def _swap_tables_with_backup(self, database: str, table: str, temp_table: str, bak_table: str):
-        """原表重命名为备份，临时表变原表名。"""
-        with self._get_connection() as conn:
-            with conn.cursor() as cursor:
-                cursor.execute(f"USE `{database}`")
-                cursor.execute(f"RENAME TABLE `{database}`.`{table}` TO `{database}`.`{bak_table}`")
-                cursor.execute(f"RENAME TABLE `{database}`.`{temp_table}` TO `{database}`.`{table}`")
-                conn.commit()
-
-    def _check_and_cleanup_backup(self, database: str, table: str, bak_table: str) -> bool:
-        """校验新表和备份表数据量一致，安全删除备份表。"""
-        with self._get_connection() as conn:
-            with conn.cursor() as cursor:
-                cursor.execute(f"USE `{database}`")
-                cursor.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{table}`")
-                new_cnt = cursor.fetchone()['cnt']
-                cursor.execute(f"SELECT COUNT(*) as cnt FROM `{database}`.`{bak_table}`")
-                old_cnt = cursor.fetchone()['cnt']
-                if new_cnt == old_cnt:
-                    cursor.execute(f"DROP TABLE `{database}`.`{bak_table}`")
-                    conn.commit()
-                    return True
-                else:
-                    logger.error('id重排后数据量不一致，未删除备份表', {'库': database, '表': table, '新表行数': new_cnt, '备份表行数': old_cnt})
-                    return False
-
-    def _rollback_table_swap(self, database: str, table: str, bak_table: str):
-        """回滚：如bak表存在且原表不存在，则恢复原表名。"""
+    def reorder_id_column(
+        self,
+        database: str,
+        table: Optional[str] = None,
+        id_column: str = "id",
+        dry_run: bool = False,
+        auto_drop_backup: bool = True
+    ) -> Any:
+        """
+        安全重排指定表或指定库下所有表的id列为顺序自增（1,2,3...）。
+        Args:
+            database (str): 数据库名
+            table (Optional[str]): 表名，None时批量处理该库所有表
+            id_column (str): id列名，默认"id"
+            dry_run (bool): 是否为模拟运行
+            auto_drop_backup (bool): 校验通过后自动删除备份表
+        Returns:
+            bool 或 dict: 单表时bool，批量时{表名: bool}
+        """
+        if not table:
+            # 批量模式，对库下所有表执行
+            try:
+                all_tables = self._get_tables(database)
+            except Exception as e:
+                logger.error('获取库下所有表失败', {"库": database, "异常": str(e)})
+                return {}
+            results = {}
+            for tbl in all_tables:
+                try:
+                    res = self.reorder_id_column(database, tbl, id_column, dry_run, auto_drop_backup)
+                    results[tbl] = res
+                except Exception as e:
+                    logger.error('批量id重排异常', {"库": database, "表": tbl, "异常": str(e)})
+                    results[tbl] = False
+            logger.info('批量id重排完成', {"库": database, "结果": results})
+            return results
+        # 单表模式
+        table_quoted = f"`{database}`.`{table}`"
+        if not self._acquire_table_lock(database, table):
+            logger.warning('表级锁获取失败，跳过id重排', {"库": database, "表": table})
+            return False
         try:
+            # 检查表是否存在
+            if not self._check_table_exists(database, table):
+                logger.warning('表不存在，跳过id重排', {"库": database, "表": table})
+                return False
+            # 检查id列是否存在
             with self._get_connection() as conn:
                 with conn.cursor() as cursor:
-                    cursor.execute(f"USE `{database}`")
-                    cursor.execute(f"SHOW TABLES LIKE '{bak_table}'")
-                    if cursor.fetchone():
-                        cursor.execute(f"SHOW TABLES LIKE '{table}'")
-                        if not cursor.fetchone():
-                            cursor.execute(f"RENAME TABLE `{database}`.`{bak_table}` TO `{database}`.`{table}`")
-                            conn.commit()
-                            logger.info('回滚成功，已恢复原表', {'库': database, '表': table})
-        except Exception as e2:
-            logger.error('回滚失败', {'库': database, '表': table, '异常': str(e2)})
-
-    def _reset_id_column(self, database: str, table: str) -> bool:
-        pk = self.primary_key
-        temp_table = f"temp_{table}_resetid_{os.getpid()}_{threading.get_ident()}"
-        temp_table = re.sub(r'[^a-zA-Z0-9_]', '_', temp_table)[:60]
-        bak_table = f"{table}_bak_{int(time.time())}"
-        try:
-            # 1. 检查外键依赖
-            if self._has_foreign_key_dependency(database, table, pk):
-                logger.warning('存在外键依赖，拒绝重排id', {'库': database, '表': table})
+                    cursor.execute("""
+                        SELECT COLUMN_NAME, COLUMN_KEY
+                        FROM INFORMATION_SCHEMA.COLUMNS
+                        WHERE TABLE_SCHEMA=%s AND TABLE_NAME=%s
+                    """, (database, table))
+                    columns_info = cursor.fetchall()
+                    columns = [row['COLUMN_NAME'] for row in columns_info]
+                    id_is_pk = any(row['COLUMN_NAME'].lower() == id_column.lower() and row['COLUMN_KEY'] in ('PRI', 'UNI') for row in columns_info)
+            if id_column not in columns:
+                logger.warning('表无id列，跳过id重排', {"库": database, "表": table})
                 return False
-            # 2. 获取表结构和主键
-            create_sql, pk_columns = self._get_table_create_sql_and_pk(database, table)
-            # 3. 生成临时表DDL
-            create_sql_temp = self._make_temp_table_sql(create_sql, table, temp_table, pk, pk_columns)
-            # 4. 创建临时表
+            # 检查主键是否为单列id
+            pk_cols = [row['COLUMN_NAME'] for row in columns_info if row['COLUMN_KEY'] == 'PRI']
+            if len(pk_cols) != 1 or pk_cols[0].lower() != id_column.lower():
+                logger.warning('主键不是单列id，跳过id重排', {"库": database, "表": table, "主键列": pk_cols})
+                return False
+            # 检查外键约束
             with self._get_connection() as conn:
                 with conn.cursor() as cursor:
-                    cursor.execute(f"USE `{database}`")
-                    cursor.execute(f"DROP TABLE IF EXISTS `{database}`.`{temp_table}`")
-                    cursor.execute(create_sql_temp)
-                    conn.commit()
-            # 5. 填充临时表
-            self._create_and_fill_temp_table(database, table, temp_table, pk)
-            # 6. 表交换
-            self._swap_tables_with_backup(database, table, temp_table, bak_table)
-            # 7. 校验和清理
-            if self._check_and_cleanup_backup(database, table, bak_table):
-                logger.info('id重排完成并安全删除备份表，主键信息已保留', {'库': database, '表': table})
+                    cursor.execute("""
+                        SELECT * FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+                        WHERE TABLE_SCHEMA=%s AND TABLE_NAME=%s AND REFERENCED_TABLE_NAME IS NOT NULL
+                    """, (database, table))
+                    if cursor.fetchone():
+                        logger.warning('表存在外键约束，跳过id重排', {"库": database, "表": table})
+                        return False
+            # 获取表结构
+            with self._get_connection() as conn:
+                with conn.cursor() as cursor:
+                    cursor.execute(f"SHOW CREATE TABLE {table_quoted}")
+                    create_table_sql = cursor.fetchone()['Create Table']
+            logger.info('开始id重排', {"库": database, "表": table, "重排列": id_column, "试运行": dry_run, "DDL警告": "MySQL DDL操作不可回滚，建议提前备份！"})
+            if dry_run:
+                logger.info('dry_run模式，打印原表结构', {"库": database, "表": table, "建表语句": create_table_sql})
                 return True
-            else:
+            temp_table = self._make_safe_table_name(table, prefix=f"temp_", suffix=f"_reorderid_{os.getpid()}_{threading.get_ident()}")
+            temp_table_quoted = f"`{database}`.`{temp_table}`"
+            backup_table = self._make_safe_table_name(table, prefix="backup_", suffix=f"_{int(time.time())}_{uuid.uuid4().hex[:8]}")
+            backup_table_quoted = f"`{database}`.`{backup_table}`"
+            try:
+                with self._get_connection() as conn:
+                    with conn.cursor() as cursor:
+                        # 1. 创建临时表，结构同原表
+                        try:
+                            cursor.execute(f"CREATE TABLE {temp_table_quoted} LIKE {table_quoted}")
+                        except Exception as e:
+                            logger.error('创建临时表失败', {"库": database, "表": table, "异常": str(e)})
+                            return False
+                        # 2. 插入数据，id列用ROW_NUMBER重排（MySQL 8+）
+                        all_cols = ','.join([f'`{col}`' for col in columns])
+                        all_cols_noid = ','.join([f'`{col}`' for col in columns if col != id_column])
+                        insert_sql = f"""
+                            INSERT INTO {temp_table_quoted} ({all_cols})
+                            SELECT ROW_NUMBER() OVER (ORDER BY `{id_column}` ASC) as `{id_column}`, {all_cols_noid}
+                            FROM {table_quoted}
+                        """
+                        try:
+                            cursor.execute(insert_sql)
+                        except Exception as e:
+                            logger.error('插入重排数据失败', {"库": database, "表": table, "异常": str(e)})
+                            try:
+                                cursor.execute(f"DROP TABLE IF EXISTS {temp_table_quoted}")
+                            except Exception as drop_e:
+                                logger.error('插入失败后删除临时表失败', {"库": database, "表": table, "异常": str(drop_e)})
+                            return False
+                        # 如果id不是主键，尝试加主键（如不冲突）
+                        if not id_is_pk:
+                            try:
+                                cursor.execute(f"ALTER TABLE {temp_table_quoted} ADD PRIMARY KEY(`{id_column}`)")
+                            except Exception as e:
+                                logger.warning('id列加主键失败，可能已存在其他主键', {"库": database, "表": table, "异常": str(e)})
+                        # 3. 原表重命名为备份，临时表重命名为正式表
+                        try:
+                            cursor.execute(f"RENAME TABLE {table_quoted} TO {backup_table_quoted}, {temp_table_quoted} TO {table_quoted}")
+                        except Exception as e:
+                            logger.error('RENAME TABLE失败', {"库": database, "表": table, "异常": str(e)})
+                            # 回滚：删除临时表
+                            try:
+                                cursor.execute(f"DROP TABLE IF EXISTS {temp_table_quoted}")
+                            except Exception as drop_e:
+                                logger.error('RENAME失败后删除临时表失败', {"库": database, "表": table, "异常": str(drop_e)})
+                            return False
+                        # 4. 校验新表和备份表数据量一致
+                        try:
+                            cursor.execute(f"SELECT COUNT(*) as cnt FROM {table_quoted}")
+                            new_cnt = cursor.fetchone()['cnt']
+                            cursor.execute(f"SELECT COUNT(*) as cnt FROM {backup_table_quoted}")
+                            old_cnt = cursor.fetchone()['cnt']
+                        except Exception as e:
+                            logger.error('校验数据量失败', {"库": database, "表": table, "异常": str(e)})
+                            return False
+                        if new_cnt != old_cnt:
+                            logger.error('id重排后数据量不一致，自动回滚', {"库": database, "表": table, "新表": new_cnt, "备份表": old_cnt})
+                            # 回滚：恢复原表
+                            try:
+                                cursor.execute(f"DROP TABLE {table_quoted}")
+                                cursor.execute(f"RENAME TABLE {backup_table_quoted} TO {table_quoted}")
+                            except Exception as e:
+                                logger.error('回滚恢复原表失败', {"库": database, "表": table, "异常": str(e)})
+                            return False
+                        logger.info('id重排成功且数据量一致', {"库": database, "表": table, "新表": new_cnt, "备份表": old_cnt, "备份表名": backup_table})
+                        # 5. 可选：自动删除备份表
+                        if auto_drop_backup:
+                            try:
+                                cursor.execute(f"DROP TABLE {backup_table_quoted}")
+                                logger.info('已自动删除备份表', {"库": database, "表": table, "备份表名": backup_table})
+                            except Exception as e:
+                                logger.error('自动删除备份表失败', {"库": database, "表": table, "异常": str(e)})
+                        return True
+            except Exception as e:
+                logger.error('id重排异常，准备回滚', {"库": database, "表": table, "异常": str(e)})
+                # 回滚：如临时表存在则删掉，恢复原表结构
+                with self._get_connection() as conn:
+                    with conn.cursor() as cursor:
+                        try:
+                            cursor.execute(f"DROP TABLE IF EXISTS {temp_table_quoted}")
+                        except Exception as drop_e:
+                            logger.error('回滚时删除临时表失败', {"库": database, "表": table, "异常": str(drop_e)})
+                        # 恢复原表（如备份表存在）
+                        try:
+                            with self._get_connection() as conn2:
+                                with conn2.cursor() as cursor2:
+                                    if self._check_table_exists(database, backup_table):
+                                        cursor2.execute(f"DROP TABLE IF EXISTS {table_quoted}")
+                                        cursor2.execute(f"RENAME TABLE {backup_table_quoted} TO {table_quoted}")
+                                        logger.info('已自动恢复原表', {"库": database, "表": table, "备份表名": backup_table})
+                        except Exception as recover_e:
+                            logger.error('回滚时恢复原表失败', {"库": database, "表": table, "异常": str(recover_e)})
                 return False
-        except Exception as e:
-            logger.error('id重排失败，尝试回滚', {'库': database, '表': table, '异常': str(e)})
-            self._rollback_table_swap(database, table, bak_table)
-            return False
+        finally:
+            self._release_table_lock(database, table)
+
+    @staticmethod
+    def _make_safe_table_name(base: str, prefix: str = '', suffix: str = '', max_length: int = 64) -> str:
+        """
+        生成安全的MySQL表名，确保总长度不超过max_length字节。
+        :param base: 原始表名
+        :param prefix: 前缀
+        :param suffix: 后缀
+        :param max_length: 最大长度，默认64
+        :return: 安全表名
+        """
+        # 只允许字母数字下划线
+        base = re.sub(r'[^a-zA-Z0-9_]', '_', base)
+        prefix = re.sub(r'[^a-zA-Z0-9_]', '_', prefix)
+        suffix = re.sub(r'[^a-zA-Z0-9_]', '_', suffix)
+        remain = max_length - len(prefix) - len(suffix)
+        if remain < 1:
+            # 前后缀太长，直接截断
+            return (prefix + suffix)[:max_length]
+        return f"{prefix}{base[:remain]}{suffix}"[:max_length]
 
 
 def main():
@@ -884,21 +1026,26 @@ def main():
         username='root',
         password='pwd',
         host='localhost',
-        port=3306
+        port=3306,
+        date_range=['2025-05-27', '2025-05-28'],
+        exclude_tables={'推广数据2': ['地域报表_城市_2025_05_copy1', '主体报表_2025_copy1']}
     )
 
     # 全库去重(单线程)
-    deduplicator.deduplicate_all(dry_run=False, parallel=False, reset_id=False)
+    deduplicator.deduplicate_all(dry_run=False, parallel=True, reorder_id=True)
 
     # # 指定数据库去重(多线程)
-    # deduplicator.deduplicate_database('my_db', dry_run=False, parallel=True, reset_id=False)
+    # deduplicator.deduplicate_database('my_db', dry_run=False, parallel=False, reorder_id=False)
 
     # # 指定表去重(使用特定列)
-    # deduplicator.deduplicate_table('my_db', 'my_table', columns=['name', 'date'], dry_run=False, reset_id=False)
+    # deduplicator.deduplicate_table('my_db', 'my_table', columns=['name', 'date'], dry_run=False, reorder_id=False)
+
+    # # 重排id列
+    # deduplicator.reorder_id_column('my_db', 'my_table', 'id', dry_run=False, auto_drop_backup=True)
 
     # 关闭连接
     deduplicator.close()
 
 if __name__ == '__main__':
-    # main()
+    main()
     pass

mdbq/mysql/uploader.py

@@ -428,6 +428,7 @@ class MySQLUploader:
                 if idx_col in set_typ:
                     safe_idx_col = self._validate_identifier(idx_col)
                     index_defs.append(f"INDEX `idx_{safe_idx_col}` (`{safe_idx_col}`)")
+        index_defs = list(set(index_defs))
         index_sql = (',' + ','.join(index_defs)) if index_defs else ''
         sql = f"""
         CREATE TABLE IF NOT EXISTS `{db_name}`.`{table_name}` (
@@ -593,6 +594,34 @@ class MySQLUploader:
             logger.error('无法获取表列信息', {'库': db_name, '表': table_name, '错误': str(e)})
             raise
 
+    def _ensure_index(self, db_name: str, table_name: str, column: str):
+        """
+        确保某列有索引，如果没有则创建。
+        """
+        db_name = self._validate_identifier(db_name)
+        table_name = self._validate_identifier(table_name)
+        column = self._validate_identifier(column)
+        # 检查索引是否已存在
+        sql_check = '''
+            SELECT COUNT(1) FROM INFORMATION_SCHEMA.STATISTICS
+            WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s AND COLUMN_NAME = %s
+        '''
+        sql_create = f'ALTER TABLE `{db_name}`.`{table_name}` ADD INDEX `idx_{column}` (`{column}`)'
+        try:
+            with self._get_connection() as conn:
+                with conn.cursor() as cursor:
+                    cursor.execute(sql_check, (db_name, table_name, column))
+                    exists = cursor.fetchone()
+                    if exists and list(exists.values())[0] > 0:
+                        logger.debug('索引已存在', {'库': db_name, '表': table_name, '列': column})
+                        return
+                    cursor.execute(sql_create)
+                conn.commit()
+                logger.info('已为列创建索引', {'库': db_name, '表': table_name, '列': column})
+        except Exception as e:
+            logger.error('创建索引失败', {'库': db_name, '表': table_name, '列': column, '错误': str(e)})
+            raise
+
     def _upload_to_table(
             self,
             db_name: str,
@@ -646,6 +675,13 @@ class MySQLUploader:
                 })
                 raise ValueError(f"列不存在: `{col}` -> `{db_name}`.`{table_name}`")
 
+        # 确保分表参考字段为索引
+        if date_column and date_column in table_columns:
+            try:
+                self._ensure_index(db_name, table_name, date_column)
+            except Exception as e:
+                logger.warning('分表参考字段索引创建失败', {'库': db_name, '表': table_name, '列': date_column, '错误': str(e)})
+
         # 插入数据
         self._insert_data(
             db_name, table_name, data, set_typ,
@@ -868,7 +904,7 @@ class MySQLUploader:
         :param duplicate_columns: 用于检查重复的列，可选
         :param allow_null: 是否允许空值，默认为False
         :param partition_by: 分表方式('year'、'month'、'None')，可选
-        :param partition_date_column: 用于分表的日期列名，默认为'日期'
+        :param partition_date_column: 用于分表的日期列名，默认为'日期', 默认会添加为索引
         :param auto_create: 表不存在时是否自动创建，默认为True
         :param indexes: 需要创建索引的列列表，可选
         :param update_on_duplicate: 遇到重复数据时是否更新旧数据，默认为False
@@ -977,6 +1013,12 @@ class MySQLUploader:
                             allow_null, auto_create, partition_date_column,
                             indexes, batch_id, update_on_duplicate, transaction_mode
                         )
+                        # 确保分表参考字段为索引
+                        if partition_date_column in filtered_set_typ:
+                            try:
+                                self._ensure_index(db_name, part_table, partition_date_column)
+                            except Exception as e:
+                                logger.warning('分表参考字段索引创建失败', {'库': db_name, '表': part_table, '列': partition_date_column, '错误': str(e)})
                     except Exception as e:
                         logger.error('分表上传异常', {
                             '库': db_name,
@@ -995,6 +1037,12 @@ class MySQLUploader:
                     allow_null, auto_create, partition_date_column,
                     indexes, batch_id, update_on_duplicate, transaction_mode
                 )
+                # 确保分表参考字段为索引
+                if partition_date_column in filtered_set_typ:
+                    try:
+                        self._ensure_index(db_name, table_name, partition_date_column)
+                    except Exception as e:
+                        logger.warning('分表参考字段索引创建失败', {'库': db_name, '表': table_name, '列': partition_date_column, '错误': str(e)})
 
             success_flag = True
 

{mdbq-3.11.7.dist-info → mdbq-3.11.9.dist-info}/METADATA

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

{mdbq-3.11.7.dist-info → mdbq-3.11.9.dist-info}/RECORD

@@ -1,17 +1,17 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=KXKzNBZD4M6L-jW29owhKjBycLSiUdGeTf_uNAYvyGI,18
+mdbq/__version__.py,sha256=PDdrWyCY8MR3t82c_RzSF6lAB6oCcZdWveXkX7AvIIQ,18
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
 mdbq/aggregation/query_data.py,sha256=nxL8hSy8yI1QLlqnkTNHHQSxRfo-6WKL5OA-N4xLB7c,179832
 mdbq/config/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/config/config.py,sha256=eaTfrfXQ65xLqjr5I8-HkZd_jEY1JkGinEgv3TSLeoQ,3170
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
-mdbq/log/mylogger.py,sha256=HuxLBCXjm6fZrxYE0rdpUCz359WGeqOX0vvg9jTuRY4,24126
+mdbq/log/mylogger.py,sha256=Crw6LwVo3I3IUbzIETu8f46Quza3CTCh-qYf4edbBPo,24139
 mdbq/log/spider_logging.py,sha256=-ozWWEGm3HVv604ozs_OOvVwumjokmUPwbaodesUrPY,1664
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
-mdbq/mysql/deduplicator.py,sha256=dq40YBLVd5ho28pYzVfwm5pA90YA3iN6l9xX4k0Ynds,42808
+mdbq/mysql/deduplicator.py,sha256=G7hdIO6rDLBNo1jSm6PbmPAzzfdN2jZFP4BnLhO02Mo,52970
 mdbq/mysql/mysql.py,sha256=Kjpi-LL00WQUmTTOfhEBsNrmo4-4kFFJzrHbVKfqiBE,56770
 mdbq/mysql/s_query.py,sha256=dlnrVJ3-Vp1Suv9CNbPxyYSRqRJUHjOpF39tb2F-wBc,10190
-mdbq/mysql/uploader.py,sha256=LxPlAfSNhQbLu-or4wxa-vLjCw5_PIN3ZVoksWUJazQ,61701
+mdbq/mysql/uploader.py,sha256=8Px_W2bYOr1wQgMXMK0DggNiuE6a6Ul4BlJake8LSo8,64469
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/other/download_sku_picture.py,sha256=YU8DxKMXbdeE1OOKEA848WVp62jYHw5O4tXTjUdq9H0,44832
 mdbq/other/otk.py,sha256=iclBIFbQbhlqzUbcMMoePXBpcP1eZ06ZtjnhcA_EbmE,7241
@@ -24,7 +24,7 @@ mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=YHgCKO8mEsslwet33K5tGss-nrDDwPnOSlhA9iBu0jY,24078
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=cqK-JRd_DHbToC7hyo83m8o97NZkJFqmB2xBtr6aAVU,20961
-mdbq-3.11.7.dist-info/METADATA,sha256=j_0kmOn4tTbk8TY8LqbEZ2OWmJz0-70sUQNwP_N0VCc,364
-mdbq-3.11.7.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-3.11.7.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.11.7.dist-info/RECORD,,
+mdbq-3.11.9.dist-info/METADATA,sha256=djSbJHNSHuyh2So6ia5CluTggpZ4REj9jxhO9vwOeKw,364
+mdbq-3.11.9.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-3.11.9.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.11.9.dist-info/RECORD,,