mdbq 3.10.7__py3-none-any.whl → 3.10.8__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '3.10.7'
+VERSION = '3.10.8'

mdbq/log/mylogger.py

@@ -239,8 +239,9 @@ class MyLogger:
                         log_data['异常'] = self.formatException(record.exc_info)
 
                     # 过滤敏感信息
-                    if hasattr(record, '过滤'):
-                        for field in record.sensitive_fields:
+                    if hasattr(record, 'extra_data') and '过滤' in record.extra_data:
+                        sensitive_fields = record.extra_data['过滤']
+                        for field in sensitive_fields:
                             if field in log_data:
                                 log_data[field] = '***'
                             if isinstance(log_data.get('message'), str):
@@ -447,8 +448,11 @@ class MyLogger:
             try:
                 self._log_queue.put((level, message, extra), timeout=0.1)
             except queue.Full:
-                # 队列满时降级为同步日志
-                self._sync_log(level, f"[ASYNC QUEUE FULL] {message}", extra)
+                # 队列满时降级为同步日志，添加队列状态信息到extra
+                if extra is None:
+                    extra = {}
+                extra['queue_status'] = 'full'
+                self._sync_log(level, message, extra)
         else:
             self._sync_log(level, message, extra)
 
@@ -509,21 +513,6 @@ class MyLogger:
         if not extra:
             extra = {}
 
-        # # 获取完整的异常堆栈
-        # tb = exc_info.__traceback__
-        # while tb.tb_next:
-        #     tb = tb.tb_next  # 获取最内层的堆栈帧
-        #
-        # extra.update({
-        #     'module': tb.tb_frame.f_globals.get('__name__', ''),
-        #     'function': tb.tb_frame.f_code.co_name,
-        #     'line': tb.tb_lineno,
-        #     'file': tb.tb_frame.f_code.co_filename,
-        #     '异常': str(exc_info),
-        #     '类型': exc_info.__class__.__name__,
-        #     '堆栈': self._format_traceback(exc_info)
-        # })
-
         # 使用inspect获取调用栈
         frame = inspect.currentframe()
         try:

mdbq/mysql/uploader.py

@@ -1,3 +1,17 @@
+"""
+MySQL数据上传工具类
+
+这个模块提供了一个用于将数据上传到MySQL数据库的工具类。它支持以下主要功能：
+1. 自动创建数据库和表
+2. 支持数据分表存储
+3. 支持数据重复检查和更新
+4. 支持批量数据插入
+5. 支持多种事务模式
+6. 自动类型转换和验证
+7. 连接池管理
+8. 错误重试机制
+"""
+
 # -*- coding:utf-8 -*-
 import datetime
 import re
@@ -6,8 +20,6 @@ from functools import wraps
 import warnings
 import pymysql
 import pandas as pd
-import os
-import logging
 from mdbq.log import mylogger
 from typing import Union, List, Dict, Optional, Any, Tuple, Set
 from dbutils.pooled_db import PooledDB
@@ -60,23 +72,40 @@ def count_decimal_places(num_str):
 
 
 class StatementCache(OrderedDict):
-    """基于OrderedDict实现的LRU缓存策略，用于缓存SQL语句"""
+    """
+    基于OrderedDict实现的LRU缓存策略，用于缓存SQL语句
+    
+    这个类继承自OrderedDict，实现了最近最少使用(LRU)的缓存策略。
+    当缓存达到最大容量时，会自动删除最早添加的项。
+    """
     def __init__(self, maxsize=100):
         """
         初始化缓存
 
-        :param maxsize: 最大缓存大小，默认为100
+        :param maxsize: 最大缓存大小，默认为100条SQL语句
         """
         super().__init__()
         self.maxsize = maxsize
 
     def __setitem__(self, key, value):
+        """
+        重写设置项方法，实现LRU策略
+
+        :param key: 缓存键
+        :param value: 缓存值
+        """
         super().__setitem__(key, value)
         if len(self) > self.maxsize:
             self.popitem(last=False)
 
 
 class MySQLUploader:
+    """
+    MySQL数据上传工具类
+    
+    提供了一系列方法用于将数据上传到MySQL数据库，支持自动建表、分表、数据验证等功能。
+    使用连接池管理数据库连接，提供错误重试机制。
+    """
     def __init__(
             self,
             username: str,
@@ -94,6 +123,8 @@ class MySQLUploader:
             ssl: Optional[Dict] = None
     ):
         """
+        初始化MySQL上传器
+
         :param username: 数据库用户名
         :param password: 数据库密码
         :param host: 数据库主机地址，默认为localhost
@@ -106,8 +137,6 @@ class MySQLUploader:
         :param connect_timeout: 连接超时(秒)，默认为10
         :param read_timeout: 读取超时(秒)，默认为30
         :param write_timeout: 写入超时(秒)，默认为30
-        :param base_excute_col: # 排重插入数据时始终排除该列
-        :param case_sensitive: # 是否保持大小写敏感，默认为False(转为小写)
         :param ssl: SSL配置字典，默认为None
         """
         self.username = username
@@ -362,10 +391,10 @@ class MySQLUploader:
             return f"{table_name}_{date_obj.year}_{date_obj.month:02d}"
         else:
             logger.error(sys._getframe().f_code.co_name, {
-                "分表方式必须是 'year' 或 'month'": partition_by,
+                "分表方式必须是 'year' 或 'month' 或 'None'": partition_by,
                 '表': table_name
             })
-            raise ValueError("分表方式必须是 'year' 或 'month'")
+            raise ValueError("分表方式必须是 'year' 或 'month' 或 'None'")
 
     def _validate_identifier(self, identifier: str) -> str:
         """
@@ -611,10 +640,15 @@ class MySQLUploader:
             column_type_lower = column_type.lower()
 
             # 处理百分比值
-            if str(value).strip().endswith('%'):
+            if isinstance(value, str) and value.strip().endswith('%'):
                 try:
                     # 移除百分号并转换为小数
-                    percent_value = float(value.strip().replace('%', ''))
+                    percent_str = value.strip().replace('%', '')
+                    # 处理科学计数法
+                    if 'e' in percent_str.lower():
+                        percent_value = float(percent_str)
+                    else:
+                        percent_value = float(percent_str)
                     decimal_value = percent_value / 100
                     return decimal_value
                 except ValueError:
@@ -855,8 +889,8 @@ class MySQLUploader:
                 data = data.replace({pd.NA: None}).to_dict('records')
             except Exception as e:
                 logger.error(sys._getframe().f_code.co_name, {
-                '数据转字典时发生错误': str(e),
-                '数据': data,
+                    '数据转字典时发生错误': str(e),
+                    '数据': data,
                 })
                 raise ValueError(f"数据转字典时发生错误: {e}")
         elif isinstance(data, dict):
@@ -878,7 +912,7 @@ class MySQLUploader:
 
         # 获取数据中实际存在的列名
         data_columns = set()
-        if data:
+        if data and len(data) > 0:
             data_columns = set(data[0].keys())
 
         # 过滤set_typ，只保留数据中存在的列
@@ -910,7 +944,6 @@ class MySQLUploader:
                     if not allow_null:
                         error_msg = f"行号:{row_idx} -> 缺失列: `{col_name}`"
                         logger.error(error_msg)
-
                         raise ValueError(error_msg)
                     prepared_row[col_name] = None
                 else:
@@ -949,7 +982,7 @@ class MySQLUploader:
 
         :param db_name: 数据库名
         :param table_name: 表名
-        :param data: 要上传的数据
+        :param data: 要上传的数据，支持字典、字典列表或DataFrame格式
         :param set_typ: 列名和数据类型字典 {列名: 数据类型}
         :param primary_keys: 主键列列表，可选
         :param check_duplicate: 是否检查重复数据，默认为False
@@ -959,12 +992,11 @@ class MySQLUploader:
         :param partition_date_column: 用于分表的日期列名，默认为'日期'
         :param auto_create: 表不存在时是否自动创建，默认为True
         :param indexes: 需要创建索引的列列表，可选
-        :param update_on_duplicate: 遇到重复数据时是否更新旧数据(默认为False)
+        :param update_on_duplicate: 遇到重复数据时是否更新旧数据，默认为False
         :param transaction_mode: 事务模式，可选值：
-        - 'row'     : 逐行提交事务（错误隔离性好）
-        - 'batch'   : 整批提交事务（性能最优）
-        - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
-            默认值为 'batch'
+            - 'row'     : 逐行提交事务（错误隔离性好）
+            - 'batch'   : 整批提交事务（性能最优）
+            - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
         :raises: 可能抛出各种验证和数据库相关异常
         """
         # upload_start = time.time()
