mdbq 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.1.1'
+VERSION = '4.1.3'

mdbq/myconf/myconf.py

@@ -1,22 +1,22 @@
 import re
 from typing import Dict, Any, Optional, Union, List, Tuple, Type, TypeVar
 from pathlib import Path
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 from dataclasses import dataclass, field
 from enum import Enum
 import time
 
-logger = mylogger.MyLogger(
-    logging_mode='both',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,  # 是否启用异步日志
-    sample_rate=1,  # 采样DEBUG/INFO日志
-    sensitive_fields=[],  #  敏感字段过滤
-    enable_metrics=False,  # 是否启用性能指标
-)
+# logger = mylogger.MyLogger(
+#     logging_mode='both',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,  # 是否启用异步日志
+#     sample_rate=1,  # 采样DEBUG/INFO日志
+#     sensitive_fields=[],  #  敏感字段过滤
+#     enable_metrics=False,  # 是否启用性能指标
+# )
 
 T = TypeVar('T')  # 类型变量
 
@@ -151,12 +151,10 @@ class ConfigParser:
     def open(self, file_path: Union[str, Path]) -> 'ConfigParser':
         """打开配置文件"""
         file_path = Path(file_path)
-        logger.debug(f'尝试打开配置文件: {file_path}')
         if not file_path.exists() and not self.options.auto_create:
-            logger.error(f'配置文件不存在: {file_path}')
+            # logger.error(f'配置文件不存在: {file_path}')
             raise ConfigException.file_not_found(file_path)
         self._current_file = file_path
-        logger.debug(f'配置文件已打开: {file_path}')
         return self
 
     def _ensure_file_open(self) -> None:
@@ -211,7 +209,6 @@ class ConfigParser:
     
     def _update_cache(self, file_path: str, config: Dict[str, Any]) -> None:
         """更新配置缓存"""
-        logger.debug(f'更新配置缓存: {file_path}')
         self._config_cache[file_path] = config
         self._cache_timestamps[file_path] = time.time()
     
@@ -236,13 +233,11 @@ class ConfigParser:
     def _clear_cache(self, file_path: Optional[str] = None) -> None:
         """清除配置缓存"""
         if file_path:
-            logger.debug(f'清除指定文件的缓存: {file_path}')
             self._config_cache.pop(file_path, None)
             self._cache_timestamps.pop(file_path, None)
             self._comments_cache.pop(file_path, None)
             self._section_map.pop(file_path, None)
         else:
-            logger.debug('清除所有配置缓存')
             self._config_cache.clear()
             self._cache_timestamps.clear()
             self._comments_cache.clear()
@@ -323,12 +318,11 @@ class ConfigParser:
                  default: Any = None, value_type: Optional[Type[T]] = None,
                  file_path: Optional[Union[str, Path]] = None) -> T:
         """获取指定配置项的值"""
-        logger.debug(f'获取配置项: section={section}, key={key}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
         if not self._validate_key(key):
-            logger.error(f'无效的键名: {key}')
+            # logger.error(f'无效的键名: {key}')
             raise ConfigException.invalid_key_error(key, file_path, section)
         config = self.read(file_path)
         section = section or self.options.default_section
@@ -336,15 +330,15 @@ class ConfigParser:
         original_section = self._get_original_section(str(file_path), normalized_section)
         if original_section is None:
             if default is not None:
-                logger.warning(f'节不存在，返回默认值: section={section}, key={key}, default={default}')
+                # logger.warning(f'节不存在，返回默认值: section={section}, key={key}, default={default}')
                 return default
-            logger.error(f'配置节不存在: {section}')
+            # logger.error(f'配置节不存在: {section}')
             raise ConfigException.section_not_found(file_path, section)
         if key not in config[original_section]:
             if default is not None:
-                logger.warning(f'键不存在，返回默认值: section={section}, key={key}, default={default}')
+                # logger.warning(f'键不存在，返回默认值: section={section}, key={key}, default={default}')
                 return default
-            logger.error(f'配置键不存在: {key}')
+            # logger.error(f'配置键不存在: {key}')
             raise ConfigException.key_not_found(file_path, original_section, key)
         value = config[original_section][key]
         if value_type is not None:
@@ -356,7 +350,6 @@ class ConfigParser:
                   value_types: Optional[Dict[str, Type]] = None,
                   file_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
         """批量获取多个配置项的值"""
-        logger.debug(f'批量获取配置项: section={section}, keys={keys}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -375,7 +368,7 @@ class ConfigParser:
                 )
                 result[key] = value
             except ConfigException as e:
-                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
+                # logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result[key] = defaults[key]
                 else:
@@ -388,7 +381,6 @@ class ConfigParser:
                           value_types: Optional[Dict[str, Type]] = None,
                           file_path: Optional[Union[str, Path]] = None) -> Tuple[Any, ...]:
         """获取指定节点下多个键的值元组"""
