mdbq 2.9.7__py3-none-any.whl → 2.9.9__py3-none-any.whl

mdbq/aggregation/query_data.py

@@ -1,7 +1,6 @@
 # -*- coding: UTF-8 –*-
 import re
 import socket
-from mdbq.mongo import mongo
 from mdbq.mysql import mysql
 from mdbq.mysql import s_query
 from mdbq.aggregation import optimize_data
@@ -19,12 +18,6 @@ import os
 import time
 
 """
-程序用于下载数据库(调用 s_query.py 下载并清洗), 并对数据进行聚合清洗, 不会更新数据库信息;
-
-添加新库流程：
-1.  在 MysqlDatasQuery 类中创建函数，从数据库取出数据
-2.  在 GroupBy 类中创建函数，处理聚合数据
-3.  在 data_aggregation 类中添加 data_dict 字典键值，回传数据到数据库
 
 """
 username, password, host, port, service_database = None, None, None, None, None,
@@ -40,61 +33,13 @@ elif socket.gethostname() in ['company', 'Mac2.local']:
     service_database = {'company': 'mysql'}
 if not username:
     print(f'找不到主机：')
-
-
-
-
-class MongoDatasQuery:
-    """
-    从 数据库 中下载数据
-    self.output: 数据库默认导出目录
-    self.is_maximize: 是否最大转化数据
-    """
-    def __init__(self, target_service):
-        # target_service 从哪个服务器下载数据
-        self.months = 0  # 下载几个月数据, 0 表示当月, 1 是上月 1 号至今
-        # 实例化一个下载类
-        self.download = mongo.DownMongo(username=username, password=password, host=host, port=port, save_path=None)
-
-    def tg_wxt(self):
-        self.download.start_date, self.download.end_date = self.months_data(num=self.months)
-        projection = {
-            '日期': 1,
-            '场景名字': 1,
-            '主体id': 1,
-            '花费': 1,
-            '展现量': 1,
-            '点击量': 1,
-            '总购物车数': 1,
-            '总成交笔数': 1,
-            '总成交金额': 1,
-            '自然流量曝光量': 1,
-            '直接成交笔数': 1,
-            '直接成交金额': 1,
-        }
-        df = self.download.data_to_df(
-            db_name='推广数据2',
-            collection_name='主体报表',
-            projection=projection,
-        )
-        return df
-
-    @staticmethod
-    def days_data(days, end_date=None):
-        """ 读取近 days 天的数据 """
-        if not end_date:
-            end_date = datetime.datetime.now()
-        start_date = end_date - datetime.timedelta(days=days)
-        return pd.to_datetime(start_date), pd.to_datetime(end_date)
-
-    @staticmethod
-    def months_data(num=0, end_date=None):
-        """ 读取近 num 个月的数据, 0 表示读取当月的数据 """
-        if not end_date:
-            end_date = datetime.datetime.now()
-        start_date = end_date - relativedelta(months=num)  # n 月以前的今天
-        start_date = f'{start_date.year}-{start_date.month}-01'  # 替换为 n 月以前的第一天
-        return pd.to_datetime(start_date), pd.to_datetime(end_date)
+m_engine = mysql.MysqlUpload(
+    username=username,
+    password=password,
+    host=host,
+    port=port,
+    charset='utf8mb4'
+)
 
 
 class MysqlDatasQuery:
@@ -106,6 +51,9 @@ class MysqlDatasQuery:
         self.months = 0  # 下载几个月数据, 0 表示当月, 1 是上月 1 号至今
         # 实例化一个下载类
         self.download = s_query.QueryDatas(username=username, password=password, host=host, port=port)
+        self.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
+        self.pf_datas = []
+        self.pf_datas_jd = []  # 京东聚合销售表
 
     @staticmethod
     def try_except(func):  # 在类内部定义一个异常处理方法
@@ -118,8 +66,8 @@ class MysqlDatasQuery:
 
         return wrapper
 