@@ -1091,9 +1123,8 @@ class MySQLUploader:
             table_name: str,
             data: List[Dict],
             set_typ: Dict[str, str],
-            check_duplicate: bool = False,
-            duplicate_columns: Optional[List[str]] = None,
-            batch_size: int = 1000,
+            check_duplicate: bool,
+            duplicate_columns: Optional[List[str]],
             batch_id: Optional[str] = None,
             update_on_duplicate: bool = False,
             transaction_mode: str = "batch"
@@ -1105,16 +1136,14 @@ class MySQLUploader:
         :param table_name: 表名
         :param data: 要插入的数据列表
         :param set_typ: 列名和数据类型字典 {列名: 数据类型}
-        :param check_duplicate: 是否检查重复数据，默认为False
+        :param check_duplicate: 是否检查重复数据
         :param duplicate_columns: 用于检查重复的列，可选
-        :param batch_size: 批量插入大小，默认为1000
-        :param update_on_duplicate: 遇到重复数据时是否更新旧数据(默认为False)
         :param batch_id: 批次ID用于日志追踪，可选
+        :param update_on_duplicate: 遇到重复数据时是否更新旧数据，默认为False
         :param transaction_mode: 事务模式，可选值：
-        - 'row'     : 逐行提交事务（错误隔离性好）
-        - 'batch'   : 整批提交事务（性能最优）
-        - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
-            默认值为 'batch'
+            - 'row'     : 逐行提交事务（错误隔离性好）
+            - 'batch'   : 整批提交事务（性能最优）
+            - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
         """
         if not data:
             return
@@ -1133,7 +1162,8 @@ class MySQLUploader:
         total_inserted, total_skipped, total_failed = self._execute_batch_insert(
             db_name, table_name, data, set_typ,
             sql, check_duplicate, duplicate_columns,
-            batch_size, batch_id, transaction_mode
+            batch_id, transaction_mode,
+            update_on_duplicate
         )
 
         logger.info('插入完成', {
@@ -1168,16 +1198,18 @@ class MySQLUploader:
             VALUES ({placeholders})
         """
 
-        # # 情况2：不检查重复但允许更新
-        # if update_on_duplicate:
-        #     update_clause = ", ".join([f"`{col}` = VALUES(`{col}`)"
-        #                                for col in columns])
-        #     sql += f" ON DUPLICATE KEY UPDATE {update_clause}"
+        # 情况2：不检查重复但允许更新
+        if update_on_duplicate:
+            update_clause = ", ".join([f"`{col}` = VALUES(`{col}`)"
+                                     for col in columns])
+            sql += f" ON DUPLICATE KEY UPDATE {update_clause}"
 
         return sql
 
     def _build_duplicate_check_sql(self, db_name, table_name, all_columns,
                                    duplicate_columns, update_on_duplicate, set_typ):
+        if duplicate_columns is None:
+            duplicate_columns = []
         duplicate_columns = [_item for _item in duplicate_columns if _item.lower() not in self.base_excute_col]
         safe_columns = [self._validate_identifier(col) for col in all_columns]
         placeholders = ','.join(['%s'] * len(safe_columns))