-        logger.debug(f'获取节下多个键的值: section={section}, keys={keys}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -407,7 +399,7 @@ class ConfigParser:
                 )
                 result.append(value)
             except ConfigException as e:
-                logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
+                # logger.error(f"读取配置项失败: section={section}, key={key}, error={e}")
                 if key in defaults:
                     result.append(defaults[key])
                 else:
@@ -419,7 +411,6 @@ class ConfigParser:
                  value_type: Optional[Type] = None,
                  file_path: Optional[Union[str, Path]] = None) -> None:
         """设置指定配置项的值"""
-        logger.debug(f'准备写入配置项: section={section}, key={key}, value={value}, file_path={file_path}')
         if file_path is None:
             self._ensure_file_open()
             file_path = self._current_file
@@ -427,7 +418,7 @@ class ConfigParser:
             file_path = Path(file_path)
             
         if not self._validate_key(key):
-            logger.error(f'无效的键名: {key}')
+            # logger.error(f'无效的键名: {key}')
             raise ConfigException.invalid_key_error(key, file_path, section)
             
         section = section or self.options.default_section
@@ -452,7 +443,7 @@ class ConfigParser:
                     else:
                         value = value_type(value)
                 except (ValueError, TypeError) as e:
-                    logger.error(f'类型转换失败: value={value}, type={value_type}, error={e}')
+                    # logger.error(f'类型转换失败: value={value}, type={value_type}, error={e}')
                     raise ConfigException.conversion_error(value, value_type, file_path, section=section, key=key)
                     
             if isinstance(value, bool):
@@ -509,21 +500,20 @@ class ConfigParser:
                     file.write(f'{key}={value}\n')
                     
             self._clear_cache(str(file_path))
-            logger.info(f'配置项写入成功: section={section}, key={key}, value={value}, file_path={file_path}')
+            # logger.info(f'配置项写入成功: section={section}, key={key}, value={value}, file_path={file_path}')
             
         except Exception as e:
-            logger.error(f'写入配置项失败: section={section}, key={key}, value={value}, file_path={file_path}, error={e}')
+            # logger.error(f'写入配置项失败: section={section}, key={key}, value={value}, file_path={file_path}, error={e}')
             raise ConfigException.write_error(file_path, e)
 
     def set_values(self, section: Optional[str] = None, values: Dict[str, Any] = None,
                   value_types: Optional[Dict[str, Type]] = None,
                   file_path: Optional[Union[str, Path]] = None) -> None:
         """批量设置多个配置项的值"""
-        logger.debug(f'批量写入配置项: section={section}, keys={list(values.keys())}, file_path={file_path}')
         for key, value in values.items():
             value_type = value_types.get(key) if value_types else None
             self.set_value(section, key, value, value_type, file_path)
-        logger.info(f'批量写入配置项完成: section={section}, file_path={file_path}')
+        # logger.info(f'批量写入配置项完成: section={section}, file_path={file_path}')
 
     def validate_config(self, section: Optional[str] = None, schema: Dict[str, Type] = None,
                        file_path: Optional[Union[str, Path]] = None) -> bool:
@@ -560,17 +550,15 @@ class ConfigParser:
         else:
             file_path = Path(file_path)
         
-        logger.debug(f'开始读取配置文件: {file_path}')
         cached_config = self._get_cached_config(str(file_path))
         if cached_config is not None:
-            logger.debug(f'命中配置缓存: {file_path}')
             return cached_config
         
         if not file_path.exists():
             if not self.options.auto_create:
-                logger.error(f'配置文件不存在: {file_path}')
+                # logger.error(f'配置文件不存在: {file_path}')
                 raise ConfigException.file_not_found(file_path)
-            logger.info(f'配置文件不存在，将创建: {file_path}')
+            # logger.info(f'配置文件不存在，将创建: {file_path}')
             file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.touch()
             return {}
@@ -592,7 +580,7 @@ class ConfigParser:
                     if stripped_line.startswith('[') and stripped_line.endswith(']'):
                         current_section = stripped_line[1:-1]
                         if not self._validate_key(current_section):
-                            logger.error(f'无效的节名: {current_section}')
+                            # logger.error(f'无效的节名: {current_section}')
                             raise ConfigException.invalid_section_error(current_section, file_path)
                         self._update_section_map(str(file_path), current_section)
                         if current_section not in config:
@@ -606,7 +594,7 @@ class ConfigParser:
                     if key_value:
                         key, value = key_value
                         if not self._validate_key(key):
-                            logger.error(f'无效的键名: {key}')
+                            # logger.error(f'无效的键名: {key}')
                             raise ConfigException.invalid_key_error(key, file_path, current_section)
                         value, comment = self._extract_comment(value)
                         
@@ -621,11 +609,10 @@ class ConfigParser:
                             self._comments_cache.setdefault(str(file_path), {}).setdefault(current_section, []).append(comment)
                 
                 self._update_cache(str(file_path), config)
-                logger.debug(f'配置文件读取成功: {file_path}')
                 return config
                 
         except Exception as e:
-            logger.error(f'读取配置文件失败: {file_path}, error={e}')
+            # logger.error(f'读取配置文件失败: {file_path}, error={e}')
             raise ConfigException.read_error(file_path, e)
 
 

mdbq/mysql/deduplicator.py

@@ -168,7 +168,7 @@ class MySQLDeduplicator:
             self._dedup_end_date = today.strftime("%Y-%m-%d")
         
         if self._dedup_start_date and self._dedup_end_date:
-            logger.info('去重日期范围', {'开始': self._dedup_start_date, '结束': self._dedup_end_date})
+            logger.debug('去重日期范围', {'开始': self._dedup_start_date, '结束': self._dedup_end_date})
 
         # 排除列处理，直接合并去重
         self.exclude_columns = list(set((exclude_columns or []) + ['id', '更新时间']))
@@ -515,7 +515,7 @@ class MySQLDeduplicator:
                         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, "数据日期": date_val})
+                            logger.debug('没有重复数据', {"库": database, "表": table, "数据量": total_count, "数据日期": date_val})
                             cursor.execute(drop_temp_sql)
                             conn.commit()
                             return (0, 0)
@@ -626,7 +626,7 @@ class MySQLDeduplicator:
                     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})
+                        logger.debug('没有重复数据', {"库": database, "表": table, "数据量": total_count})
                         cursor.execute(drop_temp_sql)
                         conn.commit()
                         return (0, 0)
@@ -722,7 +722,7 @@ class MySQLDeduplicator:
             if not self._check_table_exists(database, table):
                 logger.warning('表不存在', {"库": database, "表": table, "warning": "跳过"})
                 return (0, 0)