-    @try_except
-    def tg_wxt(self):
+    # @try_except
+    def tg_wxt(self, db_name='聚合数据', table_name='天猫_主体报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -143,10 +91,100 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.rename(columns={
+            '场景名字': '营销场景',
+            '主体id': '商品id',
+            '总购物车数': '加购量',
+            '总成交笔数': '成交笔数',
+            '总成交金额': '成交金额'
+        }, inplace=True)
+        df = df.astype({
+            '商品id': str,
+            '花费': float,
+            '展现量': int,
+            '点击量': int,
+            '加购量': int,
+            '成交笔数': int,
+            '成交金额': float,
+            '自然流量曝光量': int,
+            '直接成交笔数': int,
+            '直接成交金额': float,
+        }, errors='raise')
+        if is_maximize:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量'], as_index=False).agg(
+                **{'加购量': ('加购量', np.max),
+                   '成交笔数': ('成交笔数', np.max),
+                   '成交金额': ('成交金额', np.max),
+                   '自然流量曝光量': ('自然流量曝光量', np.max),
+                   '直接成交笔数': ('直接成交笔数', np.max),
+                   '直接成交金额': ('直接成交金额', np.max)
+                   }
+            )
+        else:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量'], as_index=False).agg(
+                **{
+                    '加购量': ('加购量', np.min),
+                    '成交笔数': ('成交笔数', np.min),
+                    '成交金额': ('成交金额', np.min),
+                    '自然流量曝光量': ('自然流量曝光量', np.min),
+                    '直接成交笔数': ('直接成交笔数', np.max),
+                    '直接成交金额': ('直接成交金额', np.max)
+                }
+            )
+        df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '商品id': 'bigint',
+            '花费': 'decimal(12,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '自然流量曝光量': 'int',
+            '直接成交笔数': 'int',
+            '直接成交金额': 'decimal(12,2)',
+        }
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['日期', '店铺名称', '商品id', '花费', '成交金额', '直接成交金额']]
+            }
+        )  # 制作其他聚合表
+        self.pf_datas.append(
+            {
+                '集合名称': '天猫汇总表调用',
+                '数据主体': df[
+                    ['日期', '店铺名称', '推广渠道', '营销场景', '商品id', '花费', '展现量', '点击量', '加购量',
+                     '成交笔数', '成交金额', '直接成交笔数', '直接成交金额', '自然流量曝光量']]
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def syj(self):
+    def syj(self, db_name='聚合数据', table_name='生意经_宝贝指标'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -169,10 +207,71 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df['宝贝id'] = df['宝贝id'].astype(str)
+        df = df.groupby(['日期', '店铺名称', '宝贝id', '行业类目'], as_index=False).agg(
+            **{'销售额': ('销售额', np.min),
+               '销售量': ('销售量', np.min),
+               '订单数': ('订单数', np.min),
+               '退货量': ('退货量', np.max),
+               '退款额': ('退款额', np.max),
+               '退款额_发货后': ('退款额_发货后', np.max),
+               '退货量_发货后': ('退货量_发货后', np.max),
+               }
+        )
+        df['件均价'] = df.apply(lambda x: x['销售额'] / x['销售量'] if x['销售量'] > 0 else 0, axis=1).round(
+            0)  # 两列运算, 避免除以0
+        df['价格带'] = df['件均价'].apply(
+            lambda x: '2000+' if x >= 2000
+            else '1000+' if x >= 1000
+            else '500+' if x >= 500
+            else '300+' if x >= 300
+            else '300以下'
+        )
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '宝贝id': 'bigint',
+            '行业类目': 'varchar(255)',
+            '销售额': 'decimal(12,2)',
+            '销售量': 'int',
+            '订单数': 'int',
+            '退货量': 'int',
+            '退款额': 'decimal(12,2)',
+            '退款额_发货后': 'decimal(12,2)',
+            '退货量_发货后': 'int',
+            '件均价': '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()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def tg_rqbb(self):
+    def tg_rqbb(self, db_name='聚合数据', table_name='天猫_人群报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -196,10 +295,166 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.rename(columns={
+            '场景名字': '营销场景',
+            '主体id': '商品id',
+            '总购物车数': '加购量',
+            '总成交笔数': '成交笔数',
+            '总成交金额': '成交金额'
+        }, inplace=True)
+        df.fillna(0, inplace=True)
+        df = df.astype({
+            '商品id': str,
+            '花费': float,
+            '展现量': int,
+            '点击量': int,
+            '加购量': int,
+            '成交笔数': int,
+            '成交金额': float,
+            '直接成交笔数': int,
+            '直接成交金额': float,
+        }, errors='raise')
+        if is_maximize:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '人群名字'],
+                            as_index=False).agg(
+                **{'加购量': ('加购量', np.max),
+                   '成交笔数': ('成交笔数', np.max),
+                   '成交金额': ('成交金额', np.max),
+                   '直接成交笔数': ('直接成交笔数', np.max),
+                   '直接成交金额': ('直接成交金额', np.max)
+                   }
+            )
+        else:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '人群名字'],
+                            as_index=False).agg(
+                **{
+                    '加购量': ('加购量', np.min),
+                    '成交笔数': ('成交笔数', np.min),
+                    '成交金额': ('成交金额', np.min),
+                    '直接成交笔数': ('直接成交笔数', np.max),
+                    '直接成交金额': ('直接成交金额', np.max)
+                }
+            )
+        df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
+        # 1. 匹配 L后面接 2 个或以上数字，不区分大小写，示例：L345
+        # 2. 其余情况，L 后面接多个数字的都会被第一条 if 命中，不区分大小写
+        df['消费力层级'] = df.apply(
+            lambda x:
+            ''.join(re.findall(r'(l\d+)', x['人群名字'].upper(), re.IGNORECASE)) if re.findall(r'(l\d{2,})',
+                                                                                               x['人群名字'],
+                                                                                               re.IGNORECASE)
+            else 'L5' if re.findall(r'(l\d*5)', x['人群名字'], re.IGNORECASE)
+            else 'L4' if re.findall(r'(l\d*4)', x['人群名字'], re.IGNORECASE)
+            else 'L3' if re.findall(r'(l\d*3)', x['人群名字'], re.IGNORECASE)
+            else 'L2' if re.findall(r'(l\d*2)', x['人群名字'], re.IGNORECASE)
+            else 'L1' if re.findall(r'(l\d*1)', x['人群名字'], re.IGNORECASE)
+            else '', axis=1)
+        # 1. 匹配连续的 4 个数字且后面不能接数字或"元"或汉字，筛掉的人群示例：月均消费6000元｜受众20240729175213｜xxx2024真皮公文包
+        # 2. 匹配 2数字_2数字且前面不能是数字，合法匹配：人群_30_50_促； 非法示例：L345_3040 避免识别出 35～20 岁用户的情况
+        # pattern = r'(\d{4})(?!\d|[\u4e00-\u9fa5])'  # 匹配 4 个数字，后面不能接数字或汉字
+        # pattern = r'(?<![\d\u4e00-\u9fa5])(\d{4})' # 匹配前面不是数字或汉字的 4 个连续数字
+
+        # 匹配 4 个数字，前面和后面都不能是数字或汉字
+        pattern1 = r'(?<![\d\u4e00-\u9fa5])(\d{4})(?!\d|[\u4e00-\u9fa5])'
+        # 匹配指定字符，前面不能是数字或 l 或 L 开头
+        pattern2 = r'(?<![\dlL])(\d{2}_\d{2})'
+        df['用户年龄'] = df.apply(
+            lambda x:
+            ''.join(re.findall(pattern1, x['人群名字'].upper())) if re.findall(pattern1, x['人群名字'])
+            # else ''.join(re.findall(r'[^\d|l|L](\d{2}_\d{2})', x['人群名字'].upper())) if re.findall(r'[^\d|l|L](\d{2}_\d{2})', x['人群名字'])
+            else ''.join(re.findall(pattern2, x['人群名字'].upper())) if re.findall(pattern2, x['人群名字'])
+            else ''.join(re.findall(r'(\d{2}-\d{2})岁', x['人群名字'].upper())) if re.findall(r'(\d{2}-\d{2})岁',
+                                                                                              x['人群名字'])
+            else '', axis=1)
+        df['用户年龄'] = df['用户年龄'].apply(
+            lambda x: f'{x[:2]}~{x[2:4]}' if str(x).isdigit()
+            else str(x).replace('_', '~') if '_' in x
+            else str(x).replace('-', '~') if '-' in x
+            else x
+        )
+        # 年龄层不能是 0 开头
+        df['用户年龄'] = df['用户年龄'].apply(
+            lambda x: '' if str(x).startswith('0') else x)
+        # df = df.head(1000)
+        # df.to_csv('/Users/xigua/Downloads/test.csv', index=False, header=True, encoding='utf-8_sig')
+        # breakpoint()
+
+        # 下面是添加人群 AIPL 分类
+        dir_file = f'\\\\192.168.1.198\\时尚事业部\\01.运营部\\0-电商周报-每周五更新\\分类配置文件.xlsx'
+        dir_file2 = '/Volumes/时尚事业部/01.运营部/0-电商周报-每周五更新/分类配置文件.xlsx'
+        if platform.system() == 'Windows':
+            dir_file3 = 'C:\\同步空间\\BaiduSyncdisk\\原始文件2\\分类配置文件.xlsx'
+        else:
+            dir_file3 = '/Users/xigua/数据中心/原始文件2/分类配置文件.xlsx'
+        if not os.path.isfile(dir_file):
+            dir_file = dir_file2
+        if not os.path.isfile(dir_file):
+            dir_file = dir_file3
+        if os.path.isfile(dir_file):
+            df_fl = pd.read_excel(dir_file, sheet_name='人群分类', header=0)
+            df_fl = df_fl[['人群名字', '人群分类']]
+            # 合并并获取分类信息
+            df = pd.merge(df, df_fl, left_on=['人群名字'], right_on=['人群名字'], how='left')
+            df['人群分类'].fillna('', inplace=True)
+        if '人群分类' in df.columns.tolist():
+            # 这行决定了，从文件中读取的分类信息优先级高于内部函数的分类规则
+            # 这个 lambda 适配人群名字中带有特定标识的分类，强匹配
+            df['人群分类'] = df.apply(
+                lambda x: self.set_crowd(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
+                else x['人群分类'], axis=1
+            )
+            # 这个 lambda 适配人群名字中聚类的特征字符，弱匹配
+            df['人群分类'] = df.apply(
+                lambda x: self.set_crowd2(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
+                else x['人群分类'], axis=1
+            )
+        else:
+            df['人群分类'] = df['人群名字'].apply(lambda x: self.set_crowd(keyword=str(x), as_file=False))
+            df['人群分类'] = df.apply(
+                lambda x: self.set_crowd2(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
+                else x['人群分类'], axis=1
+            )
+        df['人群分类'] = df['人群分类'].apply(lambda x: str(x).upper() if x else x)
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '商品id': 'bigint',
+            '花费': 'decimal(10,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '人群名字': 'varchar(255)',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '直接成交笔数': 'int',
+            '直接成交金额': 'decimal(12,2)',
+            '消费力层级': 'varchar(100)',
+            '用户年龄': 'varchar(100)',
+            '人群分类': 'varchar(100)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def tg_gjc(self):
+    def tg_gjc(self, db_name='聚合数据', table_name='天猫_关键词报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -224,10 +479,111 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.rename(columns={
+            '场景名字': '营销场景',
+            '宝贝id': '商品id',
+            '总购物车数': '加购量',
+            '总成交笔数': '成交笔数',
+            '总成交金额': '成交金额'
+        }, inplace=True)
+        df.fillna(0, inplace=True)
+        df = df.astype({
+            '商品id': str,
+            '花费': float,
+            '展现量': int,
+            '点击量': int,
+            '加购量': int,
+            '成交笔数': int,
+            '成交金额': float,
+            '直接成交笔数': int,
+            '直接成交金额': float,
+        }, errors='raise')
+        if is_maximize:
+            df = df.groupby(
+                ['日期', '店铺名称', '营销场景', '商品id', '词类型', '词名字_词包名字', '花费', '展现量', '点击量'],
+                as_index=False).agg(
+                **{'加购量': ('加购量', np.max),
+                   '成交笔数': ('成交笔数', np.max),
+                   '成交金额': ('成交金额', np.max),
+                   '直接成交笔数': ('直接成交笔数', np.max),
+                   '直接成交金额': ('直接成交金额', np.max)
+                   }
+            )
+        else:
+            df = df.groupby(
+                ['日期', '店铺名称', '营销场景', '商品id', '词类型', '词名字_词包名字', '花费', '展现量', '点击量'],
+                as_index=False).agg(
+                **{
+                    '加购量': ('加购量', np.min),
+                    '成交笔数': ('成交笔数', np.min),
+                    '成交金额': ('成交金额', np.min),
+                    '直接成交笔数': ('直接成交笔数', np.max),
+                    '直接成交金额': ('直接成交金额', np.max)
+                }
+            )
+        df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
+        df['是否品牌词'] = df['词名字_词包名字'].str.contains('万里马|wanlima', regex=True)
+        df['是否品牌词'] = df['是否品牌词'].apply(lambda x: '品牌词' if x else '')
+        dir_file = f'\\\\192.168.1.198\\时尚事业部\\01.运营部\\0-电商周报-每周五更新\\分类配置文件.xlsx'
+        dir_file2 = '/Volumes/时尚事业部/01.运营部/0-电商周报-每周五更新/分类配置文件.xlsx'
+        if not os.path.isfile(dir_file):
+            dir_file = dir_file2
+        if os.path.isfile(dir_file):
+            df_fl = pd.read_excel(dir_file, sheet_name='关键词分类', header=0)
+            # df_fl.rename(columns={'分类1': '词分类'}, inplace=True)
+            df_fl = df_fl[['关键词', '词分类']]
+            # 合并并获取词分类信息
+            df = pd.merge(df, df_fl, left_on=['词名字_词包名字'], right_on=['关键词'], how='left')
+            df.pop('关键词')
+            df['词分类'].fillna('', inplace=True)
+        if '词分类' in df.columns.tolist():
+            # 这行决定了，从文件中读取的词分类信息优先级高于 ret_keyword 函数的词分类
+            df['词分类'] = df.apply(
+                lambda x: self.ret_keyword(keyword=str(x['词名字_词包名字']), as_file=False) if x['词分类'] == ''
+                else x['词分类'], axis=1
+            )
+        else:
+            df['词分类'] = df['词名字_词包名字'].apply(lambda x: self.ret_keyword(keyword=str(x), as_file=False))
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '商品id': 'bigint',
+            '词类型': 'varchar(100)',
+            '词名字_词包名字': 'varchar(255)',
+            '花费': 'decimal(10,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '直接成交笔数': 'int',
+            '直接成交金额': 'decimal(12,2)',
+            '是否品牌词': 'varchar(100)',
+            '词分类': 'varchar(100)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def tg_cjzb(self):
+    def tg_cjzb(self, db_name='聚合数据', table_name='天猫_超级直播', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -253,10 +609,99 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.rename(columns={
+            '观看次数': '观看次数',
+            '总购物车数': '加购量',
+            '总成交笔数': '成交笔数',
+            '总成交金额': '成交金额',
+            '场景名字': '营销场景',
+        }, inplace=True)
+        df['营销场景'] = '超级直播'
+        df.fillna(0, inplace=True)
+        df = df.astype({
+            '花费': float,
+            # '点击量': int,
+            '加购量': int,
+            '成交笔数': int,
+            '成交金额': float,
+            '进店量': int,
+            '粉丝关注量': int,
+            '观看次数': int,
+        }, errors='raise')
+        if is_maximize:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '人群名字', '计划名字', '花费', '观看次数', '展现量'],
+                            as_index=False).agg(
+                **{
+                    '进店量': ('进店量', np.max),
+                    '粉丝关注量': ('粉丝关注量', np.max),
+                    '加购量': ('加购量', np.max),
+                    '成交笔数': ('成交笔数', np.max),
+                    '成交金额': ('成交金额', np.max),
+                    '直接成交笔数': ('直接成交笔数', np.max),
+                    '直接成交金额': ('直接成交金额', np.max),
+                }
+            )
+        else:
+            df = df.groupby(['日期', '店铺名称', '营销场景', '人群名字', '计划名字', '花费', '观看次数', '展现量'],
+                            as_index=False).agg(
+                **{
+                    '进店量': ('进店量', np.min),
+                    '粉丝关注量': ('粉丝关注量', np.min),
+                    '加购量': ('加购量', np.min),
+                    '成交笔数': ('成交笔数', np.min),
+                    '成交金额': ('成交金额', np.min),
+                    '直接成交笔数': ('直接成交笔数', np.min),
+                    '直接成交金额': ('直接成交金额', np.min),
+                }
+            )
+        df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['日期', '店铺名称', '推广渠道', '营销场景', '花费', '展现量', '观看次数', '加购量', '成交笔数', '成交金额', '直接成交笔数', '直接成交金额']]
+            },
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '人群名字': 'varchar(255)',
+            '计划名字': 'varchar(255)',
+            '花费': 'decimal(10,2)',
+            '观看次数': 'int',
+            '展现量': 'int',
+            '进店量': 'int',
+            '粉丝关注量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '直接成交笔数': 'int',
+            '直接成交金额': 'decimal(12,2)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def pxb_zh(self):
+    def pxb_zh(self, db_name='聚合数据', table_name='天猫_品销宝账户报表', is_maximize=True):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -280,10 +725,90 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df[df['报表类型'] == '账户']
+        df.fillna(value=0, inplace=True)
+        df.rename(columns={
+            '消耗': '花费',
+            '宝贝加购数': '加购量',
+            '搜索量': '品牌搜索量',
+            '搜索访客数': '品牌搜索人数'
+        }, inplace=True)
+        df = df.astype({
+            '花费': float,
+            '展现量': int,
+            '点击量': int,
+            '加购量': int,
+            '成交笔数': int,
+            '成交金额': float,
+            '品牌搜索量': int,
+            '品牌搜索人数': int,
+        }, errors='raise')
+        if is_maximize:
+            df = df.groupby(['日期', '店铺名称', '报表类型', '花费', '展现量', '点击量'], as_index=False).agg(
+                **{
+                    '加购量': ('加购量', np.max),
+                    '成交笔数': ('成交笔数', np.max),
+                    '成交金额': ('成交金额', np.max),
+                    '品牌搜索量': ('品牌搜索量', np.max),
+                    '品牌搜索人数': ('品牌搜索人数', np.max),
+                }
+            )
+        else:
+            df = df.groupby(['日期', '店铺名称', '报表类型', '花费', '展现量', '点击量'], as_index=False).agg(
+                **{
+                    '加购量': ('加购量', np.min),
+                    '成交笔数': ('成交笔数', np.min),
+                    '成交金额': ('成交金额', np.min),
+                    '品牌搜索量': ('品牌搜索量', np.min),
+                    '品牌搜索人数': ('品牌搜索人数', np.min),
+                }
+            )
+        df.insert(loc=1, column='推广渠道', value='品销宝')  # df中插入新列
+        df.insert(loc=2, column='营销场景', value='品销宝')  # df中插入新列
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['日期', '店铺名称', '推广渠道', '营销场景', '花费', '展现量', '点击量', '加购量', '成交笔数', '成交金额']]
+            },
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        set_typ = {
+            '日期': 'date',
+            '推广渠道': 'varchar(100)',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '报表类型': 'varchar(100)',
+            '花费': 'decimal(10,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '品牌搜索量': 'int',
+            '品牌搜索人数': 'int',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def idbm(self):
+    def idbm(self, db_name='聚合数据', table_name='商品id编码表'):
         """ 用生意经日数据制作商品 id 和编码对照表 """
         data_values = self.download.columns_to_list(
             db_name='生意经3',
@@ -291,10 +816,53 @@ class MysqlDatasQuery:
             columns_name=['宝贝id', '商家编码', '行业类目'],
         )
         df = pd.DataFrame(data=data_values)
-        return df
+        df['宝贝id'] = df['宝贝id'].astype(str)
+        df.drop_duplicates(subset='宝贝id', keep='last', inplace=True, ignore_index=True)
+        # df['行业类目'] = df['行业类目'].apply(lambda x: re.sub(' ', '', x))
+        try:
+            df[['一级类目', '二级类目', '三级类目']] = df['行业类目'].str.split(' -> ', expand=True).loc[:, 0:2]
+        except:
+            try:
+                df[['一级类目', '二级类目']] = df['行业类目'].str.split(' -> ', expand=True).loc[:, 0:1]
+            except:
+                df['一级类目'] = df['行业类目']
+        df.drop('行业类目', axis=1, inplace=True)
+        df.sort_values('宝贝id', ascending=False, inplace=True)
+        df = df[(df['宝贝id'] != '973') & (df['宝贝id'] != '973')]
+        set_typ = {
+            '宝贝id': 'bigint',
+            '商家编码': 'varchar(100)',
+            '一级类目': 'varchar(100)',
+            '二级类目': 'varchar(100)',
+            '三级类目': 'varchar(100)',
+        }
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['宝贝id', '商家编码']]
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def sp_picture(self):
+    def sp_picture(self, db_name='聚合数据', table_name='商品id图片对照表'):
         """ 用生意经日数据制作商品 id 和编码对照表 """
         data_values = self.download.columns_to_list(
             db_name='属性设置3',
@@ -302,10 +870,56 @@ class MysqlDatasQuery:
             columns_name=['日期', '商品id', '商品白底图', '方版场景图'],
         )
         df = pd.DataFrame(data=data_values)
