mdbq 4.0.2__py3-none-any.whl → 4.0.4__py3-none-any.whl

mdbq/aggregation/query_data.py

@@ -1,6 +1,7 @@
 # -*- coding: UTF-8 –*-
 import re
-from mdbq.mysql import mysql
+# from mdbq.mysql import mysql
+from mdbq.mysql import uploader
 from mdbq.mysql import s_query
 from mdbq.config import config
 from mdbq.log import mylogger
@@ -13,17 +14,15 @@ import platform
 import os
 import time
 import calendar
-import concurrent.futures
-
-"""
-
-"""
+from collections.abc import Mapping, Sequence
+import inspect
 
 dir_path = os.path.expanduser("~")
 config_file = os.path.join(dir_path, 'spd.txt')
 content = config.read_config(file_path=config_file)
 username, password, host, port = content['username'], content['password'], content['host'], content['port']
-m_engine = mysql.MysqlUpload(username=username, password=password, host=host, port=port, charset='utf8mb4')
+host = 'localhost'
+uld = uploader.MySQLUploader(username=username, password=password, host=host, port=int(port), pool_size=10)
 
 logger = mylogger.MyLogger(
     logging_mode='file',
@@ -38,15 +37,170 @@ logger = mylogger.MyLogger(
 )
 
 
+def reorder_columns(df: pd.DataFrame, set_type) -> pd.DataFrame:
+    """
+    调整DataFrame的列顺序，按照set_type中的顺序排列，忽略大小写，set_type中不存在的列自动跳过。
+    set_type可以是列表或字典（此时用字典的键名作为顺序）。
+    不改变数据和数据类型。
+    如果 set_type 为 None、空列表或空字典，则直接返回原 df，不做任何调整。
+    """
+    # 直接返回原 df 的情况
+    if set_type is None:
+        return df
+    if isinstance(set_type, Mapping) and len(set_type) == 0:
+        return df
+    if isinstance(set_type, Sequence) and not isinstance(set_type, str) and len(set_type) == 0:
+        return df
+
+    # 如果set_type是字典，提取其键名
+    if isinstance(set_type, Mapping):
+        col_order = list(set_type.keys())
+    elif isinstance(set_type, Sequence) and not isinstance(set_type, str):
+        col_order = list(set_type)
+    else:
+        raise ValueError("set_type must be a list or a dict (or other mapping type)")
+
+    # 构建原始列名的映射（小写->原始名）
+    col_map = {col.lower(): col for col in df.columns}
+    # 生成新顺序的列名（只保留df中存在的列，且顺序按set_type）
+    new_cols = []
+    used = set()
+    for col in col_order:
+        key = col.lower()
+        if key in col_map and key not in used:
+            new_cols.append(col_map[key])
+            used.add(key)
+    # 添加剩余未在set_type中出现的列，保持原顺序
+    for col in df.columns:
+        if col.lower() not in used:
+            new_cols.append(col)
+    # 返回新顺序的DataFrame
+    return df[new_cols]
+
+
+def upload_data_decorator(**upload_kwargs):
+    """
+    数据上传装饰器
+    :param upload_kwargs: 上传参数，支持所有 upload_data 方法的参数
+    :return: 装饰器函数
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                # 获取 set_type 或 set_typ 参数
+                set_type = None
+                # 先从kwargs查找
+                for key in ['set_type', 'set_typ']:
+                    if key in kwargs:
+                        set_type = kwargs[key]
+                        break
+                # 如果没在kwargs找到，尝试从args按参数名顺序查找
+                if set_type is None:
+                    sig = inspect.signature(func)
+                    params = list(sig.parameters)
+                    for key in ['set_type', 'set_typ']:
+                        if key in params:
+                            idx = params.index(key)
+                            if len(args) > idx:
+                                set_type = args[idx]
+                                break
+
+                # 执行原始函数
+                result = func(*args, **kwargs)
+                
+                # 如果返回 None，直接返回
+                if result is None:
+                    return None
+                
+                # 如果返回的是 DataFrame
+                if isinstance(result, pd.DataFrame):
+                    # 调整列顺序
+                    if set_type is not None:
+                        result = reorder_columns(result, set_type)
+                    # 设置默认值
+                    default_kwargs = {
+                        'check_duplicate': False,
+                        'update_on_duplicate': True,
+                        'allow_null': False,
+                        'transaction_mode': 'batch'
+                    }
+                    # 更新参数，优先使用装饰器参数
+                    merged_kwargs = {**default_kwargs, **upload_kwargs}
+                    
+                    # 上传数据
+                    uld.upload_data(
+                        data=result,
+                        **merged_kwargs
+                    )
+                    return True
+                
+                # 如果返回的是元组
+                elif isinstance(result, tuple):
+                    # 检查元组长度
+                    if len(result) < 2:
+                        logger.warning('函数返回的元组长度小于2，直接返回原结果，不执行上传', {'函数': func.__name__})
+                        return result
+                        
+                    # 获取前两个元素
+                    df, extra_kwargs = result[0], result[1]
+                    
+                    # 检查第一个元素是否为DataFrame
+                    if not isinstance(df, pd.DataFrame):
+                        logger.warning('函数返回的元组第一个元素不是DataFrame，直接返回原结果，不执行上传', {'函数': func.__name__})
+                        return result
+                        
+                    # 调整列顺序
+                    if set_type is not None:
+                        df = reorder_columns(df, set_type)
+                        # 保持元组结构
+                        result = (df, extra_kwargs) + result[2:]
+                    # 合并装饰器参数和函数参数
+                    merged_kwargs = {**upload_kwargs}
+                    merged_kwargs.update(extra_kwargs)
+                    
+                    # 设置默认值
+                    default_kwargs = {
+                        'check_duplicate': False,
+                        'update_on_duplicate': True,
+                        'allow_null': False,
+                        'transaction_mode': 'batch'
+                    }
+                    # 更新参数，优先使用装饰器参数
+                    for key, value in default_kwargs.items():
+                        if key not in merged_kwargs:
+                            merged_kwargs[key] = value
+                    
+                    # 上传数据
+                    uld.upload_data(
+                        data=df,
+                        **merged_kwargs
+                    )
+                    
+                    # 如果元组长度大于2，返回完整元组
+                    if len(result) > 2:
+                        return result
+                    return True
+                
+                # 其他情况直接返回结果
+                return result
+                
+            except Exception as e:
+                logger.error('数据上传失败', {'函数': func.__name__, '错误': str(e)})
+                return False
+                
+        return wrapper
+    return decorator
+
+
 class MysqlDatasQuery:
     """
     从数据库中下载数据
     """
-    def __init__(self):
+    def __init__(self, download_manager):
         # target_service 从哪个服务器下载数据
         self.months = 0  # 下载几个月数据, 0 表示当月, 1 是上月 1 号至今
-        # 实例化一个下载类
-        self.download = s_query.QueryDatas(username=username, password=password, host=host, port=port)
+        self.download_manager = download_manager
         self.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
         self.pf_datas = []
         self.pf_datas_jd = []  # 京东聚合销售表
@@ -58,7 +212,7 @@ class MysqlDatasQuery:
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                logger.info(f'函数: {func.__name__}, 报错信息: {e}')  # 将异常信息返回
+                logger.info('函数执行错误', {'函数': func.__name__, '错误': str(e)})  # 将异常信息返回
 
         return wrapper
 
@@ -82,7 +236,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'主体报表_{year}',
                 start_date=start_date,
@@ -91,6 +245,7 @@ class MysqlDatasQuery:
             )
             __res.append(df)
         df = pd.concat(__res, ignore_index=True)
+        
         df.rename(columns={
             '场景名字': '营销场景',
             '主体id': '商品id',
@@ -98,6 +253,7 @@ class MysqlDatasQuery:
             '总成交笔数': '成交笔数',
             '总成交金额': '成交金额'
         }, inplace=True)
+
         df = df.astype({
             '商品id': str,
             '花费': 'float64',
@@ -152,12 +308,7 @@ class MysqlDatasQuery:
             '直接成交笔数': 'int',
             '直接成交金额': 'decimal(12,2)',
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['日期', '店铺名称', '商品id', '花费', '成交金额', '直接成交金额']]
-        #     }
-        # )  # 制作其他聚合表
+
         self.pf_datas.append(
             {
                 '集合名称': '天猫汇总表调用',
@@ -166,21 +317,22 @@ class MysqlDatasQuery:
                      '成交笔数', '成交金额', '直接成交笔数', '直接成交金额', '自然流量曝光量']]
             }
         )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        uld.upload_data(
             db_name=db_name,
             table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
+            data=df,
+            set_typ=set_typ,  # 定义列和数据类型
+            primary_keys=[],  # 创建唯一主键
+            check_duplicate=False,  # 检查重复数据
+            duplicate_columns=[],  # 指定排重的组合键
+            update_on_duplicate=True,  # 更新旧数据
+            allow_null=False,  # 允许插入空值
+            partition_by=None,  # 分表方式
+            partition_date_column='日期',  # 用于分表的日期列名，默认为'日期'
+            indexes=[],  # 普通索引列
+            transaction_mode='batch',  # 事务模式
+            unique_keys=[['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '自然流量曝光量']],  # 唯一约束列表
         )
 
         # df_pic：商品排序索引表, 给 powerbi 中的主推款排序用的,(从上月1号到今天的总花费进行排序)
@@ -215,20 +367,26 @@ class MysqlDatasQuery:
             '花费': 'decimal(12,2)',
             '更新时间': 'timestamp',
         }
-        logger.info(f'正在更新: mysql ({host}:{port}) 属性设置3/商品索引表_主推排序调用')
-        m_engine.df_to_mysql(
-            df=df_pic,
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': '属性设置3', '表': '商品索引表_主推排序调用'})
+        uld.upload_data(
             db_name='属性设置3',
             table_name='商品索引表_主推排序调用',
-            icm_update=['商品id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
+            data=df_pic,
+            set_typ=set_typ,  # 定义列和数据类型
+            primary_keys=[],  # 创建唯一主键
+            check_duplicate=False,  # 检查重复数据
+            duplicate_columns=[],  # 指定排重的组合键
+            update_on_duplicate=True,  # 更新旧数据
+            allow_null=False,  # 允许插入空值
+            partition_by=None,  # 分表方式
+            partition_date_column='日期',  # 用于分表的日期列名，默认为'日期'
+            indexes=[],  # 普通索引列
+            transaction_mode='batch',  # 事务模式
+            unique_keys=[['商品id']],  # 唯一约束列表
         )
         return True
 
+    @upload_data_decorator()
     def _tb_wxt(self, db_name='聚合数据', table_name='淘宝_主体报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -248,7 +406,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据_淘宝店',
                 table_name=f'主体报表_{year}',
                 start_date=start_date,
@@ -318,25 +476,24 @@ class MysqlDatasQuery:
             '直接成交笔数': 'int',
             '直接成交金额': 'decimal(12,2)',
         }
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '自然流量曝光量']],  # 唯一约束列表
+        }
 
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
-
+    @upload_data_decorator()
     def _ald_wxt(self, db_name='聚合数据', table_name='奥莱店_主体报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -356,7 +513,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据_奥莱店',
                 table_name=f'主体报表_{year}',
                 start_date=start_date,
@@ -426,25 +583,24 @@ class MysqlDatasQuery:
             '直接成交笔数': 'int',
             '直接成交金额': 'decimal(12,2)',
         }
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '自然流量曝光量']],  # 唯一约束列表
+        }
 
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
-
+    @upload_data_decorator()
     def _sj_wxt(self, db_name='聚合数据', table_name='圣积天猫店_主体报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -464,7 +620,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2025, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据_圣积天猫店',
                 table_name=f'主体报表_{year}',
                 start_date=start_date,
@@ -534,26 +690,25 @@ class MysqlDatasQuery:
             '直接成交笔数': 'int',
             '直接成交金额': 'decimal(12,2)',
         }
-
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '自然流量曝光量']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def syj(self, db_name='聚合数据', table_name='生意经_宝贝指标'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -573,7 +728,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='生意经3',
                 table_name=f'宝贝指标_{year}',
                 start_date=start_date,
@@ -623,31 +778,25 @@ class MysqlDatasQuery:
             '件均价': 'mediumint',
             '价格带': 'varchar(100)',
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['日期', '店铺名称', '宝贝id', '销售额', '销售量', '退款额_发货后', '退货量_发货后']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '宝贝id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '宝贝id']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def tg_rqbb(self, db_name='聚合数据', table_name='天猫_人群报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -667,7 +816,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'人群报表_{year}',
                 start_date=start_date,
@@ -722,7 +871,7 @@ class MysqlDatasQuery:
         df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
 
         # 开始处理用户特征
-        df_sx = self.download.data_to_df(
+        df_sx = self.download_manager.data_to_df(
             db_name='达摩盘3',
             table_name=f'我的人群属性',
             start_date=start_date,
@@ -847,23 +996,25 @@ class MysqlDatasQuery:
             '用户年龄': 'varchar(100)',
             '人群分类': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费', '人群名字'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '人群名字']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def tg_gjc(self, db_name='聚合数据', table_name='天猫_关键词报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -884,7 +1035,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'关键词报表_{year}',
                 start_date=start_date,
@@ -980,21 +1131,22 @@ class MysqlDatasQuery:
             '是否品牌词': 'varchar(100)',
             '词分类': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费', '词类型', '词名字_词包名字',],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '商品id', '词类型', '词名字_词包名字']],  # 唯一约束列表
+        }
 
     def tg_cjzb_qzt(self, projection=None, is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
@@ -1012,7 +1164,7 @@ class MysqlDatasQuery:
             }
         __res = []
         for year in range(2025, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'超级直播_全站推广报表_{year}',
                 start_date=start_date,
@@ -1027,6 +1179,7 @@ class MysqlDatasQuery:
 
 
     @try_except
+    @upload_data_decorator()
     def tg_cjzb(self, db_name='聚合数据', table_name='天猫_超级直播', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -1048,7 +1201,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'超级直播报表_人群_{year}',
                 start_date=start_date,
@@ -1129,8 +1282,6 @@ class MysqlDatasQuery:
                 '数据主体': df[['日期', '店铺名称', '推广渠道', '营销场景', '花费', '展现量', '观看次数', '加购量', '成交笔数', '成交金额', '直接成交笔数', '直接成交金额']]
             },
         )  # 制作其他聚合表
-        if not self.update_service:
-            return
         set_typ = {
             '日期': 'date',
             '推广渠道': 'varchar(100)',
@@ -1149,22 +1300,23 @@ class MysqlDatasQuery:
             '直接成交笔数': 'int',
             '直接成交金额': 'decimal(12,2)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '推广渠道', '营销场景', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '人群名字', '计划名字']],  # 唯一约束列表
+        }
 
     @try_except
     def pxb_zh(self, db_name='聚合数据', table_name='天猫_品销宝账户报表', is_maximize=True):
@@ -1186,7 +1338,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'品销宝_{year}',
                 start_date=start_date,
@@ -1243,8 +1395,6 @@ class MysqlDatasQuery:
                 '数据主体': df[['日期', '店铺名称', '推广渠道', '营销场景', '花费', '展现量', '点击量', '加购量', '成交笔数', '成交金额']]
             },
         )  # 制作其他聚合表
-        if not self.update_service:
-            return
         set_typ = {
             '日期': 'date',
             '推广渠道': 'varchar(100)',
@@ -1260,29 +1410,31 @@ class MysqlDatasQuery:
             '品牌搜索量': 'int',
             '品牌搜索人数': 'int',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '报表类型', '推广渠道', '营销场景', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '推广渠道', '店铺名称', '营销场景', '报表类型']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def idbm_bak(self, db_name='聚合数据', table_name='商品id编码表'):
         """ 用生意经日数据制作商品 id 和编码对照表 """
         year = datetime.datetime.today().year
         data_values = []
         for year in range(2022, year+1):
-            data_values += self.download.columns_to_list(
+            data_values += self.download_manager.columns_to_list(
                 db_name='生意经3',
                 table_name=f'宝贝指标_{year}',
                 columns_name=['宝贝id', '商家编码', '行业类目'],
@@ -1308,27 +1460,22 @@ class MysqlDatasQuery:
             '二级类目': 'varchar(100)',
             '三级类目': 'varchar(100)',
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['宝贝id', '商家编码']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=['宝贝id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['宝贝id']],  # 唯一约束列表
+        }
 
     @try_except
     def idbm(self, db_name='聚合数据', table_name='商品id编码表'):
@@ -1342,7 +1489,7 @@ class MysqlDatasQuery:
             '三级类目': 1,
             '更新时间': 1
         }
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='属性设置3',
             table_name='商品sku属性',
             start_date='2024-11-17',
@@ -1362,83 +1509,25 @@ class MysqlDatasQuery:
             '三级类目': 'varchar(100)',
             '更新时间': 'timestamp'
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['宝贝id', '商家编码']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=['宝贝id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
-
-    @try_except
-    def sp_picture_bak(self, db_name='聚合数据', table_name='商品id图片对照表'):
-        """ 用生意经日数据制作商品 id 和编码对照表 """
-        data_values = self.download.columns_to_list(
-            db_name='属性设置3',
-            table_name='商品素材中心',
-            columns_name=['日期', '商品id', '商品白底图', '方版场景图'],
-        )
-        df = pd.DataFrame(data=data_values)
-        df['商品id'] = df['商品id'].astype('int64')
-        df['日期'] = df['日期'].astype('datetime64[ns]')
-        df = df[(df['商品白底图'] != '0') | (df['方版场景图'] != '0')]
-        # 白底图优先
-        df['商品图片'] = df[['商品白底图', '方版场景图']].apply(
-            lambda x: x['商品白底图'] if x['商品白底图'] != '0' else x['方版场景图'], axis=1)
-        # # 方版场景图优先
-        # df['商品图片'] = df[['商品白底图', '方版场景图']].apply(
-        #     lambda x: x['方版场景图'] if x['方版场景图'] != '0' else x['商品白底图'], axis=1)
-        df.sort_values(by=['商品id', '日期'], ascending=[False, True], ignore_index=True, inplace=True)
-        df.drop_duplicates(subset=['商品id'], keep='last', inplace=True, ignore_index=True)
-        df = df[['商品id', '商品图片', '日期']]
-        df['商品图片'] = df['商品图片'].apply(lambda x: x if 'http' in x else None)  # 检查是否是 http 链接
-        df.dropna(how='all', subset=['商品图片'], axis=0, inplace=True)  # 删除指定列含有空值的行
-        df['商品链接'] = df['商品id'].apply(
-            lambda x: f'https://detail.tmall.com/item.htm?id={str(x)}' if x and '.com' not in str(x) else x)
-        df.sort_values(by='商品id', ascending=False, ignore_index=True, inplace=True)  # ascending=False 降序排列
-        set_typ = {
-            '商品id': 'bigint',
-            '商品图片': 'varchar(255)',
-            '日期': 'date',
-            '商品链接': 'varchar(255)',
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['宝贝id']],  # 唯一约束列表
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['商品id', '商品图片']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=['商品id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
 
     @try_except
+    @upload_data_decorator()
     def sp_picture(self, db_name='聚合数据', table_name='商品id图片对照表'):
         """  """
         projection = {
@@ -1450,7 +1539,7 @@ class MysqlDatasQuery:
             'sku地址': 1,
             '更新时间': 1
         }
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='属性设置3',
             table_name='商品sku属性',
             start_date='2024-11-17',
@@ -1471,40 +1560,35 @@ class MysqlDatasQuery:
             'sku地址': 'varchar(255)',
             '更新时间': 'timestamp'
         }
-        # # 制作其他聚合表
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['商品id', '商品图片']]
-        #     }
-        # )
-        if not self.update_service:  # 调试加，是否继续执行下面的入库操作
-            return
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=['sku_id'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['sku_id']],  # 唯一约束列表
+        }
 
+    @upload_data_decorator()
     def item_up(self, db_name='聚合数据', table_name='淘宝店铺货品'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {}
-        df_set = self.download.data_to_df(
+        df_set = self.download_manager.data_to_df(
             db_name='属性设置3',
             table_name=f'货品年份基准',
             start_date=start_date,
             end_date=end_date,
             projection={'商品id':1, '上市年份':1},
         )
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='市场数据3',
             table_name=f'淘宝店铺数据',
             start_date=start_date,
@@ -1526,7 +1610,7 @@ class MysqlDatasQuery:
         df['上市年份'] = df['商品id'].apply(lambda x: check_year(x))
         p = df.pop('上市年份')
         df.insert(loc=5, column='上市年份', value=p)
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name}')
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
         set_typ = {
             '日期': 'date',
             '店铺id': 'bigint',
@@ -1542,26 +1626,31 @@ class MysqlDatasQuery:
             '更新时间': 'timestamp',
             '上市年份': 'varchar(50)',
         }
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '一级来源', '二级来源', '三级来源', '访客数'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺id', '商品id']],  # 唯一约束列表
+        }
 
 
+    @upload_data_decorator()
     def spph(self, db_name='聚合数据', table_name='天猫_商品排行'):
         """  """
         start_date, end_date = self.months_data(num=self.months)
         projection = {}
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='生意参谋3',
                 table_name=f'商品排行_{year}',
                 start_date=start_date,
@@ -1572,7 +1661,7 @@ class MysqlDatasQuery:
         df = pd.concat(__res, ignore_index=True)
 
         projection = {}
-        df_set = self.download.data_to_df(
+        df_set = self.download_manager.data_to_df(
             db_name='属性设置3',
             table_name=f'货品年份基准',
             start_date=start_date,
@@ -1663,22 +1752,25 @@ class MysqlDatasQuery:
             '更新时间': 'timestamp',
             '上市年份': 'varchar(100)',
         }
-        min_date = df['日期'].min().strftime("%Y-%m-%d")
-        max_date = df['日期'].max().strftime("%Y-%m-%d")
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '一级来源', '二级来源', '三级来源', '访客数'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '商品id']],  # 唯一约束列表
+        }
 
     # @try_except
+    @upload_data_decorator()
     def dplyd(self, db_name='聚合数据', table_name='店铺流量来源构成'):
         """ 新旧版取的字段是一样的 """
         start_date, end_date = self.months_data(num=self.months)
@@ -1701,7 +1793,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='生意参谋3',
                 table_name=f'店铺流量来源构成_{year}',
                 start_date=start_date,
@@ -1769,27 +1861,28 @@ class MysqlDatasQuery:
             '二级来源索引': 'smallint',
             '三级来源索引': 'smallint',
         }
-        # df.to_csv('/Users/xigua/Downloads/ll.csv', index=False, header=True, encoding='utf-8_sig')
-        min_date = df['日期'].min().strftime("%Y-%m-%d")
-        max_date = df['日期'].max().strftime("%Y-%m-%d")
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '一级来源', '二级来源', '三级来源', '访客数'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '类别', '来源构成', '一级来源', '二级来源', '三级来源']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def sp_cost(self, db_name='聚合数据', table_name='商品成本'):
         """ 电商定价 """
-        data_values = self.download.columns_to_list(
+        data_values = self.download_manager.columns_to_list(
             db_name='属性设置3',
             table_name='电商定价',
             columns_name=['日期', '款号', '年份季节', '吊牌价', '商家平台', '成本价', '天猫页面价', '天猫中促价'],
@@ -1806,31 +1899,25 @@ class MysqlDatasQuery:
             '天猫页面价': 'decimal(10,2)',
             '天猫中促价': 'decimal(10,2)',
         }
-        # self.pf_datas.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['款号', '成本价']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
-        min_date = pd.to_datetime(df['日期'].min()).strftime('%Y-%m-%d')
-        max_date = pd.to_datetime(df['日期'].max()).strftime('%Y-%m-%d')
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=['款号'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=False,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['款号']],  # 唯一约束列表
+        }
 
     # @try_except
+    @upload_data_decorator()
     def jdjzt(self, db_name='聚合数据', table_name='京东_京准通'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -1852,7 +1939,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                     db_name='京东数据3',
                     table_name=f'推广数据_京准通_{year}',
                     start_date=start_date,
@@ -1862,7 +1949,7 @@ class MysqlDatasQuery:
             __res.append(df)
         # 新增加自营店数据 2025-03-19
         for year in range(2025, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                     db_name='京东数据3',
                     table_name=f'推广数据_京准通_自营店_{year}',
                     start_date=start_date,
@@ -1889,7 +1976,7 @@ class MysqlDatasQuery:
             'sku_id': 1,
             'spu_id': 1,
         }
-        df_sku = self.download.data_to_df(
+        df_sku = self.download_manager.data_to_df(
             db_name='属性设置3',
             table_name='京东商品属性',
             start_date=start_date,
@@ -1901,15 +1988,6 @@ class MysqlDatasQuery:
         df.pop('sku_id')  # 删除聚合后合并进来的 sku id，实际使用 跟单sku_id
         p = df.pop('spu_id')
         df.insert(loc=3, column='spu_id', value=p)
-
-        # self.pf_datas_jd.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df[['日期', '产品线', '触发sku_id', '跟单sku_id', '花费']]
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
         set_typ = {
             '日期': 'date',
             '店铺名称': 'varchar(100)',
@@ -1927,23 +2005,25 @@ class MysqlDatasQuery:
             '直接加购数': 'int',
             '总加购数': 'int',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '产品线', '触发sku_id', '跟单sku_id', '花费', ],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def jdqzyx(self, db_name='聚合数据', table_name='京东_京准通_全站营销'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -1959,7 +2039,7 @@ class MysqlDatasQuery:
             '核心位置展现量': 1,
             '核心位置点击量': 1,
         }
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='京东数据3',
             table_name='推广数据_全站营销',  # 暂缺
             start_date=start_date,
@@ -1967,7 +2047,7 @@ class MysqlDatasQuery:
             projection=projection,
         )
         if len(df) == 0:
-            return False
+            return None, None
         df = df.groupby(['日期', '店铺名称', '产品线', '花费'], as_index=False).agg(
             **{
                 '全站投产比': ('全站投产比', np.max),
@@ -1993,23 +2073,25 @@ class MysqlDatasQuery:
             '核心位置展现量': 'int',
             '核心位置点击量': 'int',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '产品线', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '产品线']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def jd_gjc(self, db_name='聚合数据', table_name='京东_关键词报表'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -2036,7 +2118,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                     db_name='京东数据3',
                     table_name=f'推广数据_关键词报表_{year}',
                     start_date=start_date,
@@ -2091,23 +2173,25 @@ class MysqlDatasQuery:
             'k_是否品牌词': 'varchar(100)',
             's_是否品牌词': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '产品线', '搜索词',  '关键词', '展现数', '花费'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '产品线', '计划id', '搜索词', '关键词']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def sku_sales(self, db_name='聚合数据', table_name='京东_sku_商品明细'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -2125,7 +2209,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='京东数据3',
                 table_name=f'京东商智_sku_商品明细_{year}',
                 start_date=start_date,
@@ -2146,14 +2230,6 @@ class MysqlDatasQuery:
         idx = df.groupby(['日期', '店铺名称', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数'])['更新时间'].idxmax()
         df = df.loc[idx]
         df = df[['日期', '店铺名称', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数', '成交单量', '成交金额']]
-        # self.pf_datas_jd.append(
-        #     {
-        #         '集合名称': table_name,
-        #         '数据主体': df
-        #     }
-        # )  # 制作其他聚合表
-        if not self.update_service:
-            return
         set_typ = {
             '日期': 'date',
             '店铺名称': 'varchar(100)',
@@ -2167,23 +2243,25 @@ class MysqlDatasQuery:
             '成交金额': 'decimal(10,2)',
             'sku_id': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '商品id', '成交单量'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '商品id']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def spu_sales(self, db_name='聚合数据', table_name='京东_spu_商品明细'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -2201,7 +2279,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='京东数据3',
                 table_name=f'京东商智_spu_商品明细_{year}',
                 start_date=start_date,
@@ -2235,21 +2313,22 @@ class MysqlDatasQuery:
             '成交金额': 'decimal(10,2)',
             'spu_id': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '商品id', '成交单量'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '商品id']],  # 唯一约束列表
+        }
 
     @staticmethod
     def months_data(num=0, end_date=None):
@@ -2261,6 +2340,7 @@ class MysqlDatasQuery:
         return pd.to_datetime(start_date), pd.to_datetime(end_date)
 
     @try_except
+    @upload_data_decorator()
     def se_search(self, db_name='聚合数据', table_name='天猫店铺来源_手淘搜索'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -2281,7 +2361,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year+1):
-            df = self.download.data_to_df(
+            df = self.download_manager.data_to_df(
                 db_name='生意参谋3',
                 table_name=f'手淘搜索_本店引流词_{year}',
                 start_date=start_date,
@@ -2290,19 +2370,6 @@ class MysqlDatasQuery:
             )
             __res.append(df)
         df = pd.concat(__res, ignore_index=True)
-        # df = df.groupby(
-        #     ['日期', '店铺名称', '词类型', '搜索词'],
-        #     as_index=False).agg(
-        #     **{
-        #         '访客数': ('访客数', np.max),
-        #         '加购人数': ('加购人数', np.max),
-        #         '支付金额': ('支付金额', np.max),
-        #         '支付转化率': ('支付转化率', np.max),
-        #         '支付买家数': ('支付买家数', np.max),
-        #         '客单价': ('客单价', np.max),
-        #         'uv价值': ('uv价值', np.max)
-        #     }
-        # )
         idx = df.groupby(['日期', '店铺名称', '词类型', '搜索词'])['更新时间'].idxmax()
         df = df.loc[idx]
         df = df[['日期', '店铺名称', '词类型', '搜索词', '访客数', '加购人数', '支付金额', '支付转化率', '支付买家数', '客单价', 'uv价值']]
@@ -2320,65 +2387,33 @@ class MysqlDatasQuery:
             '客单价': 'decimal(10,2)',
             'uv价值': 'decimal(10,2)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '店铺名称', '词类型', '搜索词'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '词类型', '搜索词']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def zb_ccfx(self, db_name='聚合数据', table_name='生意参谋_直播场次分析'):
         start_date, end_date = self.months_data(num=self.months)
-        projection = {
-            # '日期': 1,
-            # '店铺': 1,
-            # '场次信息': 1,
-            # '场次id': 1,
-            # '直播开播时间': 1,
-            # '开播时长': 1,
-            # '封面图点击率': 1,
-            # '观看人数': 1,
-            # '观看次数': 1,
-            # '新增粉丝数': 1,
-            # '流量券消耗': 1,
-            # '观看总时长（秒）': 1,
-            # '人均观看时长（秒）': 1,
-            # '次均观看时长（秒）': 1,
-            # '商品点击人数': 1,
-            # '商品点击次数': 1,
-            # '商品点击率': 1,
-            # '加购人数': 1,
-            # '加购件数': 1,
-            # '加购次数': 1,
-            # '成交金额（元）': 1,
-            # '成交人数': 1,
-            # '成交件数': 1,
-            # '成交笔数': 1,
-            # '成交转化率': 1,
-            # '退款人数': 1,
-            # '退款笔数': 1,
-            # '退款件数': 1,
-            # '退款金额': 1,
-            # '预售定金支付金额': 1,
-            # '预售预估总金额': 1,
-            # '店铺名称': 1,
-        }
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='生意参谋3',
             table_name='直播分场次效果',
             start_date=start_date,
             end_date=end_date,
-            projection=projection,
+            projection={},
         )
         df.drop_duplicates(subset=['场次id'], keep='first', inplace=True, ignore_index=True)
         set_typ = {
@@ -2455,9 +2490,7 @@ class MysqlDatasQuery:
             '封面图': 'text',
             '更新时间': 'timestamp',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
         new_dict = {
             '日期': '',
             '店铺名称': '',
@@ -2496,16 +2529,26 @@ class MysqlDatasQuery:
             new_dict.update(dict_data)
             _results.append(new_dict)
         if _results:
-            m_engine.insert_many_dict(
-                db_name=db_name,
-                table_name=table_name,
-                dict_data_list=_results,
-                icm_update=['场次id'],  # 唯一组合键
-                set_typ=set_typ,  # 指定数据类型
-            )
-        return True
+            return _results, {
+                'db_name': db_name,
+                'table_name': table_name,
+                'set_typ': set_typ,
+                'primary_keys': ['场次id'],  # 创建唯一主键
+                'check_duplicate': False,  # 检查重复数据
+                'duplicate_columns': [],  # 指定排重的组合键
+                'update_on_duplicate': True,  # 更新旧数据
+                'allow_null': False,  # 允许插入空值
+                'partition_by': None,  # 分表方式
+                'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+                'indexes': [],  # 普通索引列
+                'transaction_mode': 'batch',  # 事务模式
+                'unique_keys': [['场次id']],  # 唯一约束列表
+            }
+        else:
+            return None, None
 
     # @try_except
+    @upload_data_decorator()
     def tg_by_day(self, db_name='聚合数据', table_name='多店推广场景_按日聚合'):
         """
         汇总各个店铺的推广数据，按日汇总
@@ -2535,7 +2578,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_tm = self.download.data_to_df(
+            df_tm = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'营销场景报表_{year}',
                 start_date=start_date,
@@ -2560,7 +2603,7 @@ class MysqlDatasQuery:
         # 奥莱店
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_al = self.download.data_to_df(
+            df_al = self.download_manager.data_to_df(
                 db_name='推广数据_奥莱店',
                 table_name=f'营销场景报表_{year}',
                 start_date=start_date,
@@ -2586,7 +2629,7 @@ class MysqlDatasQuery:
         # sj圣积
         __res = []
         for year in range(2025, datetime.datetime.today().year + 1):
-            df_sj = self.download.data_to_df(
+            df_sj = self.download_manager.data_to_df(
                 db_name='推广数据_圣积天猫店',
                 table_name=f'营销场景报表_{year}',
                 start_date=start_date,
@@ -2612,7 +2655,7 @@ class MysqlDatasQuery:
         # 淘宝店
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_tb = self.download.data_to_df(
+            df_tb = self.download_manager.data_to_df(
                 db_name='推广数据_淘宝店',
                 table_name=f'营销场景报表_{year}',
                 start_date=start_date,
@@ -2651,7 +2694,7 @@ class MysqlDatasQuery:
             }
             __res = []
             for year in range(2024, datetime.datetime.today().year + 1):
-                df_tb_qzt = self.download.data_to_df(
+                df_tb_qzt = self.download_manager.data_to_df(
                     db_name='推广数据_淘宝店',
                     table_name=f'全站推广报表_{year}',
                     start_date=start_date,
@@ -2701,7 +2744,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_tm_pxb = self.download.data_to_df(
+            df_tm_pxb = self.download_manager.data_to_df(
                 db_name='推广数据2',
                 table_name=f'品销宝_{year}',
                 start_date=start_date,
@@ -2741,7 +2784,7 @@ class MysqlDatasQuery:
             }
             __res = []
             for year in range(2024, datetime.datetime.today().year + 1):
-                df_tm_living = self.download.data_to_df(
+                df_tm_living = self.download_manager.data_to_df(
                     db_name='推广数据2',
                     table_name=f'超级直播报表_人群_{year}',
                     start_date=start_date,
@@ -2783,7 +2826,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_jd = self.download.data_to_df(
+            df_jd = self.download_manager.data_to_df(
                     db_name='京东数据3',
                     table_name=f'推广数据_京准通_{year}',
                     start_date=start_date,
@@ -2821,7 +2864,7 @@ class MysqlDatasQuery:
             '核心位置点击量': 1,
             '店铺名称': 1,
         }
-        df_jd_qzyx = self.download.data_to_df(
+        df_jd_qzyx = self.download_manager.data_to_df(
             db_name='京东数据3',
             table_name='推广数据_全站营销',
             start_date=start_date,
@@ -2862,7 +2905,7 @@ class MysqlDatasQuery:
         }
         __res = []
         for year in range(2025, datetime.datetime.today().year + 1):
-            df_jd_ziying = self.download.data_to_df(
+            df_jd_ziying = self.download_manager.data_to_df(
                 db_name='京东数据3',
                 table_name=f'推广数据_京准通_自营店_{year}',
                 start_date=start_date,
@@ -2952,25 +2995,25 @@ class MysqlDatasQuery:
             '成交笔数': 'int',
             '成交金额': 'decimal(12,2)',
         }
-        if not self.update_service:
-            return
-        min_date = df['日期'].min().strftime('%Y-%m-%d')
-        max_date = df['日期'].max().strftime('%Y-%m-%d')
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '店铺名称', '营销场景', '花费', '展现量', '点击量'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '营销场景']],  # 唯一约束列表
+        }
 
     @try_except
+    @upload_data_decorator()
     def aikucun_bd_spu(self, db_name='聚合数据', table_name='爱库存_商品spu榜单'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -3011,7 +3054,7 @@ class MysqlDatasQuery:
             '更新时间': 1,
         }
         projection = {}
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='爱库存2',
             table_name='spu榜单',
             start_date=start_date,
@@ -3043,26 +3086,28 @@ class MysqlDatasQuery:
             '数据更新时间': 'timestamp',
             '更新时间': 'timestamp',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=[],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '商品款号', 'spuid']],  # 唯一约束列表
+        }
 
+    @upload_data_decorator()
     def deeplink(self, db_name='聚合数据', table_name='达摩盘_deeplink人群洞察'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {}
-        df = self.download.data_to_df(
+        df = self.download_manager.data_to_df(
             db_name='达摩盘3',
             table_name='店铺deeplink人群洞察',
             start_date=start_date,
@@ -3070,8 +3115,6 @@ class MysqlDatasQuery:
             projection=projection,
         )
         df.drop_duplicates(subset=['日期', '人群类型', '店铺名称', '人群规模', '广告投入金额'], keep='last', inplace=True, ignore_index=True)
-        if not self.update_service:
-            return
         set_typ = {
             '日期': 'date',
             '人群类型': 'varchar(100)',
@@ -3092,23 +3135,25 @@ class MysqlDatasQuery:
             '长周期成交价值': 'decimal(13, 2)',
             '达摩盘id': 'int',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            # icm_update=['日期', '人群类型', '店铺名称', '人群规模', '广告投入金额'],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '人群类型', '店铺名称', '人群规模']],  # 唯一约束列表
+        }
 
     # @try_except
+    @upload_data_decorator()
     def dmp_crowd(self, db_name='聚合数据', table_name='达摩盘_人群报表'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -3120,7 +3165,7 @@ class MysqlDatasQuery:
             '用户性别': 1,
         }
         # projection = {}
-        df_crowd = self.download.data_to_df(
+        df_crowd = self.download_manager.data_to_df(
             db_name='达摩盘3',
             table_name='我的人群属性',
             start_date=start_date,
@@ -3135,7 +3180,7 @@ class MysqlDatasQuery:
         projection = {}
         __res = []
         for year in range(2024, datetime.datetime.today().year + 1):
-            df_dmp = self.download.data_to_df(
+            df_dmp = self.download_manager.data_to_df(
                         db_name='达摩盘3',
                         table_name=f'dmp人群报表_{year}',
                         start_date=start_date,
@@ -3201,21 +3246,22 @@ class MysqlDatasQuery:
             '消费能力等级': 'varchar(100)',
             '用户性别': 'varchar(100)',
         }
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=[],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '人群id', '营销渠道', '计划基础信息']],  # 唯一约束列表
+        }
 
     @try_except
     def ret_keyword(self, keyword, as_file=False):
@@ -3513,110 +3559,7 @@ class MysqlDatasQuery:
         return result
 
     # @try_except
-    def performance(self, db_name, table_name, bb_tg=True):
-
-        tg= [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '天猫_主体报表'][0]
-        syj = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '生意经_宝贝指标'][0]
-        idbm = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '商品id编码表'][0]
-        pic = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '商品id图片对照表'][0]
-        cost = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '商品成本'][0]
-
-        # 由于推广表之前根据场景、营销渠道等聚合的，这里不含这些字段所以要进一步聚合
-        tg = tg.groupby(
-            ['日期', '店铺名称', '商品id'],
-            as_index=False).agg(
-            **{
-                '花费': ('花费', np.sum),
-                '成交金额': ('成交金额', np.sum),
-                '直接成交金额': ('直接成交金额', np.sum),
-            }
-        )
-        # 4.  生意经，推广表聚合
-        if bb_tg is True:
-            # 生意经合并推广表，完整的数据表，包含全店所有推广、销售数据
-            df = pd.merge(syj, tg, how='left', left_on=['日期', '店铺名称', '宝贝id'], right_on=['日期', '店铺名称', '商品id'])
-            df.drop(labels='商品id', axis=1, inplace=True)  # 因为生意经中的宝贝 id 列才是完整的
-            df.rename(columns={'宝贝id': '商品id'}, inplace=True)
-        else:
-            # 推广表合并生意经 , 以推广数据为基准，销售数据不齐全
-            df = pd.merge(tg, syj, how='left', left_on=['日期', '店铺名称', '商品id'], right_on=['日期', '店铺名称', '宝贝id'])
-            df.drop(labels='宝贝id', axis=1, inplace=True)
-
-        df['商品id'] = df['商品id'].astype('int64')
-        df = df[df['花费'] > 0]
-        df = df.groupby(
-            ['日期', '店铺名称', '商品id'],
-            as_index=False).agg(
-            **{
-                '花费': ('花费', np.sum),
-                '成交金额': ('成交金额', np.sum),
-                '直接成交金额': ('直接成交金额', np.sum),
-                '销售额': ('销售额', np.sum),
-                '销售量': ('销售量', np.sum),
-                '退款额_发货后': ('退款额_发货后', np.sum),
-                '退货量_发货后': ('退货量_发货后', np.sum),
-            }
-        )
-
-        idbm['宝贝id'] = idbm['宝贝id'].astype('int64')
-        # 1.  id 编码表合并图片表
-        df_cb = pd.merge(idbm, pic, how='left', left_on='宝贝id', right_on='商品id')
-        df_cb = df_cb[['宝贝id', '商家编码', '商品图片']]
-        # 2.  df 合并商品成本表
-        df_cb = pd.merge(df_cb, cost, how='left', left_on='商家编码', right_on='款号')
-        df_cb = df_cb[['宝贝id', '商家编码', '商品图片', '成本价']]
-        # 3.  合并 df
-        df = pd.merge(df, df_cb, how='left', left_on='商品id', right_on='宝贝id')
-        df.drop(labels='宝贝id', axis=1, inplace=True)
-
-        # df.drop_duplicates(subset=['日期', '店铺名称', '商品id', '花费', '销售额'], keep='last', inplace=True, ignore_index=True)
-        df.fillna(0, inplace=True)
-        df['成本价'] = df['成本价'].astype('float64')
-        df['销售额'] = df['销售额'].astype('float64')
-        df['销售量'] = df['销售量'].astype('int64')
-        df['商品成本'] = df.apply(lambda x: (x['成本价'] + x['销售额']/x['销售量'] * 0.11 + 6) * x['销售量'] if x['销售量'] > 0 else 0, axis=1)
-        df['商品毛利'] = df.apply(lambda x: x['销售额'] - x['商品成本'], axis=1)
-        df['毛利率'] = df.apply(lambda x: round((x['销售额'] - x['商品成本']) / x['销售额'], 4) if x['销售额'] > 0 else 0, axis=1)
-        df['盈亏'] = df.apply(lambda x: x['商品毛利'] - x['花费'], axis=1)
-        [df[col].apply(lambda x: '0' if str(x) == '' else x) for col in df.columns.tolist()]
-        set_typ = {
-            '日期': 'date',
-            '店铺名称': 'varchar(100)',
-            '商品id': 'bigint',
-            '销售额': 'decimal(12,2)',
-            '销售量': 'int',
-            '退款额_发货后': 'decimal(12,2)',
-            '退货量_发货后': 'int',
-            '花费': 'decimal(12,2)',
-            '成交金额': 'decimal(12,2)',
-            '直接成交金额': 'decimal(12,2)',
-            '商家编码': 'varchar(100)',
-            '商品图片': 'varchar(255)',
-            '成本价': 'decimal(10,2)',
-            '商品成本': 'decimal(10,2)',
-            '商品毛利': 'decimal(10,2)',
-            '毛利率': 'decimal(12,4)',
-            '盈亏': 'decimal(12,4)',
-        }
-        if not self.update_service:
-            return
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=[],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
-
-    # @try_except
+    @upload_data_decorator()
     def performance_concat(self, db_name, table_name, bb_tg=True):
         tg = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '天猫汇总表调用'][0]
         zb = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '天猫_超级直播'][0]
@@ -3697,92 +3640,23 @@ class MysqlDatasQuery:
             '直接成交金额': 'decimal(12,2)',
             '自然流量曝光量': 'int',
         }
-        if not self.update_service:
-            return
         df['日期'] = pd.to_datetime(df['日期'], format='%Y-%m-%d', errors='ignore')
-        min_date = df['日期'].min()
-        max_date = df['日期'].max()
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=[],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
-
-    # @try_except
-    def performance_jd(self, db_name, table_name, jd_tg=True, ):
-        jdtg = [item['数据主体'] for item in self.pf_datas_jd if item['集合名称'] == '京东_京准通'][0]
-        sku_sales = [item['数据主体'] for item in self.pf_datas_jd if item['集合名称'] == '京东_sku_商品明细'][0]
-        cost = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '商品成本'][0]
-        jdtg = jdtg[jdtg['花费'] > 0]
-        jdtg = jdtg.groupby(['日期', '跟单sku_id'],
-                        as_index=False).agg(
-            **{
-                '花费': ('花费', np.sum)
-            }
-        )
-        df = pd.merge(sku_sales, cost, how='left', left_on='货号', right_on='款号')
-        df = df[['日期', '商品id', '货号', '成交单量', '成交金额', '成本价']]
-        df['商品id'] = df['商品id'].astype(str)
-        jdtg['跟单sku_id'] = jdtg['跟单sku_id'].astype(str)
-        jdtg = jdtg.astype({'日期': 'datetime64[ns]'}, errors='raise')
-        df = df.astype({'日期': 'datetime64[ns]'}, errors='raise')
-        if jd_tg is True:
-            # 完整的数据表，包含全店所有推广、销售数据
-            df = pd.merge(df, jdtg, how='left', left_on=['日期', '商品id'], right_on=['日期', '跟单sku_id'])  # df 合并推广表
-        else:
-            df = pd.merge(jdtg, df, how='left', left_on=['日期', '跟单sku_id'], right_on=['日期', '商品id'])  # 推广表合并 df
-        df = df[['日期', '跟单sku_id', '花费', '货号', '成交单量', '成交金额', '成本价']]
-        df.fillna(0, inplace=True)
-        df['成本价'] = df['成本价'].astype('float64')
-        df['成交金额'] = df['成交金额'].astype('float64')
-        df['花费'] = df['花费'].astype('float64')
-        df['成交单量'] = df['成交单量'].astype('int64')
-        df['商品成本'] = df.apply(
-            lambda x: (x['成本价'] + x['成交金额'] / x['成交单量'] * 0.11 + 6) * x['成交单量'] if x['成交单量'] > 0 else 0,
-            axis=1)
-        df['商品毛利'] = df.apply(lambda x: x['成交金额'] - x['商品成本'], axis=1)
-        df['毛利率'] = df.apply(
-            lambda x: round((x['成交金额'] - x['商品成本']) / x['成交金额'], 4) if x['成交金额'] > 0 else 0, axis=1)
-        df['盈亏'] = df.apply(lambda x: x['商品毛利'] - x['花费'], axis=1)
-        [df[col].apply(lambda x: '0' if str(x) == '' else x) for col in df.columns.tolist()]
-        set_typ = {
-            '日期': 'date',
-            '跟单sku_id': 'bigint',
-            '花费': 'decimal(12,2)',
-            '货号': 'varchar(100)',
-            '成交单量': 'int',
-            '成交金额': 'decimal(12,2)',
-            '成本价': 'decimal(10,2)',
-            '商品成本': 'decimal(10,2)',
-            '商品毛利': 'decimal(10,2)',
-            '毛利率': 'decimal(12,4)',
-            '盈亏': 'decimal(12,4)',
-        }
-        if not self.update_service:
-            return
-        min_date = df['日期'].min().strftime("%Y-%m-%d")
-        max_date = df['日期'].max().strftime("%Y-%m-%d")
-        logger.info(f'正在更新: mysql ({host}:{port}) {db_name}/{table_name} -> {min_date}~{max_date}')
-        m_engine.df_to_mysql(
-            df=df,
-            db_name=db_name,
-            table_name=table_name,
-            icm_update=[],  # 增量更新, 在聚合数据中使用，其他不要用
-            move_insert=True,  # 先删除，再插入
-            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-            count=None,
-            filename=None,  # 用来追踪处理进度
-            set_typ=set_typ,
-        )
-        return True
+        logger.info('正在更新数据库', {'主机': f'{host}:{port}', '库': db_name, '表': table_name})
+        return df, {
+            'db_name': db_name,
+            'table_name': table_name,
+            'set_typ': set_typ,
+            'primary_keys': [],  # 创建唯一主键
+            'check_duplicate': False,  # 检查重复数据
+            'duplicate_columns': [],  # 指定排重的组合键
+            'update_on_duplicate': True,  # 更新旧数据
+            'allow_null': False,  # 允许插入空值
+            'partition_by': None,  # 分表方式
+            'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+            'indexes': [],  # 普通索引列
+            'transaction_mode': 'batch',  # 事务模式
+            'unique_keys': [['日期', '店铺名称', '推广渠道', '营销场景', '商品id']],  # 唯一约束列表
+        }
 
 
 def get_day_of_month(num):
@@ -3798,6 +3672,7 @@ def get_day_of_month(num):
     return _firstDay, _lastDay
 
 
+@upload_data_decorator()
 def date_table():
     """
     生成 pbix 使用的日期表
@@ -3854,7 +3729,6 @@ def date_table():
     df = df.reset_index(drop=False)
     df.rename(columns={'index': 'id'}, inplace=True)
     df['id'] = df['id'].apply(lambda x: x + 1)
-
     set_typ = {
         '日期': 'date',
         '年': 'varchar(50)',
@@ -3869,23 +3743,32 @@ def date_table():
         '索引': 'int',
         '月索引': 'int',
     }
-    m_engine.df_to_mysql(
-        df=df,
-        db_name='聚合数据',
-        table_name='日期表',
-        move_insert=True,  # 先删除，再插入
-        df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-        set_typ=set_typ,
-    )
+
+    return df, {
+        'db_name': '聚合数据',
+        'table_name': '日期表',
+        'set_typ': set_typ,
+        'primary_keys': [],  # 创建唯一主键
+        'check_duplicate': False,  # 检查重复数据
+        'duplicate_columns': [],  # 指定排重的组合键
+        'update_on_duplicate': True,  # 更新旧数据
+        'allow_null': False,  # 允许插入空值
+        'partition_by': None,  # 分表方式
+        'partition_date_column': '日期',  # 用于分表的日期列名，默认为'日期'
+        'indexes': [],  # 普通索引列
+        'transaction_mode': 'batch',  # 事务模式
+        'unique_keys': [['日期']],  # 唯一约束列表
+    }
 
 
-def query1(months=1, less_dict=[]):
+def query1(months=1, less_dict=None, download_manager=None):
+    if less_dict is None:
+        less_dict = []
     if months == 0:
-        logger.info(f'months 不建议为 0 ')
+        logger.info('months 不建议为 0')
         return
-    sdq = MysqlDatasQuery()  # 实例化数据处理类
+    sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
-    sdq.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
 
     # 依赖表  -- >>
     sdq.tg_wxt(db_name='聚合数据', table_name='天猫_主体报表')
@@ -3907,19 +3790,17 @@ def query1(months=1, less_dict=[]):
     sdq.spu_sales(db_name='聚合数据', table_name='京东_spu_商品明细')
     sdq.zb_ccfx(db_name='聚合数据', table_name='生意参谋_直播场次分析')
     sdq.tg_by_day(db_name='聚合数据', table_name='多店推广场景_按日聚合')
-    # sdq.performance(bb_tg=True, db_name='聚合数据', table_name='_全店商品销售')  # _全店商品销售
-    # sdq.performance(bb_tg=False, db_name='聚合数据', table_name='_推广商品销售')  # _推广商品销售
-    # sdq.performance_jd(jd_tg=False, db_name='聚合数据', table_name='_京东_推广商品销售')  # _推广商品销售
     sdq.performance_concat(bb_tg=False, db_name='聚合数据', table_name='天猫_推广汇总')  # _推广商品销售
 
 
-def query2(months=1, less_dict=[]):
+def query2(months=1, less_dict=None, download_manager=None):
+    if less_dict is None:
+        less_dict = []
     if months == 0:
-        logger.info(f'months 不建议为 0 ')
+        logger.info('months 不建议为 0')
         return
-    sdq = MysqlDatasQuery()  # 实例化数据处理类
+    sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
-    sdq.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
     sdq.dplyd(db_name='聚合数据', table_name='店铺流量来源构成')
     sdq.tg_rqbb(db_name='聚合数据', table_name='天猫_人群报表')
     sdq.tg_gjc(db_name='聚合数据', table_name='天猫_关键词报表')
@@ -3930,102 +3811,35 @@ def query2(months=1, less_dict=[]):
     sdq.deeplink(db_name='聚合数据', table_name='达摩盘_deeplink人群洞察')
 
 
-def query3(months=1, less_dict=[]):
+def query3(months=1, less_dict=None, download_manager=None):
+    if less_dict is None:
+        less_dict = []
     if months == 0:
-        logger.info(f'months 不建议为 0 ')
+        logger.info('months 不建议为 0')
         return
-    sdq = MysqlDatasQuery()  # 实例化数据处理类
+    sdq = MysqlDatasQuery(download_manager=download_manager)  # 实例化数据处理类
     sdq.months = months  # 设置数据周期， 1 表示近 2 个月
-    sdq.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
     sdq.spph(db_name='聚合数据', table_name='天猫_商品排行')
 
 
-def op_data(db_name_lists, days: int = 63, is_mongo=True, is_mysql=True):
-    # Mysql
-    if is_mysql:
-        s = mysql.OptimizeDatas(username=username, password=password, host=host, port=port)
-        s.db_name_lists = db_name_lists
-        s.days = days
-        s.optimize_list()
-
-
 def main(days=150, months=3):
-    """
-    days:    清理聚合数据的日期长度，days 最好大于 3 * (months +1)
-    months:   生成聚合数据的长度
-    """
     # 1. 更新日期表  更新货品年份基准表， 属性设置 3 - 货品年份基准
     date_table()
 
-    # 清理非聚合数据库
-    db_list = [
-        "京东数据3",
-        "属性设置3",
-        "推广数据2",
-        "推广数据_淘宝店",
-        "推广数据_奥莱店",
-        "推广数据_圣积天猫店",
-        "爱库存2",
-        "生意参谋3",
-        "生意经3",
-        "达摩盘3",
-        '人群画像2',
-        '商品人群画像2',
-        '市场数据3',
-        '回传数据',
-        '数据引擎2',
-    ]
-    # 使用 ThreadPoolExecutor 来并行运行
-    # with concurrent.futures.ThreadPoolExecutor() as executor:
-    with concurrent.futures.ProcessPoolExecutor() as executor:
-        for step in range(len(db_list)):
-            future_to_function = {
-                executor.submit(
-                    op_data,
-                    days=31,
-                    is_mongo=False,
-                    is_mysql=True,
-                    db_name_lists=[db_list[step]],
-                ),
-            }
-        # # 等待所有任务完成并获取执行结果
-        # for future in concurrent.futures.as_completed(future_to_function):
-        #     future.result()
-
     # 2. 数据聚合
-    query_list = [query1, query2, query3]
-    # 使用 ThreadPoolExecutor 来并行运行
-    # with concurrent.futures.ThreadPoolExecutor() as executor:
-    with concurrent.futures.ProcessPoolExecutor() as executor:
-        for func_query in query_list:
-            future_to_function = {
-                executor.submit(
-                    func_query,
-                    months=months,
-                    less_dict=[],
-                ),
-            }
-    # query_(months=months)
-    time.sleep(10)
-
-    # 3. 清理聚合数据
-    op_data(
-        db_name_lists=['聚合数据'],
-        days=days,  # 清理聚合数据的日期长度
-        is_mongo=False,
-        is_mysql=True,
-    )
-
-
-def test():
-    sdq = MysqlDatasQuery()  # 实例化数据处理类
-    sdq.months = 1  # 设置数据周期， 1 表示近 2 个月
-    sdq.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
-    sdq.spph(db_name='聚合数据', table_name='天猫_商品排行')
+    download_manager = s_query.QueryDatas(
+        username=username, 
+        password=password, 
+        host=host, 
+        port=port,
+        maxconnections=30,
+        )
+    query1(download_manager=download_manager, months=months)
+    query2(download_manager=download_manager, months=months)
+    query3(download_manager=download_manager, months=months)
 
 
 if __name__ == '__main__':
-    main(
-        days=150,  # 清理聚合数据的日期长度
-        months=3  # 生成聚合数据的长度
-    )
+    # main(months=3)
+
+    pass