mdbq 3.9.16__tar.gz → 3.9.18__tar.gz

{mdbq-3.9.16 → mdbq-3.9.18}/PKG-INFO

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

mdbq-3.9.18/mdbq/__version__.py

@@ -0,0 +1 @@
+VERSION = '3.9.18'

{mdbq-3.9.16 → mdbq-3.9.18}/mdbq/log/mylogger.py

@@ -14,7 +14,6 @@ import inspect
 
 try:
     import psutil
-
     HAS_PSUTIL = True
 except ImportError:
     HAS_PSUTIL = False
@@ -22,9 +21,9 @@ except ImportError:
 
 class MyLogger:
     """
-    增强版结构化日志记录器，支持多种高级功能
+    日志记录器
 
-    功能增强：
+    功能：
     - 异步日志记录（减少I/O阻塞）
     - 上下文管理器支持
     - 自定义日志过滤器
@@ -71,10 +70,10 @@ class MyLogger:
             flush_interval: int = 5
     ):
         """
-        初始化日志记录器
+        初始化日志器
 
-        :param name: 日志记录器名称
-        :param logging_mode: 日志输出模式
+        :param name: 日志器名称
+        :param logging_mode: 输出模式
         :param log_level: 日志级别
         :param log_file: 日志文件路径
         :param max_log_size: 单个日志文件最大大小(MB)
@@ -391,6 +390,10 @@ class MyLogger:
         if not hasattr(self.logger, level.lower()):
             return
 
+        # message 仅接收字符串类型
+        if not isinstance(message, str):
+            message = str(message)
+
         # 简化日志内容，避免过长
         if len(message) > self.message_limited:
             message = message[:self.message_limited] + '...'

{mdbq-3.9.16 → mdbq-3.9.18}/mdbq/mysql/uploader.py

@@ -13,6 +13,7 @@ from typing import Union, List, Dict, Optional, Any, Tuple, Set
 from dbutils.pooled_db import PooledDB
 import json
 from collections import OrderedDict
+import sys
 
 warnings.filterwarnings('ignore')
 logger = mylogger.MyLogger(
@@ -301,7 +302,10 @@ class MySQLUploader:
                     logger.debug(f"{db_name} 数据库已存在: {exists}")
                     return exists
         except Exception as e:
-            logger.error(f"检查数据库是否存在时出错: {str(e)}")
+            logger.error(sys._getframe().f_code.co_name, {
+                '检查数据库是否存在时出错': str(e),
+                '库': db_name
+            })
             raise
 
     def _create_database(self, db_name: str):
@@ -321,7 +325,10 @@ class MySQLUploader:
                 conn.commit()
                 logger.info(f"`{db_name}` 数据库已创建")
         except Exception as e:
-            logger.error(f"无法创建数据库: `{db_name}` -> {str(e)}")
+            logger.error(sys._getframe().f_code.co_name, {
+                '无法创建数据库': str(e),
+                '库': db_name
+            })
             conn.rollback()
             raise
 
@@ -339,18 +346,22 @@ class MySQLUploader:
             # date_obj = datetime.datetime.strptime(date_value, '%Y-%m-%d')
             date_obj = self._validate_datetime(date_value, True)
         except ValueError:
-            error_msg = f"`{table_name}` 无效的日期格式1: `{date_value}`"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '无效的日期格式1': date_value,
+                '表': table_name
+            })
+            raise ValueError(f"`{table_name}` 无效的日期格式1: `{date_value}`")
 
         if partition_by == 'year':
             return f"{table_name}_{date_obj.year}"
         elif partition_by == 'month':
             return f"{table_name}_{date_obj.year}_{date_obj.month:02d}"
         else:
-            error_msg = "分表方式必须是 'year' 或 'month'"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                "分表方式必须是 'year' 或 'month'": partition_by,
+                '表': table_name
+            })
+            raise ValueError("分表方式必须是 'year' 或 'month'")
 
     def _validate_identifier(self, identifier: str) -> str:
         """
@@ -361,9 +372,10 @@ class MySQLUploader:
         :raises ValueError: 当标识符无效时抛出
         """
         if not identifier or not isinstance(identifier, str):
