mdbq 3.12.2__py3-none-any.whl → 3.12.4__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '3.12.2'
+VERSION = '3.12.4'

mdbq/mysql/deduplicator.py

@@ -16,7 +16,6 @@ from datetime import datetime
 import uuid
 from contextlib import contextmanager
 
-
 warnings.filterwarnings('ignore')
 logger = mylogger.MyLogger(
     name='deduplicator',
@@ -34,7 +33,22 @@ logger = mylogger.MyLogger(
 
 class MySQLDeduplicator:
     """
-    MySQL数据去重
+    MySQL 数据去重。
+
+    支持按天分区（如有 date_column）或全表去重，支持自定义去重分组字段（columns），可排除指定列（exclude_columns），并支持多线程并发。
+
+    主要参数说明：
+    - columns: 指定去重分组字段，控制唯一性分组行为。若 columns 有值且不包含 date_column，则全表去重，否则按天分区。
+    - exclude_columns: 去重时排除的列名列表，自动合并 ['id', '更新时间']，在分组时排除。
+    - date_column: 指定日期分区字段，默认为 '日期'。如表存在该字段且 columns 未排除，则按天分区去重。
+    - duplicate_keep_mode: 'keep_one'（默认，重复组保留一条），'remove_all'（全部删除重复组）。
+    - dry_run: 是否为模拟运行，不实际删除数据。
+    - use_python_dedup: 是否用 Python 方式去重（否则用 SQL）。
+
+    分天/全表去重行为：
+    - 若 columns 有值且不包含 date_column，则直接全表去重，分组字段为 columns。
+    - 否则，若表存在 date_column，则按天分区去重，分组字段为 columns（如有）或全表字段。
+    - exclude_columns 始终生效，分组时自动排除。
     """
 
     def __init__(
@@ -57,7 +71,8 @@ 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',
+            keep_order: str = 'min'
     ) -> None:
         """
         初始化去重处理器
@@ -163,6 +178,7 @@ class MySQLDeduplicator:
         self.exclude_tables = {k.lower(): set(t.lower() for t in v) for k, v in (exclude_tables or {}).items()}
 
         self.duplicate_keep_mode = duplicate_keep_mode if duplicate_keep_mode in ('keep_one', 'remove_all') else 'keep_one'
+        self.keep_order = keep_order if keep_order in ('min', 'max') else 'min'
 
     def _get_connection(self) -> pymysql.connections.Connection:
         """
@@ -370,15 +386,17 @@ class MySQLDeduplicator:
         lock_table: bool = True
     ) -> Tuple[int, int]:
         """
-        执行单表单天去重。只处理 date_val 这一天的数据（如果有 date_column），否则全表。
-        
+        执行单表单天或全表去重。根据 columns 和 date_column 决定分天或全表：
+        - 若 columns 不包含 date_column，则全表去重（不分天）。
+        - 若 columns 包含 date_column 或未指定 columns，则按天分区去重（date_val 为当前处理日期）。
+
         Args:
             database (str): 数据库名。
             table (str): 表名。
-            columns (Optional[List[str]]): 指定去重列。
+            columns (Optional[List[str]]): 指定去重列。若不含 date_column，则全表去重。
             dry_run (bool): 是否为模拟运行。
             use_python_dedup (bool): 是否用 Python 方式去重。
-            date_val (Optional[str]): 指定处理的日期（如有 date_column）。
+            date_val (Optional[str]): 指定处理的日期（如有 date_column 且分天时）。
             lock_table (bool): 是否加表级锁。
         Returns:
             Tuple[int, int]: (重复组数, 实际删除行数)
@@ -392,13 +410,12 @@ class MySQLDeduplicator:
             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
-            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)
-            has_time_col = time_col_lower in all_columns_lower if time_col_lower else False
-
-            # 只要有date_column，始终分天处理（本函数只处理一天）
-            if has_time_col and date_val is not None:
+            # 如果传了columns且columns不包含date_column，则不分天，直接全表去重
+            if columns and (not time_col_lower or time_col_lower not in [c.lower() for c in columns]):
+                has_time_col = False  # 全表去重
+            else:
+                has_time_col = time_col_lower in all_columns_lower if time_col_lower else False  # 分天去重
+            if has_time_col:
                 self._ensure_index(database, table, time_col)
                 # 获取去重列
                 use_columns = columns or all_columns
@@ -426,39 +443,58 @@ class MySQLDeduplicator:
 
                 # 用Python查找重复
                 if use_python_dedup:
+                    # 判断分组字段是否有“更新时间”
+                    has_update_time = any(col == '更新时间' for col in use_columns)
                     select_cols = f'`{pk_real}`,' + ','.join([f'`{col}`' for col in use_columns])
-                    select_where = f"WHERE `{time_col}` = '{date_val}'"
+                    if has_update_time:
+                        select_cols += ',`更新时间`'
+                    select_where = f"WHERE `{time_col}` = '{date_val}'" if date_val else ''
                     grouped = defaultdict(list)
                     for row in self._row_generator(database, table, select_cols, select_where, self.batch_size):
                         key = tuple(row[col] for col in use_columns)
-                        grouped[key].append(row[pk_real])
+                        grouped[key].append(row)
                     dup_count = 0
                     del_ids = []
                     for ids in grouped.values():
                         if len(ids) > 1:
                             dup_count += 1
-                            del_ids.extend(ids[1:])
+                            if has_update_time:
+                                # 按更新时间最大保留
+                                keep_row = max(ids, key=lambda x: x.get('更新时间') or '')
+                            else:
+                                # 按id保留
+                                if self.keep_order == 'max':
+                                    keep_row = max(ids, key=lambda x: x[pk_real])
+                                else:
+                                    keep_row = min(ids, key=lambda x: x[pk_real])
+                            del_ids.extend([r[pk_real] for r in ids if r[pk_real] != keep_row[pk_real]])
                     affected_rows = 0
                     if not dry_run and del_ids:
                         with self._conn_ctx() as conn:
                             with conn.cursor() as cursor:
-                                for i in range(0, len(del_ids), self.batch_size):
-                                    batch_ids = del_ids[i:i+self.batch_size]
-                                    del_ids_str = ','.join([str(i) for i in batch_ids])
-                                    delete_sql = f"DELETE FROM `{database}`.`{table}` WHERE `{pk_real}` IN ({del_ids_str})"
-                                    cursor.execute(delete_sql)
-                                    batch_deleted = cursor.rowcount
-                                    affected_rows += batch_deleted
-                                    conn.commit()
+                                format_ids = ','.join([str(i) for i in del_ids])
+                                del_sql = f"DELETE FROM `{database}`.`{table}` WHERE `{pk_real}` IN ({format_ids})"
+                                cursor.execute(del_sql)
+                                affected_rows = cursor.rowcount
+                                conn.commit()
                     logger.debug('去重完成', {"库": database, "表": table, "数据量": total_count, "重复组": dup_count, "实际删除": affected_rows, "去重方式": "Python", "数据处理": self.duplicate_keep_mode, "数据日期": date_val})
                     return (dup_count, affected_rows)
                 # SQL方式查找重复
                 temp_table = self._make_temp_table_name(table)
                 drop_temp_sql = f"DROP TABLE IF EXISTS `{database}`.`{temp_table}`"
                 create_temp_where = f"WHERE `{time_col}` = '{date_val}'"
+                # 判断分组字段是否有“更新时间”
+                has_update_time = any(col == '更新时间' for col in use_columns)
+                if has_update_time:
+                    keep_field = '更新时间'
+                    keep_func = 'MAX'
+                else:
+                    keep_field = pk_real
+                    keep_func = 'MAX' if self.keep_order == 'max' else 'MIN'
+                keep_alias = 'keep_val'
                 create_temp_sql = f"""
                 CREATE TABLE `{database}`.`{temp_table}` AS
-                SELECT MIN(`{pk_real}`) as `min_id`, {column_list}, COUNT(*) as `dup_count`
+                SELECT {keep_func}(`{keep_field}`) as `{keep_alias}`, {column_list}, COUNT(*) as `dup_count`
                 FROM `{database}`.`{table}`
                 {create_temp_where}
                 GROUP BY {column_list}
@@ -481,7 +517,7 @@ class MySQLDeduplicator:
                             while True:
                                 where_clauses = []
                                 if self.duplicate_keep_mode == 'keep_one':
-                                    where_clauses.append(f"t.`{pk_real}` <> tmp.`min_id`")
+                                    where_clauses.append(f"t.`{keep_field}` <> tmp.`{keep_alias}`")
                                 if where_sql.strip():
                                     where_clauses.append(where_sql.strip())
                                 where_full = "WHERE " + " AND ".join(where_clauses) if where_clauses else ""
@@ -652,12 +688,20 @@ class MySQLDeduplicator:
         use_python_dedup: bool = True
     ) -> Tuple[int, int]:
         """
-        对指定表进行去重。始终按天分区（如有 date_column），否则全表。
-        
+        对指定表进行去重。
+
+        去重行为说明：
+        - 若 columns 参数传入且不包含 date_column，则全表直接按 columns 去重。
+        - 若 columns 包含 date_column 或未指定 columns，则按天分区去重（每一天独立去重）。
+        - exclude_columns 中的字段始终不会参与去重分组。
+        - date_column 默认为 '日期'，可自定义。
+        - dry_run 模式下仅统计重复组和待删除行数，不实际删除。
+        - reorder_id=True 时，去重后自动重排主键 id。
+
         Args:
             database (str): 数据库名。
             table (str): 表名。
-            columns (Optional[List[str]]): 指定去重列。
+            columns (Optional[List[str]]): 指定去重列。若不含 date_column，则全表去重。
             dry_run (bool): 是否为模拟运行。
             reorder_id (bool): 去重后是否自动重排 id 列。
             use_python_dedup (bool): 是否用 Python 方式去重。
@@ -686,7 +730,11 @@ class MySQLDeduplicator:
             all_columns_lower = [col.lower() for col in all_columns]
             time_col = self.date_column
             time_col_lower = time_col.lower() if time_col else None
-            has_time_col = time_col_lower in all_columns_lower if time_col_lower else False
+            # 如果传了columns且columns不包含date_column，则不分天，直接全表去重
+            if columns and (not time_col_lower or time_col_lower not in [c.lower() for c in columns]):
+                has_time_col = False  # 全表去重
+            else:
+                has_time_col = time_col_lower in all_columns_lower if time_col_lower else False  # 分天去重
             if has_time_col:
                 self._ensure_index(database, table, time_col)
                 all_dates = self._get_all_dates(database, table, time_col)
@@ -727,7 +775,7 @@ class MySQLDeduplicator:
                             logger.warning('分区处理失败', {"库": database, "表": table, "日期": date_val, "异常": err, "func": sys._getframe().f_code.co_name})
                         total_dup += dup_count
                         total_del += affected_rows
-                logger.debug('单表完成', {"库": database, "表": table, "结果[重复, 删除]": (total_dup, total_del), '日期范围': f"{start_date} - {end_date}"})
+                logger.info('单表完成', {"库": database, "表": table, "结果[重复, 删除]": (total_dup, total_del), '日期范围': f"{start_date} - {end_date}", "唯一列": columns})
                 # 自动重排id列（仅当有实际删除时且reorder_id为True）
                 if reorder_id and total_del > 0:
                     try:
@@ -736,11 +784,11 @@ class MySQLDeduplicator:
                     except Exception as e:
                         logger.error('自动重排id列异常', {"库": database, "表": table, "异常": str(e)})
                 if affected_rows > 0:
-                    logger.info('单表完成(仅显示有删除的结果)', {"库": database, "表": table, "重复组": total_dup, "实际删除": total_del})
+                    logger.info('单表完成(仅显示有删除的结果)', {"库": database, "表": table, "重复组": total_dup, "实际删除": total_del, "唯一列": columns})
                 return (total_dup, total_del)
             # 没有date_column，直接全表去重
             result = self._deduplicate_table(database, table, columns, dry_run, use_python_dedup, date_val=None)
-            logger.debug('单表完成', {"库": database, "表": table, "结果[重复, 删除]": result, '日期范围': '全表'})
+            logger.info('单表完成', {"库": database, "表": table, "结果[重复, 删除]": result, '日期范围': '全表', "唯一列": columns})
             dup_count, affected_rows = result
             if reorder_id and affected_rows > 0:
                 try:
@@ -749,7 +797,7 @@ class MySQLDeduplicator:
                 except Exception as e:
                     logger.error('自动重排id列异常', {"库": database, "表": table, "异常": str(e)})
             if affected_rows > 0:
-                logger.info('单表完成(仅显示有删除的结果)', {"库": database, "表": table, "重复组": dup_count, "实际删除": affected_rows})
+                logger.info('单表完成(仅显示有删除的结果)', {"库": database, "表": table, "重复组": dup_count, "实际删除": affected_rows, "唯一列": columns})
             return result
         except Exception as e:
             logger.error('发生全局错误', {"库": database, "表": table, 'func': sys._getframe().f_code.co_name, "发生全局错误": str(e)})
@@ -1289,20 +1337,26 @@ class MySQLDeduplicator:
 
 
 def main():
+    from mdbq.config import config
+    dir_path = os.path.expanduser("~")
+    my_cont = config.read_config(file_path=os.path.join(dir_path, 'spd.txt'))
+    username, password, host, port = my_cont['username'], my_cont['password'], my_cont['host'], int(my_cont['port'])
+    # host = 'localhost'
+    
     deduplicator = MySQLDeduplicator(
-        username='root',
-        password='pwd',
-        host='localhost',
-        port=3306,
-        max_workers= 3,
+        username=username,
+        password=password,
+        host=host,
+        port=port,
+        max_workers= 2,
         batch_size=1000,
         skip_system_dbs=True,
         max_retries=3,
         retry_waiting_time=5,
         pool_size=30,
-        recent_month=1,
+        # recent_month=1,
         # date_range=['2025-06-09', '2025-06-10'],
-        date_column='日期',
+        exclude_columns=['更新时间'],
         # exclude_databases=['测试库4'],
         # exclude_tables={
         #     '推广数据2': [
@@ -1313,16 +1367,23 @@ def main():
         #         "商品排行_2025",
         #     ],
         # },
+        keep_order='MAX',  # 保留重复组中指定列的最大值
     )
 
     # 全库去重(单线程)
-    deduplicator.deduplicate_all(dry_run=False, parallel=True, reorder_id=True)
+    # deduplicator.deduplicate_all(dry_run=False, parallel=True, reorder_id=True)
 
     # # 指定数据库去重(多线程)
     # deduplicator.deduplicate_database('数据引擎2', dry_run=False, parallel=True, reorder_id=True)
 
     # # 指定表去重(使用特定列)
-    # deduplicator.deduplicate_table('my_db', 'my_table', columns=['name', 'data'], dry_run=False, reorder_id=True)
+    deduplicator.deduplicate_table(
+        '京东数据3', 
+        '推广数据_京准通_2024', 
+        columns=['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id', 'spu_id', '花费', '展现数', '点击数'], 
+        dry_run=False, 
+        reorder_id=True,
+        )
 
     # # 重排id列
     # deduplicator.reorder_id_column('my_db', 'my_table', 'id', dry_run=False, auto_drop_backup=True)
@@ -1331,5 +1392,5 @@ def main():
     deduplicator.close()
 
 if __name__ == '__main__':
-    main()
+    # main()
     pass

mdbq/mysql/uploader.py

@@ -323,7 +323,7 @@ class MySQLUploader:
             logger.error('无效的标识符', {'标识符': identifier})
             raise ValueError(f"无效的标识符: `{identifier}`")
         # 始终做特殊字符清理
-        cleaned = re.sub(r'[^-\uFFFF\w\u4e00-\u9fff$]', '_', identifier)
+        cleaned = re.sub(r'[^\w\u4e00-\u9fff$]', '_', identifier)
         cleaned = re.sub(r'_+', '_', cleaned).strip('_')
         if not cleaned:
             logger.error('无法清理异常标识符', {'原始标识符': identifier})
@@ -332,6 +332,8 @@ class MySQLUploader:
             'select', 'insert', 'update', 'delete', 'from', 'where', 'and', 'or',
             'not', 'like', 'in', 'is', 'null', 'true', 'false', 'between'
         }
+        if len(cleaned) > 64:
+            cleaned = cleaned[:64]
         if cleaned.lower() in mysql_keywords:
             logger.debug('存在MySQL保留字', {'标识符': cleaned})
             return f"`{cleaned}`"
@@ -423,11 +425,11 @@ class MySQLUploader:
         # UNIQUE KEY定义
         unique_defs = []
         if unique_keys:
-            for idx, unique_cols in enumerate(unique_keys):
+            for unique_cols in unique_keys:
                 if not unique_cols:
                     continue
                 safe_unique_cols = [self._normalize_col(col) for col in unique_cols]
-                unique_name = f"uniq_{'_'.join(safe_unique_cols)}_{idx}"
+                unique_name = f"uniq_{'_'.join(safe_unique_cols)}"
                 unique_defs.append(f"UNIQUE KEY `{unique_name}` (`{'`,`'.join(safe_unique_cols)}`)")
         index_defs = list(set(index_defs))
         all_defs = column_defs + [primary_key_sql] + index_defs + unique_defs
@@ -651,7 +653,7 @@ class MySQLUploader:
         添加UNIQUE KEY
         """
         safe_cols = [self._normalize_col(col) for col in unique_cols]