-            logger.info('单表开始', {
+            logger.debug('单表开始', {
                 "库": database, 
                 "表": table, 
                 # "参数": {
@@ -763,7 +763,7 @@ class MySQLDeduplicator:
                 if start_date and end_date:
                     all_dates = [d for d in all_dates if str(start_date) <= str(d) <= str(end_date)]
                 if not all_dates:
-                    logger.info('无可处理日期', {"库": database, "表": table})
+                    logger.debug('无可处理日期', {"库": database, "表": table})
                     return (0, 0)
                 total_dup = 0
                 total_del = 0
@@ -794,7 +794,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.info('单表完成', {"库": database, "表": table, "结果[重复, 删除]": (total_dup, total_del), '日期范围': f"{start_date} - {end_date}", "唯一列": columns})
+                logger.debug('单表完成', {"库": database, "表": table, "结果[重复, 删除]": (total_dup, total_del), '日期范围': f"{start_date} - {end_date}", "唯一列": columns})
                 # 自动重排id列（仅当有实际删除时且reorder_id为True）
                 if reorder_id and total_del > 0:
                     try:
@@ -858,7 +858,7 @@ class MySQLDeduplicator:
             if not target_tables:
                 logger.info('数据库中没有表', {"库": database, "操作": "跳过"})
                 return results
-            logger.info('库统计', {"库": database, "表数量": len(target_tables), "表列表": target_tables})
+            logger.debug('库统计', {"库": database, "表数量": len(target_tables), "表列表": target_tables})
             if parallel and self.max_workers > 1:
                 with concurrent.futures.ThreadPoolExecutor(
                         max_workers=self.max_workers
@@ -1073,9 +1073,9 @@ class MySQLDeduplicator:
             if hasattr(self, 'pool') and self.pool and not self._closed:
                 self.pool.close()
                 self._closed = True
-                logger.info("数据库连接池已关闭")
+                logger.debug("数据库连接池已关闭")
             else:
-                logger.info('连接池已关闭或不存在')
+                logger.debug('连接池已关闭或不存在')
         except Exception as e:
             logger.error(f"关闭连接池时出错", {'error_type': type(e).__name__, 'error': str(e)})
 
@@ -1172,7 +1172,7 @@ class MySQLDeduplicator:
                 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操作不可回滚，建议提前备份！"})
+            logger.debug('开始id重排', {"库": database, "表": table, "重排列": id_column, "试运行": dry_run, "DDL警告": "MySQL DDL操作不可回滚，建议提前备份！"})
             if dry_run:
                 logger.info('dry_run模式，打印原表结构', {"库": database, "表": table, "建表语句": create_table_sql})
                 return True
@@ -1370,7 +1370,7 @@ def main():
         # recent_month=1,
         # date_range=['2025-06-09', '2025-06-10'],
         exclude_columns=['更新时间'],
-        exclude_databases=['cookie文件', '日志', '视频数据', '云电影', 'api_monitor_logs', 'redis统计', 'standalone_auth', 'website_data'],
+        exclude_databases=['cookie文件', '日志', '视频数据', '云电影'],
         # exclude_tables={
         #     '推广数据2': [
         #         '地域报表_城市_2025_04', 

mdbq/mysql/s_query.py

@@ -16,7 +16,7 @@ from functools import wraps
 warnings.filterwarnings('ignore')
 logger = mylogger.MyLogger(
     logging_mode='file',
-    log_level='info',
+    log_level='error',
     log_format='json',
     max_log_size=50,
     backup_count=5,

mdbq/mysql/uploader.py

@@ -199,7 +199,7 @@ class MySQLUploader:
                 try:
                     result = func(self, *args, **kwargs)
                     if attempt > 0:
-                        logger.info('操作成功(重试后)', {'operation': operation, 'attempts': attempt + 1})
+                        logger.debug('操作成功(重试后)', {'operation': operation, 'attempts': attempt + 1})
                     return result
                 except (pymysql.OperationalError, pymysql.err.MySQLError) as e:
                     last_exception = e
@@ -217,7 +217,7 @@ class MySQLUploader:
                         time.sleep(wait_time)
                         try:
                             self.pool = self._create_connection_pool()
-                            logger.info('成功重新建立数据库连接')
+                            logger.debug('成功重新建立数据库连接')
                         except Exception as reconnect_error:
                             logger.error('重连失败', {'error': str(reconnect_error)})
                     else:
@@ -251,7 +251,7 @@ class MySQLUploader:
             try:
                 self.pool = self._create_connection_pool()
                 conn = self.pool.connection()
-                logger.info('重建连接池后获取连接成功')
+                logger.debug('重建连接池后获取连接成功')
                 return conn
             except Exception as e2:
                 logger.error('重建连接池后依然获取连接失败', {'error': str(e2)})
@@ -296,7 +296,7 @@ class MySQLUploader:
                 with conn.cursor() as cursor:
                     cursor.execute(sql)
                 conn.commit()
-                logger.info('数据库已创建', {'库': db_name})
+                logger.debug('数据库已创建', {'库': db_name})
         except Exception as e:
             logger.error('无法创建数据库', {'库': db_name, '错误': str(e)})
             if conn is not None:
@@ -602,7 +602,7 @@ class MySQLUploader:
                 with conn.cursor() as cursor:
                     cursor.execute(sql)
                 conn.commit()
-                logger.info('数据表及索引已创建', {'库': db_name, '表': table_name, '索引': indexes, '唯一约束': unique_keys})
+                logger.debug('数据表及索引已创建', {'库': db_name, '表': table_name, '索引': indexes, '唯一约束': unique_keys})
         except Exception as e:
             logger.error('建表失败', {'库': db_name, '表': table_name, '错误': str(e), '异常类型': type(e).__name__})
             if conn is not None:
@@ -909,7 +909,7 @@ class MySQLUploader:
                         return
                     cursor.execute(sql_create)
                 conn.commit()
-                logger.info('已为列创建索引', {'库': db_name, '表': table_name, '列': column})
+                logger.debug('已为列创建索引', {'库': db_name, '表': table_name, '列': column})
         except Exception as e:
             logger.error('创建索引失败', {'库': db_name, '表': table_name, '列': column, '错误': str(e)})
             raise
@@ -953,7 +953,7 @@ class MySQLUploader:
                 with conn.cursor() as cursor:
                     cursor.execute(sql)
                 conn.commit()
-            logger.info('添加唯一约束列成功', {'库': db_name, '表': table_name, '列': unique_cols})
+            logger.debug('添加唯一约束列成功', {'库': db_name, '表': table_name, '列': unique_cols})
         except Exception as e:
             logger.warning('唯一约束列添加失败', {'库': db_name, '表': table_name, '列': unique_cols, '错误': str(e)})
 
@@ -1343,7 +1343,7 @@ class MySQLUploader:
             validated_indexes = self._validate_indexes_format(indexes, db_name, table_name)
             validated_unique_keys = self._validate_unique_keys_format(unique_keys, db_name, table_name)
             
-            logger.info("开始上传", {
+            logger.debug("开始上传", {
                 '库': db_name,
                 '表': table_name,
                 '批次': batch_id,
@@ -1548,7 +1548,7 @@ class MySQLUploader:
             batch_id, transaction_mode,
             update_on_duplicate
         )
-        logger.info('插入完成', {
+        logger.debug('插入完成', {
             '库': db_name,
             '表': table_name,
             '总计': len(data),

mdbq/redis/getredis.py

@@ -5,21 +5,21 @@ import numpy as np
 import json
 import datetime
 import threading
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 from decimal import Decimal
 import orjson
 
-logger = mylogger.MyLogger(
-    logging_mode='file',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,  # 是否启用异步日志
-    sample_rate=1,  # 采样DEBUG/INFO日志
-    sensitive_fields=[],  #  敏感字段过滤
-    enable_metrics=False,  # 是否启用性能指标
-)
+# logger = mylogger.MyLogger(
+#     logging_mode='file',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,  # 是否启用异步日志
+#     sample_rate=1,  # 采样DEBUG/INFO日志
+#     sensitive_fields=[],  #  敏感字段过滤
+#     enable_metrics=False,  # 是否启用性能指标
+# )
 
 
 class RedisData(object):
@@ -61,7 +61,8 @@ class RedisData(object):
 
         combined_df = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
         if combined_df.empty:
-            logger.info(f"警告: {db_name}.{table_name} 未读取到数据")
+            # logger.info(f"警告: {db_name}.{table_name} 未读取到数据")
+            pass
         else:
             combined_df = self._convert_date_columns(combined_df)
         return combined_df
@@ -86,7 +87,7 @@ class RedisData(object):
             ttl = self.redis_engine.ttl(cache_key)
             cache_data = self._fetch_redis_data(cache_key)
         except Exception as e:
-            logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
+            # logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
 
         # 缓存失效处理逻辑
@@ -134,11 +135,11 @@ class RedisData(object):
             self.redis_engine.set(cache_key, serialized_data)
             self.redis_engine.expire(cache_key, self.cache_ttl)
 
-            logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
+            # logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
             return combined_data
 
         except Exception as e:
-            logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            # logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
             return pd.DataFrame()
 
     # Helper Methods ------------------------------------------------
@@ -160,7 +161,7 @@ class RedisData(object):
                 projection={}
             )
         except Exception as e:
-            logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
+            # logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
             return pd.DataFrame()
 
     def _fetch_redis_data(self, cache_key: str) -> pd.DataFrame:
@@ -173,7 +174,7 @@ class RedisData(object):
             df = pd.DataFrame(json.loads(data.decode("utf-8")))
             return self._convert_date_columns(df)
         except Exception as e:
-            logger.error(f"Redis 数据解析失败 {cache_key}: {e}")
+            # logger.error(f"Redis 数据解析失败 {cache_key}: {e}")
             return pd.DataFrame()
 
     def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -278,7 +279,8 @@ class RedisDataHash(object):
 
         combined_df = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
         if combined_df.empty:
-            logger.warn(f"warning: {db_name}.{table_name} 未读取到数据")
+            # logger.warn(f"warning: {db_name}.{table_name} 未读取到数据")
+            pass
         else:
             combined_df = self._convert_date_columns(combined_df)
         return combined_df
@@ -293,7 +295,7 @@ class RedisDataHash(object):
             projection={}
     ) -> pd.DataFrame:
         if not self.redis_engine.ping():
-            logger.error(f"Redis ping异常，直接访问 MySQL")
+            # logger.error(f"Redis ping异常，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
         start_dt = pd.to_datetime(start_date).floor('D')
         end_dt = pd.to_datetime(end_date).floor('D')
@@ -335,7 +337,7 @@ class RedisDataHash(object):
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
         except Exception as e:
-            logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
+            # logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
             return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
     def set_redis(
@@ -385,9 +387,10 @@ class RedisDataHash(object):
                         serialized_data = self._serialize_data(group)
                         self.redis_engine.hset(cache_key, month_str, serialized_data)
                     self.redis_engine.expire(cache_key, self.cache_ttl + random.randint(0, 1800))
-                logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
+                # logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
         except Exception as e:
-            logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            # logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+            pass
 
     def _fetch_table_data(
             self,
@@ -406,7 +409,7 @@ class RedisDataHash(object):
                 projection=projection
             )
         except Exception as e:
-            logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
+            # logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
             return pd.DataFrame()
 
     def _fetch_redis_data(self, cache_key: str, months: list = None) -> pd.DataFrame:
@@ -441,7 +444,8 @@ class RedisDataHash(object):
                             df = self._convert_date_columns(df)
                             dfs.append(df)
                         except Exception as e:
-                            logger.error(f"月份数据解析失败 {field}: {e}")
+                            # logger.error(f"月份数据解析失败 {field}: {e}")
+                            pass
 
             # 处理分片数据（优化后的批处理逻辑）
             cursor, shard_data = results[result_index]
@@ -459,7 +463,8 @@ class RedisDataHash(object):
                             df = pd.DataFrame(orjson.loads(value))
                             dfs.append(self._convert_date_columns(df))
                         except Exception as e:
-                            logger.error(f"分片数据解析失败: {e}")
+                            # logger.error(f"分片数据解析失败: {e}")
+                            pass
 
                 # 继续获取后续分片
                 if cursor == 0:
@@ -475,7 +480,7 @@ class RedisDataHash(object):
             return pd.DataFrame()
 
         except Exception as e:
-            logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
+            # logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
             return pd.DataFrame()
 
     def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -562,7 +567,7 @@ class RedisDataHash(object):
         try:
             records = temp_df.to_dict(orient='records')
         except Exception as e:
-            logger.error(f"DataFrame转字典失败: {str(e)}")
+            # logger.error(f"DataFrame转字典失败: {str(e)}")
             records = []
 
         # 序列化配置 --------------------------------------------------------