-            error_msg = f"无效的标识符: `{identifier}`"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '无效的标识符': identifier
+            })
+            raise ValueError(f"无效的标识符: `{identifier}`")
 
         # 移除非法字符，只保留字母、数字、下划线和美元符号
         cleaned = re.sub(r'[^\w\u4e00-\u9fff$]', '_', identifier)
@@ -372,9 +384,10 @@ class MySQLUploader:
         cleaned = re.sub(r'_+', '_', cleaned).strip('_')
 
         if not cleaned:
-            error_msg = f"无法清理异常标识符: `{identifier}`"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '无法清理异常标识符': identifier
+            })
+            raise ValueError(f"无法清理异常标识符: `{identifier}`")
 
         # 检查是否为MySQL保留字
         mysql_keywords = {
@@ -416,7 +429,10 @@ class MySQLUploader:
                     cursor.execute(sql, (db_name, table_name))
                     result = bool(cursor.fetchone())
         except Exception as e:
-            logger.error(f"检查数据表是否存在时发生未知错误: {e}", )
+            logger.error(sys._getframe().f_code.co_name, {
+                '库': db_name,
+                '表': table_name,
+                '检查数据表是否存在时发生未知错误': str(e)})
             raise
 
         # 执行查询并缓存结果
@@ -449,9 +465,11 @@ class MySQLUploader:
         table_name = self._validate_identifier(table_name)
 
         if not set_typ:
-            error_msg = "No columns specified for table creation"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '库': db_name,
+                '表': table_name,
+                'set_typ 未指定': set_typ})
+            raise ValueError('set_typ 未指定')
 
         # 构建列定义SQL
         column_defs = ["`id` INT NOT NULL AUTO_INCREMENT"]
@@ -527,7 +545,11 @@ class MySQLUploader:
                 logger.info(f"索引已添加: `{db_name}`.`{table_name}` -> `{indexes}`")
 
         except Exception as e:
-            logger.error(f"`{db_name}`.`{table_name}`: 建表失败: {str(e)}")
+            logger.error(sys._getframe().f_code.co_name, {
+                '建表失败': str(e),
+                '库': db_name,
+                '表': table_name,
+            })
             conn.rollback()
             raise
 
@@ -624,9 +646,10 @@ class MySQLUploader:
             else:
                 return value
         except (ValueError, TypeError) as e:
-            error_msg = f"转换异常 -> 无法将 `{value}` 的数据类型转为: `{column_type}` -> {str(e)}"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                f'转换异常, 无法将 `{value}` 的数据类型转为: `{column_type}`': str(e),
+            })
+            raise ValueError(f"转换异常 -> 无法将 `{value}` 的数据类型转为: `{column_type}` -> {str(e)}")
 
     def _get_table_columns(self, db_name: str, table_name: str) -> Dict[str, str]:
         """
@@ -654,7 +677,11 @@ class MySQLUploader:
                     logger.debug(f"`{db_name}`.`{table_name}`: 获取表的列信息: `{set_typ}`")
                     return set_typ
         except Exception as e:
-            logger.error(f"无法获取表列信息: {str(e)}")
+            logger.error(sys._getframe().f_code.co_name, {
+                '无法获取表列信息': str(e),
+                '库': db_name,
+                '表': table_name,
+            })
             raise
 
     def _upload_to_table(
@@ -680,23 +707,32 @@ class MySQLUploader:
                 self._create_table(db_name, table_name, set_typ, primary_keys, date_column, indexes,
                                    allow_null=allow_null)
             else:
-                error_msg = f"数据表不存在: `{db_name}`.`{table_name}`"
-                logger.error(error_msg)
-                raise ValueError(error_msg)
+                logger.error(sys._getframe().f_code.co_name, {
+                    '数据表不存在': table_name,
+                    '库': db_name,
+                    '表': table_name,
+                })
+                raise ValueError(f"数据表不存在: `{db_name}`.`{table_name}`")
 
         # 获取表结构并验证
         table_columns = self._get_table_columns(db_name, table_name)
         if not table_columns:
-            error_msg = f"获取列失败 `{db_name}`.`{table_name}`"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '获取列失败': table_columns,
+                '库': db_name,
+                '表': table_name,
+            })
+            raise ValueError(f"获取列失败 `{db_name}`.`{table_name}`")
 
         # 验证数据列与表列匹配
         for col in set_typ:
             if col not in table_columns:
-                error_msg = f"列不存在: `{col}` -> `{db_name}`.`{table_name}`"
-                logger.error(error_msg)
-                raise ValueError(error_msg)
+                logger.error(sys._getframe().f_code.co_name, {
+                    '列不存在': f'{col} -> {table_columns}',
+                    '库': db_name,
+                    '表': table_name,
+                })
+                raise ValueError(f"列不存在: `{col}` -> `{db_name}`.`{table_name}`")
 
         # 插入数据
         self._insert_data(
@@ -808,7 +844,10 @@ class MySQLUploader:
                 data.columns = [col.lower() for col in data.columns]
                 data = data.replace({pd.NA: None}).to_dict('records')
             except Exception as e:
-                logger.error(f"数据转字典时发生错误: {e}", )
+                logger.error(sys._getframe().f_code.co_name, {
+                '数据转字典时发生错误': str(e),
+                '数据': data,
+                })
                 raise ValueError(f"数据转字典时发生错误: {e}")
         elif isinstance(data, dict):
             data = [{k.lower(): v for k, v in data.items()}]
@@ -816,9 +855,10 @@ class MySQLUploader:
             # 将列表中的每个字典键转为小写
             data = [{k.lower(): v for k, v in item.items()} for item in data]
         else:
-            error_msg = "数据结构必须是字典、列表、字典列表或dataframe"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
+            logger.error(sys._getframe().f_code.co_name, {
+                '数据结构必须是字典、列表、字典列表或dataframe': data,
+            })
+            raise ValueError("数据结构必须是字典、列表、字典列表或dataframe")
 
         # 统一处理原始数据中列名的特殊字符
         data = self.normalize_column_names(data)
@@ -860,15 +900,19 @@ 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:
                     try:
                         prepared_row[col_name] = self._validate_value(row[col_name], filtered_set_typ[col_name], allow_null)
                     except ValueError as e:
-                        error_msg = f"行号:{row_idx}, 列名:`{col_name}`-> 报错: {str(e)}"
-                        logger.error(error_msg)
-                        raise ValueError(error_msg)
+                        logger.error(sys._getframe().f_code.co_name, {
+                            '列': col_name,
+                            '行': row_idx,
+                            '报错': str(e),
+                        })
+                        raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
             prepared_data.append(prepared_row)
 
         logger.debug(f"已准备 {len(prepared_data)} 行数据")
@@ -932,9 +976,13 @@ class MySQLUploader:
             if partition_by:
                 partition_by = str(partition_by).lower()
                 if partition_by not in ['year', 'month']:
-                    error_msg = "分表方式必须是 'year' 或 'month' 或 'None'"
-                    logger.error(error_msg)
-                    raise ValueError(error_msg)
+                    logger.error(sys._getframe().f_code.co_name, {
+                        '分表方式必须是 "year" 或 "month" 或 "None"':  partition_by,
+                        '库': db_name,
+                        '表': table_name,
+                        '批次': batch_id
+                    })
+                    raise ValueError("分表方式必须是 'year' 或 'month' 或 'None'")
 
             # 准备数据
             prepared_data, filtered_set_typ = self._prepare_data(data, set_typ, allow_null)
@@ -944,9 +992,10 @@ class MySQLUploader:
                 if auto_create:
                     self._create_database(db_name)
                 else:
-                    error_msg = f"数据库不存在: `{db_name}`"
-                    logger.error(error_msg)
-                    raise ValueError(error_msg)
+                    logger.error(sys._getframe().f_code.co_name, {
+                        '数据库不存在': db_name
+                    })
+                    raise ValueError(f"数据库不存在: `{db_name}`")
 
             # 处理分表逻辑
             if partition_by:
@@ -954,7 +1003,7 @@ class MySQLUploader:
                 for row in prepared_data:
                     try:
                         if partition_date_column not in row:
-                            logger.error('缺失列',{
+                            logger.error(sys._getframe().f_code.co_name,{
                                 '库': db_name,
                                 '表': table_name,
                                 '批次': batch_id,
@@ -971,9 +1020,11 @@ class MySQLUploader:
                             partitioned_data[part_table] = []
                         partitioned_data[part_table].append(row)
                     except Exception as e:
-                        logger.error("分表处理失败", {
+                        logger.error(sys._getframe().f_code.co_name, {
                             'row_data': row,
-                            'error': str(e)
+                            '分表处理失败': str(e),
+                            '库': db_name,
+                            '表': table_name,
                         })
                         continue  # 跳过当前行
 
@@ -987,9 +1038,11 @@ class MySQLUploader:
                             indexes, batch_id, update_on_duplicate
                         )
                     except Exception as e:
-                        logger.error("分表上传失败", {
+                        logger.error(sys._getframe().f_code.co_name, {
                             '分表': part_table,
-                            'error': str(e)
+                            '分表上传失败': str(e),
+                            '库': db_name,
+                            '表': table_name,
                         })
                         continue  # 跳过当前分表，继续处理其他分表
             else:
@@ -1004,12 +1057,14 @@ class MySQLUploader:
             success_flag = True
 
         except Exception as e:
-            logger.error("上传过程发生全局错误", {
-                'error': str(e),
-                'error_type': type(e).__name__
+            logger.error(sys._getframe().f_code.co_name, {
+                '上传过程发生全局错误': str(e),
+                'error_type': type(e).__name__,
+                '库': db_name,
+                '表': table_name,
             })
         finally:
-            logger.info("上传处理完成", {
+            logger.info("存储完成", {
                 '库': db_name,
                 '表': table_name,
                 '批次': batch_id,
@@ -1051,6 +1106,11 @@ class MySQLUploader:
         safe_columns = [self._validate_identifier(col) for col in all_columns]
         placeholders = ','.join(['%s'] * len(safe_columns))
 
+        # 初始化统计变量
+        total_inserted = 0
+        total_skipped = 0
+        total_failed = 0
+
         # 构建基础SQL语句
         if check_duplicate:
             if not duplicate_columns:
@@ -1061,10 +1121,7 @@ class MySQLUploader:
             conditions = []
             for col in duplicate_columns:
                 col_type = set_typ.get(col, '').lower()
-
-                # 处理DECIMAL类型，使用ROUND确保精度一致
                 if col_type.startswith('decimal'):
-                    # 提取小数位数，如DECIMAL(10,2)提取2
                     scale_match = re.search(r'decimal\(\d+,(\d+)\)', col_type)
                     scale = int(scale_match.group(1)) if scale_match else 2
                     conditions.append(f"ROUND(`{self._validate_identifier(col)}`, {scale}) = ROUND(%s, {scale})")
@@ -1082,10 +1139,6 @@ class MySQLUploader:
                     VALUES ({placeholders})
                     ON DUPLICATE KEY UPDATE {update_clause}
                     """