-        unique_name = f"uniq_{'_'.join(safe_cols)}_{int(time.time()*1000)%100000}"
+        unique_name = f"uniq_{'_'.join(safe_cols)}"
         sql = f'ALTER TABLE `{db_name}`.`{table_name}` ADD UNIQUE KEY `{unique_name}` ({','.join(f'`{col}`' for col in safe_cols)})'
         try:
             with self._get_connection() as conn:

{mdbq-3.12.2.dist-info → mdbq-3.12.4.dist-info}/METADATA

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

{mdbq-3.12.2.dist-info → mdbq-3.12.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=7f_XGixBIsGAP5w1W3y_kTPfLVlurDoRsv3FOOJLDIA,18
+mdbq/__version__.py,sha256=V3m3JOLEsFbctTVRE9dNc1iuNQahT_FbWxcHtAoWWqc,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
@@ -8,10 +8,10 @@ mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
 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=eILGFxFtMCSR6dvCgEgsOjwlK_hEWBe2dFSgJTPHfj8,68623
+mdbq/mysql/deduplicator.py,sha256=MYcNe0rwWOFS2Bqac8yGwwothlz8H--cOi6yuZf3qIs,72602
 mdbq/mysql/mysql.py,sha256=Kjpi-LL00WQUmTTOfhEBsNrmo4-4kFFJzrHbVKfqiBE,56770
 mdbq/mysql/s_query.py,sha256=dlnrVJ3-Vp1Suv9CNbPxyYSRqRJUHjOpF39tb2F-wBc,10190
-mdbq/mysql/uploader.py,sha256=szX6t4SObBF6fbHT2s5ixfh1-c288cigsJ66pFE02Qg,70266
+mdbq/mysql/uploader.py,sha256=ekpPaJypnuwxi2v42e-khqwT_eZ5LRl1ylQP492xbkk,70271
 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.12.2.dist-info/METADATA,sha256=1V071qDvuX5apscDGFLY_ICX6mMVBUhjzMGh_a_wd7w,364
-mdbq-3.12.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-3.12.2.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.12.2.dist-info/RECORD,,
+mdbq-3.12.4.dist-info/METADATA,sha256=bptLkLuByUNJJnZ_ruWRjxeG2LOFvaqK26M3MtQkf78,364
+mdbq-3.12.4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-3.12.4.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.12.4.dist-info/RECORD,,