-        return df
+        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)',
+        }
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['商品id', '商品图片']]
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def dplyd(self):
+    def dplyd(self, db_name='聚合数据', table_name='店铺流量来源构成'):
         """ 新旧版取的字段是一样的 """
         start_date, end_date = self.months_data(num=self.months)
         projection = {
@@ -327,34 +941,66 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        # df = df[df['店铺名称'] == '万里马官方旗舰店']
-        return df
-
-    @try_except
-    def dplyd_old(self):
-        start_date, end_date = self.months_data(num=self.months)
-        projection = {
-            '日期': 1,
-            '一级来源': 1,
-            '二级来源': 1,
-            '三级来源': 1,
-            '访客数': 1,
-            '支付金额': 1,
-            '支付买家数': 1,
-            '支付转化率': 1,
-            '加购人数': 1,
+        # 包含三级来源名称和预设索引值列
+        # 截取 从上月1日 至 今天的花费数据, 推广款式按此数据从高到低排序（商品图+排序）
+        df_visitor3 = df.groupby(['日期', '三级来源'], as_index=False).agg({'访客数': 'sum'})
+        df_visitor3 = df_visitor3[~df_visitor3['三级来源'].isin([''])]  # 指定列中删除包含空值的行
+        # df_visitor = df_visitor[(df_visitor['日期'] >= f'{year_my}-{last_month.month}-01')]
+        df_visitor3 = df_visitor3.groupby(['三级来源'], as_index=False).agg({'访客数': 'sum'})
+        df_visitor3.sort_values('访客数', ascending=False, ignore_index=True, inplace=True)
+        df_visitor3.reset_index(inplace=True)
+        df_visitor3['index'] = df_visitor3['index'] + 100
+        df_visitor3.rename(columns={'index': '三级访客索引'}, inplace=True)
+        df_visitor3 = df_visitor3[['三级来源', '三级访客索引']]
+
+        # 包含二级来源名称和预设索引值列
+        df_visitor2 = df.groupby(['日期', '二级来源'], as_index=False).agg({'访客数': 'sum'})
+        df_visitor2 = df_visitor2[~df_visitor2['二级来源'].isin([''])]  # 指定列中删除包含空值的行
+        # df_visitor2 = df_visitor2[(df_visitor2['日期'] >= f'{year_my}-{last_month.month}-01')]
+        df_visitor2 = df_visitor2.groupby(['二级来源'], as_index=False).agg({'访客数': 'sum'})
+        df_visitor2.sort_values('访客数', ascending=False, ignore_index=True, inplace=True)
+        df_visitor2.reset_index(inplace=True)
+        df_visitor2['index'] = df_visitor2['index'] + 100
+        df_visitor2.rename(columns={'index': '二级访客索引'}, inplace=True)
+        df_visitor2 = df_visitor2[['二级来源', '二级访客索引']]
+
+        df = pd.merge(df, df_visitor2, how='left', left_on='二级来源', right_on='二级来源')
+        df = pd.merge(df, df_visitor3, how='left', left_on='三级来源', right_on='三级来源')
+        set_typ = {
+            '日期': 'date',
+            '一级来源': 'varchar(100)',
+            '二级来源': 'varchar(100)',
+            '三级来源': 'varchar(100)',
+            '访客数': 'int',
+            '支付金额': 'decimal(12,2)',
+            '支付买家数': 'int',
+            '支付转化率': 'decimal(10,4)',
+            '加购人数': 'int',
+            '店铺名称': 'varchar(100)',
+            '二级访客索引': 'smallint',
+            '三级访客索引': 'smallint',
         }
-        df = self.download.data_to_df(
-            db_name='生意参谋2',
-            table_name='店铺来源_日数据_旧版',
-            start_date=start_date,
-            end_date=end_date,
-            projection=projection,
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
         )
-        return df
+        return True
 
     @try_except
-    def sp_cost(self):
+    def sp_cost(self, db_name='聚合数据', table_name='商品成本'):
         """ 电商定价 """
         data_values = self.download.columns_to_list(
             db_name='属性设置3',
@@ -362,10 +1008,46 @@ class MysqlDatasQuery:
             columns_name=['日期', '款号', '年份季节', '吊牌价', '商家平台', '成本价', '天猫页面价', '天猫中促价'],
         )
         df = pd.DataFrame(data=data_values)
-        return df
+        df.sort_values(by=['款号', '日期'], ascending=[False, True], ignore_index=True, inplace=True)
+        df.drop_duplicates(subset=['款号'], keep='last', inplace=True, ignore_index=True)
+        set_typ = {
+            '日期': 'date',
+            '款号': 'varchar(100)',
+            '年份季节': 'varchar(100)',
+            '吊牌价': 'decimal(10,2)',
+            '成本价': 'decimal(10,2)',
+            '天猫页面价': 'decimal(10,2)',
+            '天猫中促价': 'decimal(10,2)',
+        }
+        self.pf_datas.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['款号', '成本价']]
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def jdjzt(self):
+    def jdjzt(self, db_name='聚合数据', table_name='京东_京准通'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -391,13 +1073,68 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df.groupby(
+            ['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id', 'spu_id', '花费', '展现数', '点击数'],
+            as_index=False).agg(
+            **{'直接订单行': ('直接订单行', np.max),
+               '直接订单金额': ('直接订单金额', np.max),
+               '总订单行': ('总订单行', np.max),
+               '总订单金额': ('总订单金额', np.max),
+               '直接加购数': ('直接加购数', np.max),
+               '总加购数': ('总加购数', np.max),
+               }
+        )
+        df = df[df['花费'] > 0]
+        self.pf_datas_jd.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df[['日期', '产品线', '触发sku_id', '跟单sku_id', '花费']]
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '产品线': 'varchar(100)',
+            '触发sku_id': 'bigint',
+            '跟单sku_id': 'bigint',
+            'spu_id': 'bigint',
+            '花费': 'decimal(10,2)',
+            '展现数': 'int',
+            '点击数': 'int',
+            '直接订单行': 'int',
+            '直接订单金额': 'decimal(10,2)',
+            '总订单行': 'int',
+            '总订单金额': 'decimal(10,2)',
+            '直接加购数': 'int',
+            '总加购数': 'int',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def jdqzyx(self):
+    def jdqzyx(self, db_name='聚合数据', table_name='京东_京准通_全站营销'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
+            '店铺名称': 1,
             '产品线': 1,
             '花费': 1,
             '全站投产比': 1,
@@ -415,10 +1152,51 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df.groupby(['日期', '店铺名称', '产品线', '花费'], as_index=False).agg(
+            **{'全站投产比': ('全站投产比', np.max),
+               '全站交易额': ('全站交易额', np.max),
+               '全站订单行': ('全站订单行', np.max),
+               '全站订单成本': ('全站订单成本', np.max),
+               '全站费比': ('全站费比', np.max),
+               '核心位置展现量': ('核心位置展现量', np.max),
+               '核心位置点击量': ('核心位置点击量', np.max),
+               }
+        )
+        df = df[df['花费'] > 0]
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '产品线': 'varchar(100)',
+            '花费': 'decimal(10,2)',
+            '全站投产比': 'decimal(10,2)',
+            '全站交易额': 'decimal(10,2)',
+            '全站订单行': 'decimal(10,2)',
+            '全站订单成本': 'decimal(10,2)',
+            '全站费比': 'decimal(8,4)',
+            '核心位置展现量': 'int',
+            '核心位置点击量': 'int',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def jd_gjc(self):
+    def jd_gjc(self, db_name='聚合数据', table_name='京东_关键词报表'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -449,13 +1227,77 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df_lin = df[['计划id', '推广计划']]
+        df_lin.drop_duplicates(subset=['计划id'], keep='last', inplace=True, ignore_index=True)
+        df = df.groupby(
+            ['日期', '产品线', '计划类型', '计划id', '搜索词', '关键词', '关键词购买类型', '广告定向类型', '展现数',
+             '点击数', '花费'],
+            as_index=False).agg(
+            **{
+                '直接订单行': ('直接订单行', np.max),
+                '直接订单金额': ('直接订单金额', np.max),
+                '总订单行': ('总订单行', np.max),
+                '总订单金额': ('总订单金额', np.max),
+                '总加购数': ('总加购数', np.max),
+                '领券数': ('领券数', np.max),
+                '商品关注数': ('商品关注数', np.max),
+                '店铺关注数': ('店铺关注数', np.max)
+            }
+        )
+        df = pd.merge(df, df_lin, how='left', left_on='计划id', right_on='计划id')
+        df['k_是否品牌词'] = df['关键词'].str.contains('万里马|wanlima', regex=True)
+        df['k_是否品牌词'] = df['k_是否品牌词'].apply(lambda x: '品牌词' if x else '')
+        df['s_是否品牌词'] = df['搜索词'].str.contains('万里马|wanlima', regex=True)
+        df['s_是否品牌词'] = df['s_是否品牌词'].apply(lambda x: '品牌词' if x else '')
+        set_typ = {
+            '日期': 'date',
+            '产品线': 'varchar(100)',
+            '计划类型': 'varchar(100)',
+            '计划id': 'varchar(100)',
+            '搜索词': 'varchar(100)',
+            '关键词': 'varchar(100)',
+            '关键词购买类型': 'varchar(100)',
+            '广告定向类型': 'varchar(100)',
+            '展现数': 'int',
+            '点击数': 'int',
+            '花费': 'decimal(10,2)',
+            '直接订单行': 'int',
+            '直接订单金额': 'decimal(12,2)',
+            '总订单行': 'int',
+            '总订单金额': 'decimal(12,2)',
+            '总加购数': 'int',
+            '领券数': 'int',
+            '商品关注数': 'int',
+            '店铺关注数': 'int',
+            '推广计划': 'varchar(100)',
+            'k_是否品牌词': 'varchar(100)',
+            's_是否品牌词': 'varchar(100)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def sku_sales(self):
+    def sku_sales(self, db_name='聚合数据', table_name='京东_sku_商品明细'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
+            '店铺名称': 1,
             '商品id': 1,
             '货号': 1,
             '成交单量': 1,
@@ -472,13 +1314,59 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df[df['商品id'] != '合计']
+        df = df.groupby(['日期', '店铺名称', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数'],
+                        as_index=False).agg(
+            **{
+                '成交单量': ('成交单量', np.max),
+                '成交金额': ('成交金额', np.max),
+            }
+        )
+        self.pf_datas_jd.append(
+            {
+                '集合名称': table_name,
+                '数据主体': df
+            }
+        )  # 制作其他聚合表
+        if not self.update_service:
+            return
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '商品id': 'varchar(100)',
+            '货号': 'varchar(100)',
+            '访客数': 'int',
+            '成交客户数': 'int',
+            '加购商品件数': 'int',
+            '加购人数': 'int',
+            '成交单量': 'int',
+            '成交金额': 'decimal(10,2)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def spu_sales(self):
+    def spu_sales(self, db_name='聚合数据', table_name='京东_spu_商品明细'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
+            '店铺名称': 1,
             '商品id': 1,
             '货号': 1,
             '成交单量': 1,
@@ -495,7 +1383,44 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df[df['商品id'] != '合计']
+        df = df.groupby(['日期', '店铺名称', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数'],
+                        as_index=False).agg(
+            **{
+                '成交单量': ('成交单量', np.max),
+                '成交金额': ('成交金额', np.max),
+            }
+        )
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '商品id': 'varchar(100)',
+            '货号': 'varchar(100)',
+            '访客数': 'int',
+            '成交客户数': 'int',
+            '加购商品件数': 'int',
+            '加购人数': 'int',
+            '成交单量': 'int',
+            '成交金额': 'decimal(10,2)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @staticmethod
     def months_data(num=0, end_date=None):
@@ -507,7 +1432,7 @@ class MysqlDatasQuery:
         return pd.to_datetime(start_date), pd.to_datetime(end_date)
 
     @try_except
-    def se_search(self):
+    def se_search(self, db_name='聚合数据', table_name='天猫店铺来源_手淘搜索'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -531,10 +1456,53 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df = df.groupby(
+            ['日期', '店铺名称', '词类型', '搜索词'],
+            as_index=False).agg(
+            **{
+                '访客数': ('访客数', np.max),
+                '加购人数': ('加购人数', np.max),
+                '支付金额': ('支付金额', np.max),
+                '支付转化率': ('支付转化率', np.max),
+                '支付买家数': ('支付买家数', np.max),
+                '客单价': ('客单价', np.max),
+                'uv价值': ('uv价值', np.max)
+            }
+        )
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '词类型': 'varchar(100)',
+            '搜索词': 'varchar(100)',
+            '访客数': 'int',
+            '加购人数': 'int',
+            '支付金额': 'decimal(10,2)',
+            '支付转化率': 'decimal(10,4)',
+            '支付买家数': 'int',
+            '客单价': 'decimal(10,2)',
+            'uv价值': 'decimal(10,2)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def zb_ccfx(self):
+    def zb_ccfx(self, db_name='聚合数据', table_name='生意参谋_直播场次分析'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             # '日期': 1,
@@ -577,10 +1545,102 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.drop_duplicates(subset=['场次id'], keep='first', inplace=True, ignore_index=True)
+        set_typ = {
+            '日期': 'DATE',
+            '店铺名称': 'varchar(100)',
+            'fvr_pv': 'int',
+            '封面图点击率': 'decimal(10,4)',
+            'itrt_pv    ': 'int',
+            '开播时长': 'smallint',
+            '成交笔数': 'smallint',
+            'aov': 'decimal(10,2)',
+            '退款金额': 'decimal(12,2)',
+            '曝光pv': 'int',
+            '场次信息': 'varchar(255)',
+            'cmt_uv': 'int',
+            '退款件数占比': 'decimal(10,4)',
+            'reward_gift_cnt': 'smallint',
+            '观看人数': 'int',
+            '开播时长_f': 'varchar(100)',
+            'reward_uv_rate': 'smallint',
+            'fvr_uv': 'int',
+            '直播开播时间': 'datetime',
+            '商品点击率': 'decimal(10,4)',
+            '加购次数': 'smallint',
+            '成交转化率': 'decimal(10,4)',
+            'atv': 'decimal(10,2)',
+            '成交金额': 'decimal(12,2)',
+            '退款人数': 'smallint',
+            'index': 'smallint',
+            '预售定金支付人数': 'smallint',
+            '加购访客': 'smallint',
+            '商品点击次数': 'int',
+            '退款笔数': 'smallint',
+            'itrt_uv': 'smallint',
+            '成交人数': 'smallint',
+            '观看总时长': 'varchar(100)',
+            '加购访客转化率': 'decimal(10,4)',
+            'subpay_order_cnt': 'smallint',
+            'cmt_pv': 'int',
+            '商品点击人数': 'int',
+            'status': 'int',
+            '商品曝光uv': 'int',
+            '预售定金支付件数': 'smallint',
+            '预售预估总金额': 'decimal(12,2)',
+            '退款笔数占比': 'decimal(10,4)',
+            'reward_pv': 'int',
+            '访客点击量': 'int',
+            'aiv': 'decimal(10,2)',
+            'shr_uv': 'int',
+            '浏览点击量': 'int',
+            '场次图片': 'text',
+            'user_role': 'varchar(100)',
+            '退款人数占比': 'decimal(10,4)',
+            '退款件数': 'smallint',
+            '新增粉丝数': 'smallint',
+            '场均观看时长': 'decimal(10,2)',
+            '人均观看时长': 'decimal(10,2)',
+            '加购人数': 'smallint',
+            'reward_uv': 'smallint',
+            '直播结束时间': 'datetime',
+            '商品曝光pv': 'int',
+            'shr_pv': 'int',
+            '场次id': 'bigint',
+            'look_pv_flowcontrol': 'smallint',
+            '退款率': 'decimal(10,4)',
+            'is_delete': 'varchar(50)',
+            'atn_uv_rate': 'decimal(10,4)',
+            '成交件数': 'smallint',
+            '最大在线人数': 'int',
+            '曝光uv': 'int',
+            '加购件数': 'smallint',
+            '预售定金支付金额': 'decimal(12,2)',
+            '观看次数': 'int',
+            '封面图': 'text',
+            '更新时间': 'timestamp',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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=False,  # 先删除，再插入
+            df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     # @try_except
-    def tg_by_day(self):
+    def tg_by_day(self, db_name='聚合数据', table_name='多店推广场景_按日聚合'):
         """
         汇总各个店铺的推广数据，按日汇总
         """
@@ -768,26 +1828,71 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        df_jd_qzyx = df_jd_qzyx.groupby(['日期', '店铺名称', '产品线', '花费'], as_index=False).agg(
-            **{'全站投产比': ('全站投产比', np.max),
-               '成交金额': ('全站交易额', np.max),
-               '成交笔数': ('全站订单行', np.max),
-               '全站订单成本': ('全站订单成本', np.max),
-               '全站费比': ('全站费比', np.max),
-               '展现量': ('核心位置展现量', np.max),
-               '点击量': ('核心位置点击量', np.max),
-               }
-        )
-        df_jd_qzyx.rename(columns={'产品线': '营销场景'}, inplace=True)
-        df_jd_qzyx = df_jd_qzyx[['日期', '店铺名称', '营销场景', '花费', '展现量', '点击量', '成交笔数', '成交金额']]
-        df_jd_qzyx = df_jd_qzyx[df_jd_qzyx['花费'] > 0]
+        if len(df_jd_qzyx) > 0:
+            df_jd_qzyx = df_jd_qzyx.groupby(['日期', '店铺名称', '产品线', '花费'], as_index=False).agg(
+                **{'全站投产比': ('全站投产比', np.max),
+                   '成交金额': ('全站交易额', np.max),
+                   '成交笔数': ('全站订单行', np.max),
+                   '全站订单成本': ('全站订单成本', np.max),
+                   '全站费比': ('全站费比', np.max),
+                   '展现量': ('核心位置展现量', np.max),
+                   '点击量': ('核心位置点击量', np.max),
+                   }
+            )
+            df_jd_qzyx.rename(columns={'产品线': '营销场景'}, inplace=True)
+            df_jd_qzyx = df_jd_qzyx[['日期', '店铺名称', '营销场景', '花费', '展现量', '点击量', '成交笔数', '成交金额']]
+            df_jd_qzyx = df_jd_qzyx[df_jd_qzyx['花费'] > 0]
 
         _datas = [item for item in  [df_tm, df_tb, df_tm_pxb, df_tm_living, df_jd, df_jd_qzyx] if len(item) > 0]  # 阻止空的 dataframe
         df = pd.concat(_datas, axis=0, ignore_index=True)
-        return df
+        df['日期'] = pd.to_datetime(df['日期'], format='%Y-%m-%d', errors='ignore')  # 转换日期列
+        df = df.groupby(
+            ['日期', '店铺名称', '营销场景'],
+            as_index=False).agg(
+            **{
+                '花费': ('花费', np.sum),
+                '展现量': ('展现量', np.sum),
+                '点击量': ('点击量', np.sum),
+                '加购量': ('加购量', np.sum),
+                '成交笔数': ('成交笔数', np.sum),
+                '成交金额': ('成交金额', np.sum)
+            }
+        )
+        df.sort_values(['日期', '店铺名称', '花费'], ascending=[False, False, False], ignore_index=True, inplace=True)
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '花费': 'decimal(12,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+        }
+        if not self.update_service:
+            return
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def aikucun_bd_spu(self):
+    def aikucun_bd_spu(self, db_name='聚合数据', table_name='爱库存_商品spu榜单'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -833,10 +1938,45 @@ class MysqlDatasQuery:
             end_date=end_date,
             projection=projection,
         )
-        return df
+        df.drop_duplicates(
+            subset=[
+                '日期',
+                '店铺名称',
+                'spu_id',
+                '访客量',
+                '浏览量',
+                '下单gmv',
+                '成交gmv',
+            ], keep='last', inplace=True, ignore_index=True)
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '序号': 'int',
+            'spu_id': 'varchar(100)',
+            '图片': 'varchar(255)',
+            '数据更新时间': 'timestamp',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
-    def dmp_crowd(self):
+    def dmp_crowd(self, db_name='聚合数据', table_name='达摩盘_人群报表'):
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
@@ -876,702 +2016,71 @@ class MysqlDatasQuery:
         # df.to_csv('/Users/xigua/Downloads/test3.csv', index=False, header=True, encoding='utf-8_sig')
         # breakpoint()
         df.rename(columns={'消耗_元': '消耗'}, inplace=True)
-        return df
-
-
-
-class GroupBy:
-    """
-    数据聚合和导出
-    """
-    def __init__(self):
-        # self.output: 数据库默认导出目录
-        if platform.system() == 'Darwin':
-            self.output = os.path.join('/Users', getpass.getuser(), '数据中心/数据库导出')
-        elif platform.system() == 'Windows':
-            self.output = os.path.join('C:\\同步空间\\BaiduSyncdisk\\数据库导出')
-        else:
-            self.output = os.path.join('数据中心/数据库导出')
-        self.data_tgyj = {}  # 推广综合聚合数据表
-        self.data_jdtg = {}  # 京东推广数据，聚合数据
-        self.sp_index_datas = pd.DataFrame()  # 商品 id 索引表
-
-    @staticmethod
-    def try_except(func):  # 在类内部定义一个异常处理方法
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                print(f'{func.__name__}, {e}')  # 将异常信息返回
-
-        return wrapper
-
-    # @try_except
-    def groupby(self, df, table_name, is_maximize=True):
-        """
-        self.is_maximize: 是否最大转化数据
-        table_name： 聚合数据库处的名称，不是原始数据库
-        """
-        if isinstance(df, pd.DataFrame):
-            if len(df) == 0:
-                print(f' query_data.groupby 函数中 {table_name} 传入的 df 数据长度为0')
-                self.data_tgyj.update(
-                    {
-                        table_name: pd.DataFrame(),
-                    }
-                )
-                return pd.DataFrame()
-        # elif '多店推广场景_按日聚合' in table_name:  # 这个函数传递的是多个 df 组成的列表，暂时放行
-        #     pass
-        else:
-            print(f'query_data.groupby函数中 {table_name} 传入的 df 不是 dataframe 结构')
-            return pd.DataFrame()
-        # print(table_name)
-        if '天猫_主体报表' in table_name:
-            df.rename(columns={
-                '场景名字': '营销场景',
-                '主体id': '商品id',
-                '总购物车数': '加购量',
-                '总成交笔数': '成交笔数',
-                '总成交金额': '成交金额'
-            }, inplace=True)
-            df.fillna(0, inplace=True)
-            df = df.astype({
-                '商品id': str,
-                '花费': float,
-                '展现量': int,
-                '点击量': int,
-                '加购量': int,
-                '成交笔数': int,
-                '成交金额': float,
-                '自然流量曝光量': int,
-                '直接成交笔数': int,
-                '直接成交金额': float,
-            }, errors='raise')
-            if is_maximize:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{'加购量': ('加购量', np.max),
-                       '成交笔数': ('成交笔数', np.max),
-                       '成交金额': ('成交金额', np.max),
-                       '自然流量曝光量': ('自然流量曝光量', np.max),
-                       '直接成交笔数': ('直接成交笔数', np.max),
-                       '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            else:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{
-                        '加购量': ('加购量', np.min),
-                        '成交笔数': ('成交笔数', np.min),
-                        '成交金额': ('成交金额', np.min),
-                        '自然流量曝光量': ('自然流量曝光量', np.min),
-                        '直接成交笔数': ('直接成交笔数', np.max),
-                        '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
-            df_new = df.groupby(['日期', '店铺名称', '商品id'], as_index=False).agg(
-                    **{
-                        '花费': ('花费', np.sum),
-                        '成交笔数': ('成交笔数', np.max),
-                        '成交金额': ('成交金额', np.max),
-                        '自然流量曝光量': ('自然流量曝光量', np.max),
-                        '直接成交笔数': ('直接成交笔数', np.max),
-                        '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            self.data_tgyj.update(
-                {
-                    table_name: df_new,
-                }
-            )
-            self.data_tgyj.update(
-                {
-                    '天猫汇总表调用': df,
-                }
-            )
-            # df_pic：商品排序索引表, 给 powerbi 中的主推款排序用的,(从上月1号到今天的总花费进行排序)
-            today = datetime.date.today()
-            last_month = today - datetime.timedelta(days=30)
-            if last_month.month == 12:
-                year_my = today.year - 1
-            else:
-                year_my = today.year
-            # 截取 从上月1日 至 今天的花费数据, 推广款式按此数据从高到低排序（商品图+排序）
-            df_pic_lin = df[df['店铺名称'] == '万里马官方旗舰店']
-            df_pic = df_pic_lin.groupby(['日期', '商品id'], as_index=False).agg({'花费': 'sum'})
-            df_pic = df_pic[~df_pic['商品id'].isin([''])]  # 指定列中删除包含空值的行
-            date_obj = datetime.datetime.strptime(f'{year_my}-{last_month.month}-01', '%Y-%m-%d').date()
-            df_pic = df_pic[(df_pic['日期'] >= date_obj)]
-            df_pic = df_pic.groupby(['商品id'], as_index=False).agg({'花费': 'sum'})
-            df_pic.sort_values('花费', ascending=False, ignore_index=True, inplace=True)
-            df_pic.reset_index(inplace=True)
-            df_pic['index'] = df_pic['index'] + 100
-            df_pic.rename(columns={'index': '商品索引'}, inplace=True)
-            df_pic_new = pd.merge(df_pic_lin, df_pic, how='left', on=['商品id'])
-            df_pic_new['商品索引'].fillna(1000, inplace=True)
-            self.sp_index_datas = df_pic_new[['商品id', '商品索引']]  # 商品索引表_主推排序调用
-            return df
-        elif '商品索引表' in table_name:
-            return df
-        elif '爱库存_商品spu榜单' in table_name:
-            df.drop_duplicates(
-                subset=[
-                    '日期',
-                    '店铺名称',
-                    'spu_id',
-                    '访客量',
-                    '浏览量',
-                    '下单gmv',
-                    '成交gmv',
-                ], keep='last', inplace=True, ignore_index=True)
-            return df
-        elif '天猫_人群报表' in table_name and '达摩盘' not in table_name:
-            """
-            天猫推广人群报表独立生成消费力、年龄层、分类等特征，不依赖于达摩盘数据表
-            """
-            df.rename(columns={
-                '场景名字': '营销场景',
-                '主体id': '商品id',
-                '总购物车数': '加购量',
-                '总成交笔数': '成交笔数',
-                '总成交金额': '成交金额'
-            }, inplace=True)
-            df.fillna(0, inplace=True)
-            df = df.astype({
-                '商品id': str,
-                '花费': float,
-                '展现量': int,
-                '点击量': int,
-                '加购量': int,
-                '成交笔数': int,
-                '成交金额': float,
-                '直接成交笔数': int,
-                '直接成交金额': float,
-            }, errors='raise')
-            if is_maximize:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '人群名字'], as_index=False).agg(
-                    **{'加购量': ('加购量', np.max),
-                       '成交笔数': ('成交笔数', np.max),
-                       '成交金额': ('成交金额', np.max),
-                       '直接成交笔数': ('直接成交笔数', np.max),
-                       '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            else:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '花费', '展现量', '点击量', '人群名字'], as_index=False).agg(
-                    **{
-                        '加购量': ('加购量', np.min),
-                        '成交笔数': ('成交笔数', np.min),
-                        '成交金额': ('成交金额', np.min),
-                        '直接成交笔数': ('直接成交笔数', np.max),
-                        '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
-            # 1. 匹配 L后面接 2 个或以上数字，不区分大小写，示例：L345
-            # 2. 其余情况，L 后面接多个数字的都会被第一条 if 命中，不区分大小写
-            df['消费力层级'] = df.apply(
-                lambda x:
-                ''.join(re.findall(r'(l\d+)', x['人群名字'].upper(), re.IGNORECASE)) if re.findall(r'(l\d{2,})', x['人群名字'], re.IGNORECASE)
-                else 'L5' if re.findall(r'(l\d*5)', x['人群名字'], re.IGNORECASE)
-                else 'L4' if re.findall(r'(l\d*4)', x['人群名字'], re.IGNORECASE)
-                else 'L3' if re.findall(r'(l\d*3)', x['人群名字'], re.IGNORECASE)
-                else 'L2' if re.findall(r'(l\d*2)', x['人群名字'], re.IGNORECASE)
-                else 'L1' if re.findall(r'(l\d*1)', x['人群名字'], re.IGNORECASE)
-                else '', axis=1)
-            # 1. 匹配连续的 4 个数字且后面不能接数字或"元"或汉字，筛掉的人群示例：月均消费6000元｜受众20240729175213｜xxx2024真皮公文包
-            # 2. 匹配 2数字_2数字且前面不能是数字，合法匹配：人群_30_50_促； 非法示例：L345_3040 避免识别出 35～20 岁用户的情况
-            # pattern = r'(\d{4})(?!\d|[\u4e00-\u9fa5])'  # 匹配 4 个数字，后面不能接数字或汉字
-            # pattern = r'(?<![\d\u4e00-\u9fa5])(\d{4})' # 匹配前面不是数字或汉字的 4 个连续数字
-
-            # 匹配 4 个数字，前面和后面都不能是数字或汉字
-            pattern1 = r'(?<![\d\u4e00-\u9fa5])(\d{4})(?!\d|[\u4e00-\u9fa5])'
-            # 匹配指定字符，前面不能是数字或 l 或 L 开头
-            pattern2 = r'(?<![\dlL])(\d{2}_\d{2})'
-            df['用户年龄'] = df.apply(
-                lambda x:
-                ''.join(re.findall(pattern1, x['人群名字'].upper())) if re.findall(pattern1, x['人群名字'])
-                # else ''.join(re.findall(r'[^\d|l|L](\d{2}_\d{2})', x['人群名字'].upper())) if re.findall(r'[^\d|l|L](\d{2}_\d{2})', x['人群名字'])
-                else ''.join(re.findall(pattern2, x['人群名字'].upper())) if re.findall(pattern2, x['人群名字'])
-                else ''.join(re.findall(r'(\d{2}-\d{2})岁', x['人群名字'].upper())) if re.findall(r'(\d{2}-\d{2})岁', x['人群名字'])
-                else '', axis=1)
-            df['用户年龄'] = df['用户年龄'].apply(
-                lambda x: f'{x[:2]}~{x[2:4]}' if str(x).isdigit()
-                else str(x).replace('_', '~') if '_' in x
-                else str(x).replace('-', '~') if '-' in x
-                else x
-            )
-            # 年龄层不能是 0 开头
-            df['用户年龄'] = df['用户年龄'].apply(
-                lambda x: '' if str(x).startswith('0') else x)
-            # df = df.head(1000)
-            # df.to_csv('/Users/xigua/Downloads/test.csv', index=False, header=True, encoding='utf-8_sig')
-            # breakpoint()
-
-            # 下面是添加人群 AIPL 分类
-            dir_file = f'\\\\192.168.1.198\\时尚事业部\\01.运营部\\0-电商周报-每周五更新\\分类配置文件.xlsx'
-            dir_file2 = '/Volumes/时尚事业部/01.运营部/0-电商周报-每周五更新/分类配置文件.xlsx'
-            if platform.system() == 'Windows':
-                dir_file3 = 'C:\\同步空间\\BaiduSyncdisk\\原始文件2\\分类配置文件.xlsx'
-            else:
-                dir_file3 = '/Users/xigua/数据中心/原始文件2/分类配置文件.xlsx'
-            if not os.path.isfile(dir_file):
-                dir_file = dir_file2
-            if not os.path.isfile(dir_file):
-                dir_file = dir_file3
-            if os.path.isfile(dir_file):
-                df_fl = pd.read_excel(dir_file, sheet_name='人群分类', header=0)
-                df_fl = df_fl[['人群名字', '人群分类']]
-                # 合并并获取分类信息
-                df = pd.merge(df, df_fl, left_on=['人群名字'], right_on=['人群名字'], how='left')
-                df['人群分类'].fillna('', inplace=True)
-            if '人群分类' in df.columns.tolist():
-                # 这行决定了，从文件中读取的分类信息优先级高于内部函数的分类规则
-                # 这个 lambda 适配人群名字中带有特定标识的分类，强匹配
-                df['人群分类'] = df.apply(
-                    lambda x: self.set_crowd(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
-                    else x['人群分类'], axis=1
-                )
-                # 这个 lambda 适配人群名字中聚类的特征字符，弱匹配
-                df['人群分类'] = df.apply(
-                    lambda x: self.set_crowd2(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
-                    else x['人群分类'], axis=1
-                )
-            else:
-                df['人群分类'] = df['人群名字'].apply(lambda x: self.set_crowd(keyword=str(x), as_file=False))
-                df['人群分类'] = df.apply(
-                    lambda x: self.set_crowd2(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
-                    else x['人群分类'], axis=1
-                )
-            df['人群分类'] = df['人群分类'].apply(lambda x: str(x).upper() if x else x)
-            # df.to_csv('/Users/xigua/Downloads/test_人群分类.csv', index=False, header=True, encoding='utf-8_sig')
-            # breakpoint()
-            return df
-        elif '天猫_关键词报表' in table_name:
-            df.rename(columns={
-                '场景名字': '营销场景',
-                '宝贝id': '商品id',
-                '总购物车数': '加购量',
-                '总成交笔数': '成交笔数',
-                '总成交金额': '成交金额'
-            }, inplace=True)
-            df.fillna(0, inplace=True)
-            df = df.astype({
-                '商品id': str,
-                '花费': float,
-                '展现量': int,
-                '点击量': int,
-                '加购量': int,
-                '成交笔数': int,
-                '成交金额': float,
-                '直接成交笔数': int,
-                '直接成交金额': float,
-            }, errors='raise')
-            if is_maximize:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '词类型', '词名字_词包名字', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{'加购量': ('加购量', np.max),
-                       '成交笔数': ('成交笔数', np.max),
-                       '成交金额': ('成交金额', np.max),
-                       '直接成交笔数': ('直接成交笔数', np.max),
-                       '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            else:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '商品id', '词类型', '词名字_词包名字', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{
-                        '加购量': ('加购量', np.min),
-                        '成交笔数': ('成交笔数', np.min),
-                        '成交金额': ('成交金额', np.min),
-                        '直接成交笔数': ('直接成交笔数', np.max),
-                        '直接成交金额': ('直接成交金额', np.max)
-                       }
-                )
-            df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
-            df['是否品牌词'] = df['词名字_词包名字'].str.contains('万里马|wanlima', regex=True)
-            df['是否品牌词'] = df['是否品牌词'].apply(lambda x: '品牌词' if x else '')
-            dir_file = f'\\\\192.168.1.198\\时尚事业部\\01.运营部\\0-电商周报-每周五更新\\分类配置文件.xlsx'
-            dir_file2 = '/Volumes/时尚事业部/01.运营部/0-电商周报-每周五更新/分类配置文件.xlsx'
-            if not os.path.isfile(dir_file):
-                dir_file = dir_file2
-            if os.path.isfile(dir_file):
-                df_fl = pd.read_excel(dir_file, sheet_name='关键词分类', header=0)
-                # df_fl.rename(columns={'分类1': '词分类'}, inplace=True)
-                df_fl = df_fl[['关键词', '词分类']]
-                # 合并并获取词分类信息
-                df = pd.merge(df, df_fl, left_on=['词名字_词包名字'], right_on=['关键词'], how='left')
-                df.pop('关键词')
-                df['词分类'].fillna('', inplace=True)
-            if '词分类' in df.columns.tolist():
-                # 这行决定了，从文件中读取的词分类信息优先级高于 ret_keyword 函数的词分类
-                df['词分类'] = df.apply(
-                    lambda x: self.ret_keyword(keyword=str(x['词名字_词包名字']), as_file=False) if x['词分类'] == ''
-                    else x['词分类'], axis=1
-                )
-            else:
-                df['词分类'] = df['词名字_词包名字'].apply(lambda x: self.ret_keyword(keyword=str(x), as_file=False))
-            # df.to_csv('/Users/xigua/Downloads/test.csv', index=False, header=True, encoding='utf-8_sig')
-            # breakpoint()
-            return df
-        elif '天猫_超级直播' in table_name:
-            df.rename(columns={
-                '观看次数': '观看次数',
-                '总购物车数': '加购量',
-                '总成交笔数': '成交笔数',
-                '总成交金额': '成交金额',
-                '场景名字': '营销场景',
-            }, inplace=True)
-            df['营销场景'] = '超级直播'
-            df.fillna(0, inplace=True)
-            df = df.astype({
-                '花费': float,
-                # '点击量': int,
-                '加购量': int,
-                '成交笔数': int,
-                '成交金额': float,
-                '进店量': int,
-                '粉丝关注量': int,
-                '观看次数': int,
-            }, errors='raise')
-            if is_maximize:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '人群名字', '计划名字', '花费', '观看次数', '展现量'],
-                                as_index=False).agg(
-                    **{
-                        '进店量': ('进店量', np.max),
-                        '粉丝关注量': ('粉丝关注量', np.max),
-                        '加购量': ('加购量', np.max),
-                        '成交笔数': ('成交笔数', np.max),
-                        '成交金额': ('成交金额', np.max),
-                        '直接成交笔数': ('直接成交笔数', np.max),
-                        '直接成交金额': ('直接成交金额', np.max),
-                       }
-                )
-            else:
-                df = df.groupby(['日期', '店铺名称', '营销场景', '人群名字', '计划名字', '花费', '观看次数', '展现量'],
-                                as_index=False).agg(
-                    **{
-                        '进店量': ('进店量', np.min),
-                        '粉丝关注量': ('粉丝关注量', np.min),
-                        '加购量': ('加购量', np.min),
-                        '成交笔数': ('成交笔数', np.min),
-                        '成交金额': ('成交金额', np.min),
-                        '直接成交笔数': ('直接成交笔数', np.min),
-                        '直接成交金额': ('直接成交金额', np.min),
-                    }
-                )
-            df.insert(loc=1, column='推广渠道', value='万相台无界版')  # df中插入新列
-            # df.insert(loc=2, column='营销场景', value='超级直播')  # df中插入新列
-            # df = df.loc[df['日期'].between(start_day, today)]
-            df_new = df.groupby(['日期', '店铺名称', '推广渠道', '营销场景'], as_index=False).agg(
-                **{
-                    '花费': ('花费', np.sum),
-                    '展现量': ('展现量', np.sum),
-                    '观看次数': ('观看次数', np.sum),
-                    '加购量': ('加购量', np.sum),
-                    '成交笔数': ('成交笔数', np.sum),
-                    '成交金额': ('成交金额', np.sum),
-                    '直接成交笔数': ('直接成交笔数', np.sum),
-                    '直接成交金额': ('直接成交金额', np.sum),
-                }
-            )
-            self.data_tgyj.update(
-                {
-                    table_name: df_new,
-                }
-            )
-            return df
-        elif '天猫_品销宝账户报表' in table_name:
-            df = df[df['报表类型'] == '账户']
-            df.fillna(value=0, inplace=True)
-            df.rename(columns={
-                '消耗': '花费',
-                '宝贝加购数': '加购量',
-                '搜索量': '品牌搜索量',
-                '搜索访客数': '品牌搜索人数'
-            }, inplace=True)
-            df = df.astype({
-                '花费': float,
-                '展现量': int,
-                '点击量': int,
-                '加购量': int,
-                '成交笔数': int,
-                '成交金额': float,
-                '品牌搜索量': int,
-                '品牌搜索人数': int,
-            }, errors='raise')
-            if is_maximize:
-                df = df.groupby(['日期', '店铺名称', '报表类型', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{
-                        '加购量': ('加购量', np.max),
-                        '成交笔数': ('成交笔数', np.max),
-                        '成交金额': ('成交金额', np.max),
-                        '品牌搜索量': ('品牌搜索量', np.max),
-                        '品牌搜索人数': ('品牌搜索人数', np.max),
-                       }
-                )
-            else:
-                df = df.groupby(['日期', '店铺名称', '报表类型', '花费', '展现量', '点击量'], as_index=False).agg(
-                    **{
-                        '加购量': ('加购量', np.min),
-                        '成交笔数': ('成交笔数', np.min),
-                        '成交金额': ('成交金额', np.min),
-                        '品牌搜索量': ('品牌搜索量', np.min),
-                        '品牌搜索人数': ('品牌搜索人数', np.min),
-                       }
-                )
-            df.insert(loc=1, column='推广渠道', value='品销宝')  # df中插入新列
-            df.insert(loc=2, column='营销场景', value='品销宝')  # df中插入新列
-            df_new = df.groupby(['日期', '店铺名称', '推广渠道', '营销场景'], as_index=False).agg(
-                **{
-                    '花费': ('花费', np.sum),
-                    '展现量': ('展现量', np.sum),
-                    '点击量': ('点击量', np.sum),
-                    '加购量': ('加购量', np.sum),
-                    '成交笔数': ('成交笔数', np.sum),
-                    '成交金额': ('成交金额', np.sum)
-                }
-            )
-            self.data_tgyj.update(
-                {
-                    table_name: df_new,
-                }
-            )
-            return df
-        elif '宝贝指标' in table_name:
-            """ 聚合时不可以加商家编码，编码有些是空白，有些是 0 """
-            df['宝贝id'] = df['宝贝id'].astype(str)
-            df.fillna(0, inplace=True)
-            # df = df[(df['销售额'] != 0) | (df['退款额'] != 0)]  # 注释掉, 因为后续使用生意经作为基准合并推广表，需确保所有商品id 齐全
-            df = df.groupby(['日期', '店铺名称', '宝贝id', '行业类目'], as_index=False).agg(
-                **{'销售额': ('销售额', np.min),
-                   '销售量': ('销售量', np.min),
-                   '订单数': ('订单数', np.min),
-                   '退货量': ('退货量', np.max),
-                   '退款额': ('退款额', np.max),
-                   '退款额_发货后': ('退款额_发货后', np.max),
-                   '退货量_发货后': ('退货量_发货后', np.max),
-                   }
-            )
-            df['件均价'] = df.apply(lambda x: x['销售额'] / x['销售量'] if x['销售量'] > 0 else 0, axis=1).round(
-                0)  # 两列运算, 避免除以0
-            df['价格带'] = df['件均价'].apply(
-                lambda x: '2000+' if x >= 2000
-                else '1000+' if x >= 1000
-                else '500+' if x >= 500
-                else '300+' if x >= 300
-                else '300以下'
-            )
-            self.data_tgyj.update(
-                {
-                    table_name: df[['日期', '店铺名称', '宝贝id', '销售额', '销售量', '退款额_发货后', '退货量_发货后']],
-                }
-            )
-            return df
-        elif '店铺流量来源构成' in table_name:
-            # 包含三级来源名称和预设索引值列
-            # 截取 从上月1日 至 今天的花费数据, 推广款式按此数据从高到低排序（商品图+排序）
-            df_visitor3 = df.groupby(['日期', '三级来源'], as_index=False).agg({'访客数': 'sum'})
-            df_visitor3 = df_visitor3[~df_visitor3['三级来源'].isin([''])]  # 指定列中删除包含空值的行
-            # df_visitor = df_visitor[(df_visitor['日期'] >= f'{year_my}-{last_month.month}-01')]
-            df_visitor3 = df_visitor3.groupby(['三级来源'], as_index=False).agg({'访客数': 'sum'})
-            df_visitor3.sort_values('访客数', ascending=False, ignore_index=True, inplace=True)
-            df_visitor3.reset_index(inplace=True)
-            df_visitor3['index'] = df_visitor3['index'] + 100
-            df_visitor3.rename(columns={'index': '三级访客索引'}, inplace=True)
-            df_visitor3 = df_visitor3[['三级来源', '三级访客索引']]
-
-            # 包含二级来源名称和预设索引值列
-            df_visitor2 = df.groupby(['日期', '二级来源'], as_index=False).agg({'访客数': 'sum'})
-            df_visitor2 = df_visitor2[~df_visitor2['二级来源'].isin([''])]  # 指定列中删除包含空值的行
-            # df_visitor2 = df_visitor2[(df_visitor2['日期'] >= f'{year_my}-{last_month.month}-01')]
-            df_visitor2 = df_visitor2.groupby(['二级来源'], as_index=False).agg({'访客数': 'sum'})
-            df_visitor2.sort_values('访客数', ascending=False, ignore_index=True, inplace=True)
-            df_visitor2.reset_index(inplace=True)
-            df_visitor2['index'] = df_visitor2['index'] + 100
-            df_visitor2.rename(columns={'index': '二级访客索引'}, inplace=True)
-            df_visitor2 = df_visitor2[['二级来源', '二级访客索引']]
-
-            df = pd.merge(df, df_visitor2, how='left', left_on='二级来源', right_on='二级来源')
-            df = pd.merge(df, df_visitor3, how='left', left_on='三级来源', right_on='三级来源')
-            return df
-        elif '商品id编码表' in table_name:
-            df['宝贝id'] = df['宝贝id'].astype(str)
-            df.drop_duplicates(subset='宝贝id', keep='last', inplace=True, ignore_index=True)
-            # df['行业类目'] = df['行业类目'].apply(lambda x: re.sub(' ', '', x))
-            try:
-                df[['一级类目', '二级类目', '三级类目']] = df['行业类目'].str.split(' -> ', expand=True).loc[:, 0:2]
-            except:
-                try:
-                    df[['一级类目', '二级类目']] = df['行业类目'].str.split(' -> ', expand=True).loc[:, 0:1]
-                except:
-                    df['一级类目'] = df['行业类目']
-            df.drop('行业类目', axis=1, inplace=True)
-            df.sort_values('宝贝id', ascending=False, inplace=True)
-            df = df[(df['宝贝id'] != '973') & (df['宝贝id'] != '973')]
-            self.data_tgyj.update(
-                {
-                    table_name: df[['宝贝id', '商家编码']],
-                }
-            )
-            return df
-        elif '商品id图片对照表' in table_name:
-            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 降序排列
-            self.data_tgyj.update(
-                {
-                    table_name: df[['商品id', '商品图片']],
-                }
-            )
-            df['商品id'] = df['商品id'].astype(str)
-            return df
-        elif '商品成本' in table_name:
-            df.sort_values(by=['款号', '日期'], ascending=[False, True], ignore_index=True, inplace=True)
-            df.drop_duplicates(subset=['款号'], keep='last', inplace=True, ignore_index=True)
-            self.data_tgyj.update(
-                {
-                    table_name: df[['款号', '成本价']],
-                }
-            )
-            return df
-        elif '京东_京准通' in table_name and '全站营销' not in table_name:
-            df = df.groupby(['日期', '店铺名称', '产品线', '触发sku_id', '跟单sku_id', 'spu_id', '花费', '展现数', '点击数'], as_index=False).agg(
-                **{'直接订单行': ('直接订单行', np.max),
-                   '直接订单金额': ('直接订单金额', np.max),
-                   '总订单行': ('总订单行', np.max),
-                   '总订单金额': ('总订单金额', np.max),
-                   '直接加购数': ('直接加购数', np.max),
-                   '总加购数': ('总加购数', np.max),
-                   }
-            )
-            df = df[df['花费'] > 0]
-            self.data_jdtg.update(
-                {
-                    table_name: df[['日期', '产品线', '触发sku_id', '跟单sku_id', '花费']],
-                }
-            )
-            return df
-        elif '京东_京准通_全站营销' in table_name:
-            df = df.groupby(['日期', '产品线', '花费'], as_index=False).agg(
-                **{'全站投产比': ('全站投产比', np.max),
-                   '全站交易额': ('全站交易额', np.max),
-                   '全站订单行': ('全站订单行', np.max),
-                   '全站订单成本': ('全站订单成本', np.max),
-                   '全站费比': ('全站费比', np.max),
-                   '核心位置展现量': ('核心位置展现量', np.max),
-                   '核心位置点击量': ('核心位置点击量', np.max),
-                   }
-            )
-            df = df[df['花费'] > 0]
-            return df
-        elif '京东_sku_商品明细' in table_name:
-            df = df[df['商品id'] != '合计']
-            df = df.groupby(['日期', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数'],
-                            as_index=False).agg(
-                **{
-                    '成交单量': ('成交单量', np.max),
-                    '成交金额': ('成交金额', np.max),
-                   }
-            )
-            self.data_jdtg.update(
-                {
-                    table_name: df,
-                }
-            )
-            return df
-        elif '京东_spu_商品明细' in table_name:
-            df = df[df['商品id'] != '合计']
-            df = df.groupby(['日期', '商品id', '货号', '访客数', '成交客户数', '加购商品件数', '加购人数'],
-                            as_index=False).agg(
-                **{
-                    '成交单量': ('成交单量', np.max),
-                    '成交金额': ('成交金额', np.max),
-                   }
-            )
-            self.data_jdtg.update(
-                {
-                    table_name: df,
-                }
-            )
-            return df
-        elif '京东_关键词报表' in table_name:
-            df_lin = df[['计划id', '推广计划']]
-            df_lin.drop_duplicates(subset=['计划id'], keep='last', inplace=True, ignore_index=True)
-            df = df.groupby(['日期', '产品线', '计划类型', '计划id', '搜索词', '关键词', '关键词购买类型', '广告定向类型', '展现数', '点击数', '花费'],
-                            as_index=False).agg(
-                **{
-                    '直接订单行': ('直接订单行', np.max),
-                    '直接订单金额': ('直接订单金额', np.max),
-                    '总订单行': ('总订单行', np.max),
-                    '总订单金额': ('总订单金额', np.max),
-                    '总加购数': ('总加购数', np.max),
-                    '领券数': ('领券数', np.max),
-                    '商品关注数': ('商品关注数', np.max),
-                    '店铺关注数': ('店铺关注数', np.max)
-                }
-            )
-            df = pd.merge(df, df_lin, how='left', left_on='计划id', right_on='计划id')
-            df['k_是否品牌词'] = df['关键词'].str.contains('万里马|wanlima', regex=True)
-            df['k_是否品牌词'] = df['k_是否品牌词'].apply(lambda x: '品牌词' if x else '')
-            df['s_是否品牌词'] = df['搜索词'].str.contains('万里马|wanlima', regex=True)
-            df['s_是否品牌词'] = df['s_是否品牌词'].apply(lambda x: '品牌词' if x else '')
-            return df
-        elif '天猫店铺来源_手淘搜索' in table_name:
-            df = df.groupby(
-                ['日期', '店铺名称', '词类型', '搜索词'],
-                as_index=False).agg(
-                **{
-                    '访客数': ('访客数', np.max),
-                    '加购人数': ('加购人数', np.max),
-                    '支付金额': ('支付金额', np.max),
-                    '支付转化率': ('支付转化率', np.max),
-                    '支付买家数': ('支付买家数', np.max),
-                    '客单价': ('客单价', np.max),
-                    'uv价值': ('uv价值', np.max)
-                }
-            )
-            return df
-        elif '生意参谋_直播场次分析' in table_name:
-            df.drop_duplicates(subset=['场次id'], keep='first', inplace=True, ignore_index=True)
-            return df
-        elif '多店推广场景_按日聚合' in table_name:
-            df['日期'] = pd.to_datetime(df['日期'], format='%Y-%m-%d', errors='ignore')  # 转换日期列
-            df = df.groupby(
-                ['日期', '店铺名称', '营销场景'],
-                as_index=False).agg(
-                **{
-                    '花费': ('花费', np.sum),
-                    '展现量': ('展现量', np.sum),
-                    '点击量': ('点击量', np.sum),
-                    '加购量': ('加购量', np.sum),
-                    '成交笔数': ('成交笔数', np.sum),
-                    '成交金额': ('成交金额', np.sum)
-                }
-            )
-            df.sort_values(['日期', '店铺名称', '花费'], ascending=[False, False, False], ignore_index=True, inplace=True)
-            # df.to_csv('/Users/xigua/Downloads/test.csv', encoding='utf-8_sig', index=False, header=True)
-            return df
-        elif '达摩盘_人群报表' in table_name:
-            return df
-
-        else:
-            print(f'<{table_name}>: Groupby 类尚未配置，数据为空')
-            return pd.DataFrame({})
+        set_typ = {
+            '店铺名称': 'varchar(100)',
+            '日期': 'date',
+            '人群id': 'bigint',
+            '人群名称': 'varchar(255)',
+            '营销渠道': 'varchar(100)',
+            '计划基础信息': 'varchar(255)',
+            '推广单元信息': 'varchar(255)',
+            '消耗_元': 'decimal(10,2)',
+            '展现人数': 'int',
+            '展现量': 'int',
+            '点击人数': 'int',
+            '点击量': 'int',
+            '店铺收藏人数': 'smallint',
+            '店铺收藏量': 'smallint',
+            '加购人数': 'smallint',
+            '加购量': 'smallint',
+            '宝贝收藏人数': 'smallint',
+            '宝贝收藏量': 'smallint',
+            '收藏加购量': 'smallint',
+            '收藏加购人数': 'smallint',
+            '拍下人数': 'smallint',
+            '拍下订单量': 'smallint',
+            '拍下订单金额_元': 'decimal(10,2)',
+            '成交人数': 'smallint',
+            '成交订单量': 'smallint',
+            '成交订单金额_元': 'decimal(10,2)',
+            '店铺首购人数': 'smallint',
+            '店铺复购人数': 'smallint',
+            '点击率': 'decimal(10,4)',
+            'uv点击率': 'decimal(10, 4)',
+            '收藏加购率': 'decimal(10, 4)',
+            'uv收藏加购率': 'decimal(10, 4)',
+            '点击转化率': 'decimal(10, 4)',
+            'uv点击转化率': 'decimal(10, 4)',
+            '投资回报率': 'decimal(10, 4)',
+            '千次展现成本_元': 'decimal(10, 2)',
+            '点击成本_元': 'decimal(10, 2)',
+            'uv点击成本_元': 'decimal(10, 2)',
+            '收藏加购成本_元': 'decimal(10, 2)',
+            'uv收藏加购成本_元': 'decimal(10, 2)',
+            '更新时间': 'timestamp',
+            '人群规模': 'int',
+            '用户年龄': 'varchar(100)',
+            '消费能力等级': 'varchar(100)',
+            '用户性别': 'varchar(100)',
+        }
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     @try_except
     def ret_keyword(self, keyword, as_file=False):
@@ -1876,33 +2385,77 @@ class GroupBy:
         return result
 
     # @try_except
-    def performance(self, bb_tg=True):
-         # print(self.data_tgyj)
-        tg, syj, idbm, pic, cost = (
-            self.data_tgyj['天猫_主体报表'],
-            self.data_tgyj['生意经_宝贝指标'],
-            self.data_tgyj['商品id编码表'],
-            self.data_tgyj['商品id图片对照表'],
-            self.data_tgyj['商品成本'])  # 这里不要加逗号
-        pic['商品id'] = pic['商品id'].astype(str)
-        df = pd.merge(idbm, pic, how='left', left_on='宝贝id', right_on='商品id')  # id 编码表合并图片表
-        df = df[['宝贝id', '商家编码', '商品图片']]
-        df = pd.merge(df, cost, how='left', left_on='商家编码', right_on='款号')  # df 合并商品成本表
-        df = df[['宝贝id', '商家编码', '商品图片', '成本价']]
-        df = pd.merge(tg, df, how='left', left_on='商品id', right_on='宝贝id')  # 推广表合并 df
-        df.drop(labels='宝贝id', axis=1, inplace=True)
+    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]
+
+        # pic['商品id'] = pic['商品id'].astype(str)
+        # # 1.  id 编码表合并图片表
+        # df = pd.merge(idbm, pic, how='left', left_on='宝贝id', right_on='商品id')
+        # df = df[['宝贝id', '商家编码', '商品图片']]
+        # # 2.  df 合并商品成本表
+        # df = pd.merge(df, cost, how='left', left_on='商家编码', right_on='款号')
+        # df = df[['宝贝id', '商家编码', '商品图片', '成本价']]
+        # # 3.  推广表合并 df
+        # df = pd.merge(tg, df, how='left', left_on='商品id', right_on='宝贝id')
+        # df.drop(labels='宝贝id', axis=1, inplace=True)
+
+        # 由于推广表之前根据场景、营销渠道等聚合的，这里不含这些字段所以要进一步聚合
+        tg = tg.groupby(
+            ['日期', '店铺名称', '商品id'],
+            as_index=False).agg(
+            **{
+                '花费': ('花费', np.sum),
+                '成交金额': ('成交金额', np.sum),
+                '直接成交金额': ('直接成交金额', np.sum),
+            }
+        )
+        syj.to_csv('/Users/xigua/Downloads/ddd.csv', index=False, header=True, encoding='utf-8_sig')
+        # 4.  生意经，推广表聚合
         if bb_tg is True:
             # 生意经合并推广表，完整的数据表，包含全店所有推广、销售数据
-            df = pd.merge(syj, df, how='left', left_on=['日期', '店铺名称', '宝贝id'], right_on=['日期', '店铺名称', '商品id'])
+            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)
-            # df.to_csv('/Users/xigua/Downloads/test.csv', encoding='utf-8_sig', index=False, header=True)
         else:
             # 推广表合并生意经 , 以推广数据为基准，销售数据不齐全
-            df = pd.merge(df, syj, how='left', left_on=['日期', '店铺名称', '商品id'], right_on=['日期', '店铺名称', '宝贝id'])
+            df = pd.merge(tg, syj, 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['商品id'] = df['商品id'].astype(int)
+        df = df.groupby(
+            ['日期', '店铺名称', '商品id'],
+            as_index=False).agg(
+            **{
+                '花费': ('花费', np.sum),
+                '成交金额': ('成交金额', np.sum),
+                '直接成交金额': ('直接成交金额', np.sum),
+                '销售额': ('销售额', np.sum),
+                '销售量': ('销售量', np.sum),
+                '退款额_发货后': ('退款额_发货后', np.sum),
+                '退货量_发货后': ('退货量_发货后', np.sum),
+            }
+        )
+        # print(df.info())
+
+        idbm['宝贝id'] = idbm['宝贝id'].astype(int)
+        # 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', '商家编码', '商品图片', '成本价']]
+        # print(df_cb.info())
+        # 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')
@@ -1910,11 +2463,74 @@ class GroupBy:
         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)
-        return df
+        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()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
+
+    # @try_except
+    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]
+        pxb = [item['数据主体'] for item in self.pf_datas if item['集合名称'] == '天猫_品销宝账户报表'][0]
+        zb = zb.groupby(['日期', '店铺名称', '推广渠道', '营销场景'], as_index=False).agg(
+            **{
+                '花费': ('花费', np.sum),
+                '展现量': ('展现量', np.sum),
+                '观看次数': ('观看次数', np.sum),
+                '加购量': ('加购量', np.sum),
+                '成交笔数': ('成交笔数', np.sum),
+                '成交金额': ('成交金额', np.sum),
+                '直接成交笔数': ('直接成交笔数', np.sum),
+                '直接成交金额': ('直接成交金额', np.sum),
+            }
+        )
+        pxb = pxb.groupby(['日期', '店铺名称', '推广渠道', '营销场景'], as_index=False).agg(
+            **{
+                '花费': ('花费', np.sum),
+                '展现量': ('展现量', np.sum),
+                '点击量': ('点击量', np.sum),
+                '加购量': ('加购量', np.sum),
+                '成交笔数': ('成交笔数', np.sum),
+                '成交金额': ('成交金额', np.sum)
+            }
+        )
 
-    @try_except
-    def performance_concat(self, bb_tg=True):
-        tg,  zb, pxb = self.data_tgyj['天猫汇总表调用'], self.data_tgyj['天猫_超级直播'], self.data_tgyj['天猫_品销宝账户报表']
         zb.rename(columns={
             '观看次数': '点击量',
         }, inplace=True)
@@ -1959,23 +2575,61 @@ class GroupBy:
                 '自然流量曝光量': int,
         }
         )
-        return df
+        set_typ = {
+            '日期': 'date',
+            '店铺名称': 'varchar(100)',
+            '推广渠道': 'varchar(100)',
+            '营销场景': 'varchar(100)',
+            '商品id': 'bigint',
+            '花费': 'decimal(12,2)',
+            '展现量': 'int',
+            '点击量': 'int',
+            '加购量': 'int',
+            '成交笔数': 'int',
+            '成交金额': 'decimal(12,2)',
+            '直接成交笔数': 'int',
+            '直接成交金额': 'decimal(12,2)',
+            '自然流量曝光量': 'int',
+        }
+        if not self.update_service:
+            return
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
     # @try_except
-    def performance_jd(self, jd_tg=True):
-        jdtg, sku_sales = self.data_jdtg['京东_京准通'], self.data_jdtg['京东_sku_商品明细']
+    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.groupby(['日期', '跟单sku_id'],
                         as_index=False).agg(
             **{
                 '花费': ('花费', np.sum)
             }
         )
-        cost = self.data_tgyj['商品成本']
         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 合并推广表
@@ -1994,89 +2648,40 @@ class GroupBy:
         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)
-        return df
-
-    def as_csv(self, df, filename, path=None, encoding='utf-8_sig',
-               index=False, header=True, st_ascend=None, ascend=None, freq=None):
-        """
-        path: 默认导出目录 self.output, 这个函数的 path 作为子文件夹，可以不传，
-        st_ascend: 排序参数 ['column1', 'column2']
-        ascend: 升降序 [True, False]
-        freq: 将创建子文件夹并按月分类存储,  freq='Y', 或 freq='M'
-        """
-        if len(df) == 0:
-            return
-        if not path:
-            path = self.output
-        else:
-            path = os.path.join(self.output, path)
-        if not os.path.exists(path):
-            os.makedirs(path)
-        if filename.endswith('.csv'):
-            filename = filename[:-4]
-        if st_ascend and ascend:
-            try:
-                df.sort_values(st_ascend, ascending=ascend, ignore_index=True, inplace=True)
-            except:
-                print(f'{filename}: sort_values排序参数错误！')
-        if freq:
-            if '日期' not in df.columns.tolist():
-                return print(f'{filename}: 数据缺少日期列，无法按日期分组')
-            groups = df.groupby(pd.Grouper(key='日期', freq=freq))
-            for name1, df in groups:
-                if freq == 'M':
-                    sheet_name = name1.strftime('%Y-%m')
-                elif freq == 'Y':
-                    sheet_name = name1.strftime('%Y年')
-                else:
-                    sheet_name = '_未分类'
-                new_path = os.path.join(path, filename)
-                if not os.path.exists(new_path):
-                    os.makedirs(new_path)
-                new_path = os.path.join(new_path, f'{filename}{sheet_name}.csv')
-                if st_ascend and ascend:  # 这里需要重新排序一次，原因未知
-                    try:
-                        df.sort_values(st_ascend, ascending=ascend, ignore_index=True, inplace=True)
-                    except:
-                        print(f'{filename}: sort_values排序参数错误！')
-
-                df.to_csv(new_path, encoding=encoding, index=index, header=header)
-        else:
-            df.to_csv(os.path.join(path, filename + '.csv'), encoding=encoding, index=index, header=header)
-
-    def as_json(self, df, filename, path=None, orient='records', force_ascii=False, st_ascend=None, ascend=None):
-        if len(df) == 0:
-            return
-        if not path:
-            path = self.output
-        else:
-            path = os.path.join(self.output, path)
-        if not os.path.exists(path):
-            os.makedirs(path)
-        if st_ascend and ascend:
-            try:
-                df.sort_values(st_ascend, ascending=ascend, ignore_index=True, inplace=True)
-            except:
-                print(f'{filename}: sort_values排序参数错误！')
-        df.to_json(os.path.join(path, filename + '.json'),
-                   orient=orient, force_ascii=force_ascii)
-
-    def as_excel(self, df, filename, path=None, index=False, header=True, engine='openpyxl',
-                 freeze_panes=(1, 0), st_ascend=None, ascend=None):
-        if len(df) == 0:
+        # print(df.info())
+        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
-        if not path:
-            path = self.output
-        else:
-            path = os.path.join(self.output, path)
-        if not os.path.exists(path):
-            os.makedirs(path)
-        if st_ascend and ascend:
-            try:
-                df.sort_values(st_ascend, ascending=ascend, ignore_index=True, inplace=True)
-            except:
-                print(f'{filename}: sort_values排序参数错误！')
-        df.to_excel(os.path.join(path, filename + '.xlsx'), index=index, header=header, engine=engine, freeze_panes=freeze_panes)
+        min_date = df['日期'].min()
+        max_date = df['日期'].max()
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} 正在更新: 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 函数上传整个表, 不会排重
+            drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
+            filename=None,  # 用来追踪处理进度
+            reset_id=False,  # 是否重置自增列
+            set_typ=set_typ,
+        )
+        return True
 
 
 def date_table():
@@ -2125,253 +2730,6 @@ def date_table():
     )
 
 
-def data_aggregation(months=1, is_juhe=True, less_dict=[]):
-    """
-    1. 从数据库中读取数据
-    2. 数据聚合清洗
-    3. 统一回传数据库: <聚合数据>  （不再导出为文件）
-    公司台式机调用
-    months: 1+，写 0 表示当月数据，但在每月 1 号时可能会因为返回空数据出错
-    is_juhe： 聚合数据
-    less_dict:：只聚合某个特定的库
-    """
-    if months == 0:
-        print(f'months 不建议为 0 ')
-        return
-
-    sdq = MysqlDatasQuery()  # 实例化数据处理类
-    sdq.months = months  # 设置数据周期， 1 表示近 2 个月
-    g = GroupBy()  # 实例化数据聚合类
-    # 实例化数据库连接
-
-    m = mysql.MysqlUpload(username=username, password=password, host=host, port=port)
-
-    # 从数据库中获取数据, 返回包含 df 数据的字典
-    data_dict = [
-        {
-            '数据库名': '聚合数据',  # 清洗完回传的目的地数据库
-            '集合名': '天猫_主体报表',  # 清洗完回传的数据表名
-            '唯一主键': ['日期', '推广渠道', '营销场景', '商品id', '花费'],
-            '数据主体': sdq.tg_wxt(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '生意经_宝贝指标',
-            '唯一主键': ['日期', '宝贝id'],  # 不能加其他字段做主键，比如销售额，是变动的，不是唯一的
-            '数据主体': sdq.syj(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '店铺流量来源构成',
-            '唯一主键': ['日期', '一级来源', '二级来源', '三级来源', '访客数'],
-            '数据主体': sdq.dplyd(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '商品id编码表',
-            '唯一主键': ['宝贝id'],
-            '数据主体': sdq.idbm(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '商品id图片对照表',
-            '唯一主键': ['商品id'],
-            '数据主体': sdq.sp_picture(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '商品成本',  # 暂缺 10.31
-            '唯一主键': ['款号'],
-            '数据主体': sdq.sp_cost(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '京东_京准通',
-            '唯一主键': ['日期', '产品线', '触发sku_id', '跟单sku_id', '花费', ],
-            '数据主体': sdq.jdjzt(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '京东_京准通_全站营销',  # 暂缺
-            '唯一主键': ['日期', '产品线', '花费'],
-            '数据主体': sdq.jdqzyx(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '京东_sku_商品明细',
-            '唯一主键': ['日期', '商品id', '成交单量'],
-            '数据主体': sdq.sku_sales(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '京东_spu_商品明细',
-            '唯一主键': ['日期', '商品id', '成交单量'],
-            '数据主体': sdq.spu_sales(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '天猫_人群报表',
-            '唯一主键': ['日期', '推广渠道', '营销场景', '商品id', '花费', '人群名字'],
-            '数据主体': sdq.tg_rqbb(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '天猫_关键词报表',
-            '唯一主键': ['日期', '推广渠道', '营销场景', '商品id', '花费', '词类型', '词名字_词包名字',],
-            '数据主体': sdq.tg_gjc(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '天猫_超级直播',
-            '唯一主键': ['日期', '推广渠道', '营销场景', '花费'],
-            '数据主体': sdq.tg_cjzb(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '京东_关键词报表',
-            '唯一主键': ['日期', '产品线', '搜索词',  '关键词', '展现数', '花费'],
-            '数据主体': sdq.jd_gjc(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '天猫_品销宝账户报表',
-            '唯一主键': ['日期', '报表类型', '推广渠道', '营销场景', '花费'],
-            '数据主体': sdq.pxb_zh(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '天猫店铺来源_手淘搜索',  # 暂缺
-            '唯一主键': ['日期', '关键词', '访客数'],
-            '数据主体': sdq.se_search(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '生意参谋_直播场次分析',  # 暂缺
-            '唯一主键': ['场次id'],
-            '数据主体': sdq.zb_ccfx(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '多店推广场景_按日聚合',
-            '唯一主键': [],
-            '数据主体': sdq.tg_by_day(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '爱库存_商品spu榜单',
-            '唯一主键': [],
-            '数据主体': sdq.aikucun_bd_spu(),
-        },
-        {
-            '数据库名': '聚合数据',
-            '集合名': '达摩盘_人群报表',
-            '唯一主键': [],
-            '数据主体': sdq.dmp_crowd(),
-        },
-    ]
-
-    if less_dict:
-        data_dict = [item for item in data_dict if item['集合名'] in less_dict]
-    for items in data_dict:  # 遍历返回结果
-        db_name, table_name, unique_key_list, df = items['数据库名'], items['集合名'], items['唯一主键'], items['数据主体']
-        df = g.groupby(df=df, table_name=table_name, is_maximize=True)  # 2. 聚合数据
-        if len(g.sp_index_datas) != 0:
-            # 由推广主体报表，写入一个商品索引表，索引规则：从上月 1 号至今花费从高到低排序
-            m.df_to_mysql(
-                df=g.sp_index_datas,
-                db_name='属性设置3',
-                table_name='商品索引表_主推排序调用',
-                move_insert=False,  # 先删除，再插入
-                # df_sql=True,
-                drop_duplicates=False,
-                icm_update=['商品id'],
-                count=None,
-                filename=None,
-                set_typ={},
-            )
-            g.sp_index_datas = pd.DataFrame()  # 重置，不然下个循环会继续刷入数据库
-        # g.as_csv(df=df, filename=table_name + '.csv')  # 导出 csv
-        if '日期' in df.columns.tolist():
-            m.df_to_mysql(
-                df=df,
-                db_name=db_name,
-                table_name=table_name,
-                move_insert=True,  # 先删除，再插入
-                # df_sql=True,
-                # drop_duplicates=False,
-                # icm_update=unique_key_list,
-                count=None,
-                filename=None,
-                set_typ={},
-            )  # 3. 回传数据库
-        else:  # 没有日期列的就用主键排重
-            m.df_to_mysql(
-                df=df,
-                db_name=db_name,
-                table_name=table_name,
-                move_insert=False,  # 先删除，再插入
-                # df_sql=True,
-                drop_duplicates=False,
-                icm_update=unique_key_list,
-                count=None,
-                filename=None,
-                set_typ={},
-            )  # 3. 回传数据库
-    if is_juhe:
-        res = g.performance(bb_tg=True)   # 盈亏表，依赖其他表，单独做
-        m.df_to_mysql(
-            df=res,
-            db_name='聚合数据',
-            table_name='_全店商品销售',
-            move_insert=True,  # 先删除，再插入
-            # df_sql=True,
-            # drop_duplicates=False,
-            # icm_update=['日期', '商品id'],  # 设置唯一主键
-            count=None,
-            filename=None,
-            set_typ={},
-        )
-        res = g.performance(bb_tg=False)  # 盈亏表，依赖其他表，单独做
-        m.df_to_mysql(
-            df=res,
-            db_name='聚合数据',
-            table_name='_推广商品销售',
-            move_insert=True,  # 先删除，再插入
-            # df_sql=True,
-            # drop_duplicates=False,
-            # icm_update=['日期', '商品id'],  # 设置唯一主键
-            count=None,
-            filename=None,
-            set_typ={},
-        )
-        res = g.performance_concat(bb_tg=False)  # 推广主体合并直播表，依赖其他表，单独做
-        m.df_to_mysql(
-            df=res,
-            db_name='聚合数据',
-            table_name='天猫_推广汇总',
-            move_insert=True,  # 先删除，再插入
-            # df_sql=True,
-            # drop_duplicates=False,
-            # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费', '展现量', '点击量'],  # 设置唯一主键
-            count=None,
-            filename=None,
-            set_typ={},
-        )
-        res = g.performance_jd(jd_tg=False)  # 盈亏表，依赖其他表，单独做
-        m.df_to_mysql(
-            df=res,
-            db_name='聚合数据',
-            table_name='_京东_推广商品销售',
-            move_insert=True,  # 先删除，再插入
-            # df_sql=True,
-            # drop_duplicates=False,
-            # icm_update=['日期', '跟单sku_id', '货号', '花费'],  # 设置唯一主键
-            count=None,
-            filename=None,
-            set_typ={},
-        )
-
-
 def main(days=100, months=3):
     # 1. 更新日期表  更新货品年份基准表， 属性设置 3 - 货品年份基准
     date_table()
@@ -2392,11 +2750,7 @@ def main(days=100, months=3):
     )
 
     # 3. 数据聚合
-    data_aggregation(
-        months=months,
-        is_juhe=True,  # 生成聚合表
-        # less_dict=['天猫_品销宝账户报表'],  # 单独聚合某一个数据库
-    )
+    query_(months=3)
     time.sleep(60)
 
     # 4. 清理聚合数据
@@ -2408,16 +2762,41 @@ def main(days=100, months=3):
     )
 
 
+def query_(months=1, less_dict=[]):
+    if months == 0:
+        print(f'months 不建议为 0 ')
+        return
+    sdq = MysqlDatasQuery()  # 实例化数据处理类
+    sdq.months = months  # 设置数据周期， 1 表示近 2 个月
+    sdq.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
+
+    sdq.tg_wxt(db_name='聚合数据', table_name='天猫_主体报表')
+    sdq.syj(db_name='聚合数据', table_name='生意经_宝贝指标')
+    sdq.idbm(db_name='聚合数据', table_name='商品id编码表')
+    sdq.sp_picture(db_name='聚合数据', table_name='商品id图片对照表')
+    sdq.sp_cost(db_name='聚合数据', table_name='商品成本')
+    sdq.dplyd(db_name='聚合数据', table_name='店铺流量来源构成')
+    sdq.jdjzt(db_name='聚合数据', table_name='京东_京准通')
+    sdq.jdqzyx(db_name='聚合数据', table_name='京东_京准通_全站营销')
+    sdq.sku_sales(db_name='聚合数据', table_name='京东_sku_商品明细')
+    sdq.spu_sales(db_name='聚合数据', table_name='京东_spu_商品明细')
+    sdq.tg_rqbb(db_name='聚合数据', table_name='天猫_人群报表')
+    sdq.tg_gjc(db_name='聚合数据', table_name='天猫_关键词报表')
+    sdq.tg_cjzb(db_name='聚合数据', table_name='天猫_超级直播')
+    sdq.jd_gjc(db_name='聚合数据', table_name='京东_关键词报表')
+    sdq.pxb_zh(db_name='聚合数据', table_name='天猫_品销宝账户报表')
+    sdq.se_search(db_name='聚合数据', table_name='天猫店铺来源_手淘搜索')
+    sdq.zb_ccfx(db_name='聚合数据', table_name='生意参谋_直播场次分析')
+    sdq.tg_by_day(db_name='聚合数据', table_name='多店推广场景_按日聚合')
+    sdq.aikucun_bd_spu(db_name='聚合数据', table_name='爱库存_商品spu榜单')
+    sdq.dmp_crowd(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='天猫_推广汇总')  # _推广商品销售
+
+
 if __name__ == '__main__':
-    # main(days=100, months=3)
-
-    # data_aggregation(
-    #     months=3,
-    #     is_juhe=True,  # 生成聚合表
-    #     # less_dict=['天猫_品销宝账户报表'],  # 单独聚合某一个数据库
-    # )
-    data_aggregation(
-        months=1,
-        is_juhe=True,  # 生成聚合表
-        # less_dict=['天猫_品销宝账户报表'],  # 单独聚合某一个数据库
-    )
+    main(days=100, months=3)
+
+    # query_(months=1)