mdbq 3.6.8__py3-none-any.whl → 3.6.9__py3-none-any.whl

mdbq/mysql/s_query.py

@@ -12,6 +12,7 @@ from sqlalchemy import create_engine
 import os
 import calendar
 from mdbq.dataframe import converter
+from decimal import Decimal
 
 warnings.filterwarnings('ignore')
 """
@@ -49,9 +50,14 @@ class QueryDatas:
             return columns
 
     def data_to_df(self, db_name, table_name, start_date, end_date, projection: dict=[]):
-
-        start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
-        end_date = pd.to_datetime(end_date).strftime('%Y-%m-%d')
+        if start_date:
+            start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
+        else:
+            start_date = '1970-01-01'
+        if end_date:
+            end_date = pd.to_datetime(end_date).strftime('%Y-%m-%d')
+        else:
+            end_date = datetime.datetime.today().strftime('%Y-%m-%d')
         df = pd.DataFrame()  # 初始化df
 
         if self.check_infos(db_name, table_name) == False:
@@ -97,6 +103,9 @@ class QueryDatas:
             rows = cursor.fetchall()  # 获取查询结果
             columns = [desc[0] for desc in cursor.description]
             df = pd.DataFrame(rows, columns=columns)  # 转为 df
+            # 使用applymap将每个Decimal转换为float
+            df_float = df.applymap(lambda x: float(x) if isinstance(x, Decimal) else x)
+
             if 'id' in df.columns.tolist():
                 df.pop('id')  # 默认不返回 id 列
             if len(df) == 0:

mdbq/redis/getredis.py

@@ -12,6 +12,7 @@ import logging
 from logging.handlers import RotatingFileHandler
 import getpass
 import platform
+from decimal import Decimal
 
 if platform.system() == 'Windows':
     D_PATH = os.path.join(f'C:\\Users\\{getpass.getuser()}\\Downloads')
@@ -57,6 +58,9 @@ logger.addHandler(file_handler)
 
 
 class RedisData(object):
+    """
+    存储 string
+    """
     def __init__(self, redis_engine, download, cache_ttl: int):
         self.redis_engine = redis_engine  # Redis 数据处理引擎
         self.download = download  # MySQL 数据处理引擎
@@ -268,6 +272,409 @@ class RedisData(object):
         return temp_df.to_json(orient="records", force_ascii=False)
 
 
+class RedisDataHash(object):
+    """
+    存储 hash
+    Redis缓存与MySQL数据联合查询处理器
+
+    功能特性：
+    - 支持带年份分表的MySQL数据查询
+    - 多级缓存策略（内存缓存+Redis缓存）
+    - 异步缓存更新机制
+    - 自动处理日期范围和数据类型转换
+    """
+
+    def __init__(self, redis_engine, download, cache_ttl: int):
+        """
+        初始化缓存处理器
+
+        :param redis_engine: Redis连接实例
+        :param download: 数据下载处理器（需实现data_to_df方法）
+        :param cache_ttl: 缓存存活时间（单位：分钟，内部转换为秒存储）
+        """
+        self.redis_engine = redis_engine
+        self.download = download
+        self.cache_ttl = cache_ttl * 60  # 转换为秒存储
+
+    def get_from_mysql(
+            self,
+            db_name: str,
+            table_name: str,
+            set_year: bool,
+            start_date,
+            end_date
+    ) -> pd.DataFrame:
+        """
+        从MySQL直接获取数据的核心方法
+
+        处理逻辑：
+        1. 当启用年份分表时(set_year=True)，自动遍历2024到当前年份的所有分表
+        2. 合并所有符合条件的数据表内容
+        3. 自动处理日期列格式转换
+
+        :return: 合并后的DataFrame（可能包含多个分表数据）
+        """
+        # 原有实现保持不变
+        dfs = []
+        if set_year:
+            # 处理年份分表情况（例如 table_2024, table_2025...）
+            current_year = datetime.datetime.today().year
+            for year in range(2024, current_year + 1):
+                df = self._fetch_table_data(
+                    db_name, f"{table_name}_{year}", start_date, end_date
+                )
+                if df is not None:
+                    dfs.append(df)
+        else:
+            # 单表查询模式
+            df = self._fetch_table_data(db_name, table_name, start_date, end_date)
+            if df is not None:
+                dfs.append(df)
+
+        # 合并结果并处理空数据情况
+        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} 未读取到数据")
+        else:
+            combined_df = self._convert_date_columns(combined_df)
+        return combined_df
+
+    def get_from_redis(
+            self,
+            db_name: str,
+            table_name: str,
+            set_year: bool,
+            start_date,
+            end_date
+    ) -> pd.DataFrame:
+        """
+        带缓存策略的数据获取主入口
+
+        执行流程：
+        1. 生成缓存键并检查TTL（存活时间）
+        2. 当TTL<60秒时触发异步更新，同时直接访问MySQL获取最新数据
+        3. 从Redis获取历史数据并进行日期过滤
+        4. 若缓存数据不完整，触发异步更新并降级到MySQL查询
+        5. 异常时自动降级到MySQL查询
+
+        设计特点：
+        - 缓存预热：首次访问时异步更新缓存
+        - 降级机制：任何异常自动切换直连MySQL
+        - 过时缓存：当TTL不足时并行更新缓存
+        """
+        # 时分秒部分重置为 00:00:00 这是个巨坑，不可以省略
+        start_dt = pd.to_datetime(start_date).floor('D')
+        end_dt = pd.to_datetime(end_date).floor('D')
+        # 生成缓存键名
+        cache_key = self._generate_cache_key(db_name, table_name, set_year)
+
+        try:
+            # 检查缓存
+            ttl = self.redis_engine.ttl(cache_key)
+            if ttl < 60:  # 当剩余时间不足1分钟时触发更新
+                # 获取当前缓存
+                cache_data = self._fetch_redis_data(cache_key)
+                # 异步更新缓存
+                self._trigger_async_cache_update(
+                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+                )
+                # 立即降级返回MySQL查询
+                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+
+            # 按年份范围获取缓存数据（优化大数据量时的读取效率）
+            start_year = start_dt.year
+            end_year = end_dt.year
+            cache_data = self._fetch_redis_data(cache_key, start_year, end_year)
+            # 空数据检查（缓存未命中）
+            if cache_data.empty:
+                self._trigger_async_cache_update(
+                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+                )
+                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+            # 按请求范围过滤数据（应对按年存储的粗粒度缓存）
+            filtered_df = self._filter_by_date_range(cache_data, start_dt, end_dt)
+            if not filtered_df.empty:
+                if '日期' in filtered_df.columns.tolist():
+                    # 缓存数据的日期在请求日期范围内时，直接返回缓存数据
+                    exsit_min_date = filtered_df['日期'].min()
+                    if exsit_min_date <= start_dt:
+                        return filtered_df
+                else:
+                    return filtered_df
+            # 缓存数据不完整时触发异步更新缓存
+            self._trigger_async_cache_update(
+                cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+            )
+            # 立即降级返回MySQL查询
+            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+
+        except Exception as e:
+            # 异常策略：立即返回MySQL查询，保障服务可用
+            logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
+            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+
+    def set_redis(
+            self,
+            cache_key: str,
+            db_name: str,
+            table_name: str,
+            set_year: bool,
+            start_date,
+            end_date,
+            existing_data: pd.DataFrame
+    ) -> None:
+        """
+        异步缓存更新方法
+
+        核心逻辑：
+        1. 获取MySQL最新数据
+        2. 合并新旧数据（保留历史数据中不在新数据时间范围内的部分）
+        3. 智能存储策略：
+           - 无日期字段：全量存储到"all"字段
+           - 有日期字段：按年份分片存储（提升查询效率）
+
+        设计特点：
+        - 增量更新：仅合并必要数据，避免全量覆盖
+        - 数据分片：按年存储提升大数据的读取性能
+        - 容错处理：跳过无日期字段的异常情况
+        """
+        try:
+            # 获取最新数据（使用最新查询条件）
+            new_data = self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+            if new_data.empty:
+                return
+
+            # 合并缓存数据
+            combined_data = self._merge_data(new_data, existing_data)
+
+            if not combined_data.empty:
+                # 处理无日期字段的特殊情况
+                if '日期' not in combined_data.columns.tolist():
+                    # 数据序列化
+                    serialized_data = self._serialize_data(combined_data)
+                    self.redis_engine.hset(cache_key, "all", serialized_data)
+                    self.redis_engine.expire(cache_key, self.cache_ttl)
+                else:
+                    # 按年份分片存储策略
+                    combined_data['年份'] = combined_data['日期'].dt.year
+                    # 分组存储到Redis哈希的不同字段（例如2024字段存储当年数据）
+                    for year, group in combined_data.groupby('年份'):
+                        year_str = str(year)
+                        serialized_data = self._serialize_data(group.drop(columns=['年份']))
+                        self.redis_engine.hset(cache_key, year_str, serialized_data)
+                    self.redis_engine.expire(cache_key, self.cache_ttl)
+                logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
+        except Exception as e:
+            logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
+
+    def _fetch_table_data(
+            self,
+            db_name: str,
+            table_name: str,
+            start_date,
+            end_date
+    ) -> pd.DataFrame:
+        """执行MySQL查询并返回DataFrame（带异常处理）"""
+        try:
+            return self.download.data_to_df(
+                db_name=db_name,
+                table_name=table_name,
+                start_date=start_date,
+                end_date=end_date,
+                projection={}
+            )
+        except Exception as e:
+            logger.info(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
+            return pd.DataFrame()
+
+    def _fetch_redis_data(self, cache_key: str, start_year: int = None, end_year: int = None) -> pd.DataFrame:
+        """
+        从Redis哈希表读取数据
+
+        优化策略：
+        - 当指定年份范围时，仅获取相关字段（hmget）
+        - 未指定范围时全量获取（hgetall）
+        --  从mysql过来的表，虽然没有日期列，但也指定了 start_year/end_year，再redis中存储的键名是"all"，所以要把 all也加进去
+        """
+        try:
+            if start_year is not None and end_year is not None:
+                # 按年份范围精确获取字段（提升性能）
+                fields = [str(y) for y in range(start_year, end_year + 1)]
+                fields += ['all']
+                data_list = self.redis_engine.hmget(cache_key, fields)
+                dfs = []
+                for data, field in zip(data_list, fields):
+                    if data:
+                        df = pd.DataFrame(json.loads(data.decode("utf-8")))
+                        df = self._convert_date_columns(df)
+                        dfs.append(df)
+                return pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
+            else:
+                # 全量获取模式
+                data_dict = self.redis_engine.hgetall(cache_key)
+                dfs = []
+                for field, data in data_dict.items():
+                    try:
+                        df = pd.DataFrame(json.loads(data.decode("utf-8")))
+                        df = self._convert_date_columns(df)
+                        dfs.append(df)
+                    except Exception as e:
+                        logger.info(f"Redis 数据解析失败 {cache_key} 字段 {field}: {e}")
+                return pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
+        except Exception as e:
+            logger.info(f"Redis 数据获取失败 {cache_key}: {e}")
+            return pd.DataFrame()
+
+    def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
+        """统一日期列格式转换"""
+        if "日期" in df.columns:
+            df["日期"] = pd.to_datetime(df["日期"], format="%Y-%m-%d", errors="coerce")
+        return df
+
+    def _generate_cache_key(self, db_name: str, table_name: str, set_year: bool) -> str:
+        """生成缓存键名"""
+        return f"{db_name}:{table_name}_haveyear" if set_year else f"{db_name}:{table_name}"
+
+    def _filter_by_date_range(
+            self,
+            df: pd.DataFrame,
+            start_dt: datetime.datetime,
+            end_dt: datetime.datetime
+    ) -> pd.DataFrame:
+        """按日期范围精确过滤数据"""
+        if "日期" not in df.columns:
+            return df
+        date_mask = (df["日期"] >= start_dt) & (df["日期"] <= end_dt)
+        return df[date_mask].copy()
+
+    def _trigger_async_cache_update(
+            self,
+            cache_key: str,
+            db_name: str,
+            table_name: str,
+            set_year: bool,
+            start_date: str,
+            end_date: str,
+            existing_data: pd.DataFrame
+    ):
+        """启动异步线程执行缓存更新（不阻塞主流程）"""
+        thread = threading.Thread(
+            target=self.set_redis,
+            args=(cache_key, db_name, table_name, set_year, start_date, end_date, existing_data),
+            daemon=True
+        )
+        thread.start()
+
+    def _merge_data(self, new_data: pd.DataFrame, existing_data: pd.DataFrame) -> pd.DataFrame:
+        """合并新旧数据集策略：保留现有数据中在新数据范围外的历史数据，并按日期排序"""
+        if existing_data.empty or "日期" not in existing_data.columns:
+            return new_data
+        new_data["日期"] = pd.to_datetime(new_data["日期"])
+        existing_data["日期"] = pd.to_datetime(existing_data["日期"])
+
+        # 计算新数据日期范围
+        new_min = new_data["日期"].min()
+        new_max = new_data["日期"].max()
+
+        # 保留现有数据中在新数据范围之外的部分
+        valid_historical = existing_data[
+            (existing_data["日期"] < new_min) | (existing_data["日期"] > new_max)
+            ]
+        merged_data = pd.concat([new_data, valid_historical], ignore_index=True)
+        merged_data.sort_values(['日期'], ascending=[False], ignore_index=True, inplace=True)
+        return merged_data
+
+    def _serialize_data(self, df: pd.DataFrame) -> bytes:
+        """
+        高性能数据序列化方法
+
+        处理要点：
+        1. 日期类型转换为字符串
+        2. Decimal类型转换为浮点数
+        3. NaN值统一转换为None
+        4. 优化JSON序列化性能
+        """
+        if df.empty:
+            return json.dumps([], ensure_ascii=False).encode("utf-8")
+        temp_df = df.copy()
+
+        # 处理日期类型列（安全转换）
+        date_cols = temp_df.select_dtypes(include=["datetime64[ns]"]).columns
+        for col in date_cols:
+            # 处理全NaT列避免类型错误
+            if temp_df[col].isna().all():
+                temp_df[col] = temp_df[col].astype(object)  # 转换为object类型避免NaT
+            temp_df[col] = (
+                temp_df[col]
+                .dt.strftime("%Y-%m-%d")  # 安全使用dt访问器（因类型强制为datetime）
+                .where(temp_df[col].notna(), None)
+            )
+
+        # 统一空值处理（保护全None列类型）
+        def safe_null_convert(series):
+            """保留全None列的原始dtype"""
+            if series.isna().all():
+                return series.astype(object).where(pd.notnull(series), None)
+            return series.where(pd.notnull(series), None)
+
+        temp_df = temp_df.apply(safe_null_convert)
+
+        # 类型处理函数（增强嵌套结构处理）
+        def decimal_serializer(obj):
+            """递归序列化处理"""
+            # 提前处理None值
+            if obj is None:
+                return None
+
+            # 按类型分发处理
+            if isinstance(obj, Decimal):
+                return round(float(obj), 6)
+            elif isinstance(obj, pd.Timestamp):
+                return obj.strftime("%Y-%m-%d %H:%M:%S")  # 兜底处理漏网之鱼
+            elif isinstance(obj, np.generic):  # 处理所有numpy标量类型
+                return obj.item()
+            elif isinstance(obj, (datetime.date, datetime.datetime)):
+                return obj.isoformat()
+            elif isinstance(obj, (list, tuple, set)):
+                return [decimal_serializer(item) for item in obj]
+            elif isinstance(obj, dict):
+                return {decimal_serializer(k): decimal_serializer(v) for k, v in obj.items()}
+            elif isinstance(obj, bytes):
+                return obj.decode("utf-8", errors="replace")  # 二进制安全处理
+            elif isinstance(obj, pd.Series):  # 防止意外传入Series对象
+                return obj.to_list()
+            else:
+                # 尝试直接转换可序列化类型
+                try:
+                    json.dumps(obj)
+                    return obj
+                except TypeError:
+                    logger.error(f"无法序列化类型 {type(obj)}: {str(obj)}")
+                    raise
+
+        # 序列化前防御性检查
+        try:
+            data_records = temp_df.to_dict(orient="records")
+        except Exception as e:
+            logger.error(f"数据转换字典失败: {str(e)}")
+            raise
+
+        # 空记录特殊处理
+        if not data_records:
+            return json.dumps([], ensure_ascii=False).encode("utf-8")
+
+        # 执行序列化
+        try:
+            return json.dumps(
+                data_records,
+                ensure_ascii=False,
+                default=decimal_serializer
+            ).encode("utf-8")
+        except TypeError as e:
+            logger.error(f"序列化失败，请检查未处理的数据类型: {str(e)}")
+            raise
+
+
 if __name__ == '__main__':
     # # ****************************************************
     # # 这一部分在外部定义，只需要定义一次，开始

{mdbq-3.6.8.dist-info → mdbq-3.6.9.dist-info}/METADATA

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

{mdbq-3.6.8.dist-info → mdbq-3.6.9.dist-info}/RECORD

@@ -19,8 +19,9 @@ mdbq/mongo/__init__.py,sha256=SILt7xMtQIQl_m-ik9WLtJSXIVf424iYgCfE_tnQFbw,13
 mdbq/mongo/mongo.py,sha256=M9DUeUCMPDngkwn9-ui0uTiFrvfNU1kLs22s5SmoNm0,31899
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
 mdbq/mysql/mysql.py,sha256=_jFo2_OC1BNm5wEmoYiBG_TcuNNA2xUWKNhMBfgDiAM,99699
+mdbq/mysql/mysql_bak.py,sha256=_jFo2_OC1BNm5wEmoYiBG_TcuNNA2xUWKNhMBfgDiAM,99699
 mdbq/mysql/recheck_mysql.py,sha256=ppBTfBLgkRWirMVZ31e_ZPULiGPJU7K3PP9G6QBZ3QI,8605
-mdbq/mysql/s_query.py,sha256=Z0C3lQQcGtnizyVHa62HYIAqZ8R3KeSHP-N0O7Qb5eU,9280
+mdbq/mysql/s_query.py,sha256=M186PgZR_slDdSi_m1vGw2fhZQVEfCuFRBSJlz8yL3A,9643
 mdbq/mysql/year_month_day.py,sha256=VgewoE2pJxK7ErjfviL_SMTN77ki8GVbTUcao3vFUCE,1523
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/other/download_sku_picture.py,sha256=GdphR7Q3psXXVuZoyJ4u_6OWn_rWlcbT0iJ-1zPT6O0,45368
@@ -33,12 +34,10 @@ mdbq/pbix/pbix_refresh.py,sha256=JUjKW3bNEyoMVfVfo77UhguvS5AWkixvVhDbw4_MHco,239
 mdbq/pbix/refresh_all.py,sha256=OBT9EewSZ0aRS9vL_FflVn74d4l2G00wzHiikCC4TC0,5926
 mdbq/pbix/refresh_all_old.py,sha256=_pq3WSQ728GPtEG5pfsZI2uTJhU8D6ra-htIk1JXYzw,7192
 mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
-mdbq/redis/getredis.py,sha256=faqRBX-xV2C665Q-C9lh0XmPvruXv1jeNPpQJaT3y38,11726
-mdbq/redis/getredis_bak20250131.py,sha256=DQazRyKVnaDziP9JEIofAJF8dw_PKyLEgwEznlTnGDw,12284
-mdbq/redis/getredis_deepseek.py,sha256=bQ6VfiTYkQ5cYK6MYJPKgwbdrwsOLBLrV-ObblKaurA,9653
+mdbq/redis/getredis.py,sha256=q7omKJCPw_6Zr_r6WwTv4RGSXzZzpLPkIaqJ22svJhE,29104
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=v7VO5gtEXR6_4Q6ujbTyu1FHu7TXHcwSQ6hIO249YH0,22208
-mdbq-3.6.8.dist-info/METADATA,sha256=6J05ZtnIu9ttqbPXHaFt_Q9RZTmbH3IG7huPeu1V6SU,243
-mdbq-3.6.8.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-mdbq-3.6.8.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.6.8.dist-info/RECORD,,
+mdbq-3.6.9.dist-info/METADATA,sha256=m6rX1e31X7uhBfVC0ZE07nWd5EY4QVO6RZC93uAdr68,243
+mdbq-3.6.9.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+mdbq-3.6.9.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.6.9.dist-info/RECORD,,