-
-                # 注意：在update_on_duplicate模式下，row_values只需要插入数据，不需要排重列值
-                def prepare_values(row):
-                    return [row.get(col) for col in all_columns]
             else:
                 sql = f"""INSERT INTO `{db_name}`.`{table_name}` 
                     (`{'`,`'.join(safe_columns)}`) 
@@ -1096,10 +1149,6 @@ class MySQLUploader:
                         WHERE {where_clause}
                     )
                     """
-
-                # 在check_duplicate模式下，row_values需要插入数据+排重列值
-                def prepare_values(row):
-                    return [row.get(col) for col in all_columns] + [row.get(col) for col in duplicate_columns]
         else:
             sql = f"""
                 INSERT INTO `{db_name}`.`{table_name}` 
@@ -1107,68 +1156,64 @@ class MySQLUploader:
                 VALUES ({placeholders})
                 """
 
-            # 普通模式下，row_values只需要插入数据
-            def prepare_values(row):
-                return [row.get(col) for col in all_columns]
-
-        total_inserted = 0
-        total_skipped = 0
-        total_failed = 0  # 失败计数器
-
         # 分批插入数据
         with self._get_connection() as conn:
             with conn.cursor() as cursor:
                 for i in range(0, len(data), batch_size):
-                    batch_start = time.time()
                     batch = data[i:i + batch_size]