@@ -1286,11 +1318,25 @@ class MySQLUploader:
             sql: str,
             check_duplicate: bool,
             duplicate_columns: Optional[List[str]],
-            batch_size: int,
             batch_id: Optional[str],
-            transaction_mode: str
+            transaction_mode: str,
+            update_on_duplicate: bool = False
     ) -> Tuple[int, int, int]:
         """执行批量插入操作"""
+
+        def get_optimal_batch_size(total_rows: int) -> int:
+            # 根据数据量调整批量大小
+            if total_rows <= 100:
+                return total_rows
+            elif total_rows <= 1000:
+                return 500
+            elif total_rows <= 10000:
+                return 1000
+            else:
+                return 2000
+        
+        batch_size = get_optimal_batch_size(len(data))
+        
         # 获取所有列名（排除id列）
         all_columns = [col for col in set_typ.keys()
                        if col.lower() != 'id']
@@ -1306,7 +1352,7 @@ class MySQLUploader:
                     batch_inserted, batch_skipped, batch_failed = self._process_batch(
                         conn, cursor, db_name, table_name, batch, all_columns,
                         sql, check_duplicate, duplicate_columns, batch_id,
-                        transaction_mode, i, len(data)
+                        transaction_mode, i, len(data), update_on_duplicate
                     )
 
                     # 更新总统计
@@ -1330,7 +1376,8 @@ class MySQLUploader:
             batch_id: Optional[str],
             transaction_mode: str,
             batch_index: int,
-            total_data_length: int
+            total_data_length: int,
+            update_on_duplicate: bool = False
     ) -> Tuple[int, int, int]:
         """处理单个批次的数据插入"""
         batch_inserted = 0
@@ -1344,7 +1391,8 @@ class MySQLUploader:
                     result = self._process_single_row(
                         db_name, table_name,
                         cursor, row, all_columns, sql,
-                        check_duplicate, duplicate_columns
+                        check_duplicate, duplicate_columns,
+                        update_on_duplicate
                     )
                     if result == 'inserted':
                         batch_inserted += 1
@@ -1376,7 +1424,8 @@ class MySQLUploader:
                     result = self._process_single_row(
                         db_name, table_name,
                         cursor, row, all_columns, sql,
-                        check_duplicate, duplicate_columns
+                        check_duplicate, duplicate_columns,
+                        update_on_duplicate
                     )
                     if result == 'inserted':
                         batch_inserted += 1
@@ -1400,7 +1449,6 @@ class MySQLUploader:
                         '批次/当前行': f'{batch_id}  {row_idx}/{len(batch)}',
                         'error_type': type(e).__name__,
                         '单行插入失败': str(e),
-                        '数据类型': set_typ,
                         '是否排重': check_duplicate,
                         '排重列': duplicate_columns,
                         '事务模式': transaction_mode,
@@ -1421,21 +1469,24 @@ class MySQLUploader:
             all_columns: List[str],
             sql: str,
             check_duplicate: bool,
-            duplicate_columns: Optional[List[str]]
+            duplicate_columns: Optional[List[str]],
+            update_on_duplicate: bool = False
     ) -> str:
         """处理单行数据插入"""
         try:
             # 准备参数
             row_values = [row.get(col) for col in all_columns]
+            
+            # 确定排重列（排除id和更新时间列）
+            dup_cols = duplicate_columns if duplicate_columns else [
+                col for col in all_columns
+                if col.lower() not in self.base_excute_col
+            ]
+            
             if check_duplicate:
-                # 确定排重列（排除id和更新时间列）
-                dup_cols = duplicate_columns if duplicate_columns else [
-                    col for col in all_columns
-                    if col.lower() not in self.base_excute_col
-                ]
-
                 # 添加排重条件参数
-                row_values += [row.get(col) for col in dup_cols]
+                dup_values = [row.get(col) for col in dup_cols]
+                row_values.extend(dup_values)
 
             # logger.info(sql)
             # logger.info(row_values)