-                    successful_rows = 0  # 当前批次成功数
+                    batch_inserted = 0
+                    batch_skipped = 0
+                    batch_failed = 0
 
                     for row in batch:
                         try:
                             # 准备参数
-                            row_values = prepare_values(row)
+                            row_values = [row.get(col) for col in all_columns]
+                            if check_duplicate and not update_on_duplicate:
+                                row_values += [row.get(col) for col in duplicate_columns]
+
                             cursor.execute(sql, row_values)
-                            successful_rows += 1
-                            conn.commit()  # 每次成功插入后提交
 
-                        except Exception as e:
-                            conn.rollback()  # 回滚当前行的事务
-                            total_failed += 1
+                            if check_duplicate:
+                                # 检查是否实际插入了行
+                                if cursor.rowcount > 0:
+                                    batch_inserted += 1
+                                else:
+                                    batch_skipped += 1
+                            else:
+                                batch_inserted += 1
+
+                            conn.commit()
 
-                            # 记录失败行详细信息
-                            logger.error(f"单行插入失败", {
+                        except Exception as e:
+                            conn.rollback()
+                            batch_failed += 1
+                            logger.error(sys._getframe().f_code.co_name, {
                                 '库': db_name,
                                 '表': table_name,
                                 '批次': batch_id,
                                 'error_type': type(e).__name__,
-                                'error_message': str(e),
+                                '单行插入失败': str(e),
                                 '数据类型': set_typ,
                                 '是否排重': check_duplicate,
                                 '排重列': duplicate_columns
                             })
-                            continue  # 跳过当前行，继续处理下一行
-
-                    # 更新统计信息
-                    if check_duplicate:
-                        cursor.execute("SELECT ROW_COUNT()")
-                        affected_rows = cursor.rowcount
-                        total_inserted += affected_rows
-                        total_skipped += len(batch) - affected_rows - (len(batch) - successful_rows)
-                    else:
-                        total_inserted += successful_rows
 
-                    batch_elapsed = round(time.time() - batch_start, 2)
-                    logger.debug("批次处理完成", {
+                    # 更新总统计
+                    total_inserted += batch_inserted
+                    total_skipped += batch_skipped
+                    total_failed += batch_failed
+
+                    logger.debug(sys._getframe().f_code.co_name, {
                         '库': db_name,
                         '表': table_name,
                         '批次': batch_id,
-                        'batch_index': i // batch_size + 1,
-                        'total_batches': (len(data) + batch_size - 1) // batch_size,
-                        'batch_size': len(batch),
-                        'successful_rows': successful_rows,
-                        'failed_rows': len(batch) - successful_rows,
-                        '耗时': batch_elapsed,
-                        'rows_per_second': successful_rows / batch_elapsed if batch_elapsed > 0 else 0
+                        '批次处理完成': i // batch_size + 1,
+                        '总批次': (len(data) + batch_size - 1) // batch_size,
+                        '数据量': len(batch),
+                        '插入': batch_inserted,
+                        '跳过': batch_skipped,
+                        '失败': batch_failed
                     })
 
         logger.info('插入完成', {

{mdbq-3.9.16 → mdbq-3.9.18}/mdbq.egg-info/PKG-INFO

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

mdbq-3.9.16/mdbq/__version__.py

@@ -1 +0,0 @@
-VERSION = '3.9.16'