@@ -1459,6 +1510,10 @@ class MySQLUploader:
     def close(self):
         """
         关闭连接池并清理资源
+        
+        这个方法会安全地关闭数据库连接池，并清理相关资源。
+        建议结束时手动调用此方法。
+        
         :raises: 可能抛出关闭连接时的异常
         """
         try:
@@ -1486,16 +1541,24 @@ class MySQLUploader:
 
         :return: 连接池健康返回True，否则返回False
         """
+        conn = None
         try:
             conn = self.pool.connection()
             conn.ping(reconnect=True)
-            conn.close()
             return True
         except Exception as e:
             logger.warning("连接池健康检查失败", {
                 'error': str(e)
             })
             return False
+        finally:
+            if conn:
+                try:
+                    conn.close()
+                except Exception as e:
+                    logger.warning("关闭连接时出错", {
+                        'error': str(e)
+                    })
 
     def retry_on_failure(max_retries=3, delay=1):
         def decorator(func):
@@ -1527,6 +1590,16 @@ class MySQLUploader:
 
 
 def main():
+    """
+    示例代码：
+    
+    这个示例展示了如何：
+    1. 创建上传器实例
+    2. 定义数据表结构
+    3. 准备测试数据
+    4. 上传数据到数据库
+    5. 关闭连接
+    """
     uploader = MySQLUploader(
         username='root',
         password='pw',

{mdbq-3.10.7.dist-info → mdbq-3.10.8.dist-info}/METADATA

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

{mdbq-3.10.7.dist-info → mdbq-3.10.8.dist-info}/RECORD

@@ -1,18 +1,18 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=luTjFBlvNtusrL5oiS9aezU8M7ZT0e3xyxokQP2F1Es,18
+mdbq/__version__.py,sha256=3bjRR4HE9A875_CgBnallmc2aayagpc0BO_tqJqU6vE,18
 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
 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=1c4ij0BlSeFvjLoglJCcFXkYfAUw3Zuh2HjMmRd5fa8,24495
+mdbq/log/mylogger.py,sha256=07sstIeaIQUJXwpMwmxppRI7kW7QwZFnv4Rr3UDlyUs,24133
 mdbq/log/spider_logging.py,sha256=-ozWWEGm3HVv604ozs_OOvVwumjokmUPwbaodesUrPY,1664
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
 mdbq/mysql/deduplicator.py,sha256=brhX3eyE8-kn3nAYweKfBbAkXiNcyw_pL4CTyPqmPBg,21983
 mdbq/mysql/mysql.py,sha256=Fzaqbjg5g3HdNl50jInIrdurdzcgR2CCzdKLVImD1-Q,55339
 mdbq/mysql/s_query.py,sha256=X055aLRAgxVvueXx4NbfNjp6MyBI02_XBb1pTKw09L0,8660
-mdbq/mysql/uploader.py,sha256=Lw9lgzmJkr5ojHQ_VMy4z710ZJpIoH7pzn4zrpZokms,62371
+mdbq/mysql/uploader.py,sha256=3RzslC10pNIYm-0NASicvCHXH0zgUXx7uD1jE21z_OU,64677
 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
@@ -25,7 +25,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=YyPWa_nOH1zs8wgTDcgzn5w8szGKWPyWzmWMVIPkFnU,21638
-mdbq-3.10.7.dist-info/METADATA,sha256=bsu32knUObF_BeSlp2OYExxro_8H1ygHLX2ZMay9Bug,364
-mdbq-3.10.7.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-mdbq-3.10.7.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.10.7.dist-info/RECORD,,
+mdbq-3.10.8.dist-info/METADATA,sha256=-hNRDByZy-pto3aGS3WGlOivKQCC8CpM5NHy5yd8VgI,364
+mdbq-3.10.8.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+mdbq-3.10.8.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.10.8.dist-info/RECORD,,