mdbq 3.2.10__py3-none-any.whl → 3.2.12__py3-none-any.whl

mdbq/aggregation/aggregation.py

@@ -52,6 +52,16 @@ if not username:
     print(f'找不到主机：')
 
 
+def get_encoding(path):
+    """
+    获取文件的编码方式, 读取速度比较慢，非必要不要使用
+    """
+    with open(path, 'rb') as f:
+        f1 = f.read()
+        encod = chardet.detect(f1).get('encoding')
+    return encod
+
+
 class DatabaseUpdateBak:
     """
     清洗文件，并入库，被 tg.py 调用
@@ -1236,20 +1246,22 @@ def one_file_to_mysql(file, db_name, table_name):
     if file.endswith('.xlsx'):
         df = pd.read_excel(file)
     else:
-        df = pd.read_csv(file, encoding='utf-8_sig', header=0, na_filter=False, float_precision='high')
+        encod = get_encoding(file)
+        df = pd.read_csv(file, encoding=encod, header=0, na_filter=False, float_precision='high')
     # df.replace(to_replace=[','], value='', regex=True, inplace=True)  # 替换掉特殊字符
     m = mysql.MysqlUpload(username=username, password=password, host=host, port=port)
+    # df.pop('id')
     m.df_to_mysql(
         df=df,
         db_name=db_name,
         table_name=table_name,
         # icm_update=['sku_id'],  # 增量更新, 在聚合数据中使用，其他不要用
-        move_insert=False,  # 先删除，再插入
+        move_insert=True,  # 先删除，再插入
         df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
         drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
         count=None,
         filename=None,  # 用来追踪处理进度
-        # reset_id=False,  # 是否重置自增列
+        reset_id=True,  # 是否重置自增列
         # set_typ=set_typ,
     )
 
@@ -1312,32 +1324,115 @@ def cut_as_year_month(as_month=False):
                         df.to_csv(os.path.join(root, new_name), encoding='utf-8_sig', index=False, header=True)
 
 
+def doc_to_sql(write_data=False, read_data=False):
+    if not write_data and not read_data:
+        return
+    # filename = '关于做好2024年世界互联网大会乌镇峰会期间寄递渠道安全保障工作的通知.pdf'
+    path = '/Users/xigua/数据中心/微信pdf文件/2024-10'
+
+    if not os.path.isdir(path):
+        print(f'不存在的文件夹: {path}')
+        return
+    m_engine = mysql.MysqlUpload(
+        username=username,
+        password=password,
+        host=host,
+        port=port,
+        charset='utf8mb4'
+    )
+    if write_data:
+        for root, dirs, files in os.walk(path, topdown=False):
+            for name in files:
+                if '~$' in name or '.DS' in name or '.localized' in name or 'baidu' in name:
+                    continue
+                if name.endswith('.pdf') or name.endswith('.pptx'):
+                    file_size = os.stat(os.path.join(root, name)).st_size
+                    if file_size > 1024 * 1024 * 1024:
+                        file_size = file_size / 1024 / 1024 / 1024
+                        file_size = f'{file_size:.2f} GB'
+                    elif file_size > 1024 * 1024:
+                        file_size = file_size / 1024 / 1024
+                        file_size = f'{file_size:.2f} MB'
+                    else:
+                        file_size = file_size / 1024
+                        file_size = f'{file_size:.2f} KB'
+                    mod_time = os.path.getmtime(os.path.join(root, name))
+                    local_time = time.localtime(mod_time)
+                    mod_time_formatted = time.strftime('%Y-%m-%d %H:%M:%S', local_time)
+
+                    # 读取PDF文件为二进制数据
+                    with open(os.path.join(path, name), 'rb') as file:
+                        pdf_data = file.read()
+                    dict_data = {
+                        '日期': datetime.datetime.today().strftime('%Y-%m-%d'),
+                        '数据来源': '微信',
+                        '文件名称': name,
+                        '文件大小': file_size,
+                        '修改时间': mod_time_formatted,
+                        '数据主体': pdf_data,
+                        '扩展名': os.path.splitext(name)[-1],
+                        '更新时间': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    }
+                    set_typ = {
+                        '日期': 'date',
+                        '数据来源': 'varchar(100)',
+                        '文件名称': 'varchar(255)',
+                        '文件大小': 'varchar(20)',
+                        '修改时间': 'timestamp',
+                        '数据主体': 'longblob',
+                        '扩展名': 'varchar(50)',
+                        '更新时间': 'timestamp',
+                    }
+                    m_engine.doc_to_sql(
+                        db_name='pdf文件',
+                        table_name='微信pdf文件',
+                        remove_by_key=['文件名称'],
+                        dict_data=dict_data,
+                        set_typ=set_typ,
+                        allow_not_null=False,
+                        filename=name,
+                        reset_id=True,
+                    )
+    if read_data:
+        filename=''
+        save_path = '/Users/xigua/Downloads'
+        m_engine.read_doc_data(
+            db_name='pdf文件',
+            table_name='微信pdf文件',
+            column='文件名称',
+            filename=filename,
+            save_path=save_path,
+        )
+
 if __name__ == '__main__':
+    doc_to_sql(
+        write_data=True,
+        read_data=False,
+    )
     # cut_as_year_month(as_month=False)
 
     # username = 'root'
     # password = ''
     # host = ''
     # port = ''
-    #
+
     # # 上传 1 个文件到数据库
     # one_file_to_mysql(
-    #     file=r'/Users/xigua/Downloads/城市等级.csv',
-    #     db_name='属性设置3',
-    #     table_name='城市等级',
+    #     file=r'/Users/xigua/Downloads/日期表.csv',
+    #     db_name='聚合数据test',
+    #     table_name='日期表',
     # )
 
 
-    col = 1
-    if col:
-        # 上传一个目录到指定数据库
-        db_name = '爱库存2'
-        table_name = '商品spu榜单'
-        upload_dir(
-            path=r'/Users/xigua/Downloads/数据上传中心',
-            db_name=db_name,
-            collection_name=table_name,
-        )
-
+    # col = 1
+    # if col:
+    #     # 上传一个目录到指定数据库
+    #     db_name = '爱库存2'
+    #     table_name = '商品spu榜单'
+    #     upload_dir(
+    #         path=r'/Users/xigua/Downloads/数据上传中心',
+    #         db_name=db_name,
+    #         collection_name=table_name,
+    #     )
 
 

mdbq/aggregation/query_data.py

@@ -59,6 +59,7 @@ class MysqlDatasQuery:
         self.update_service = True  # 调试时加，true: 将数据写入 mysql 服务器
         self.pf_datas = []
         self.pf_datas_jd = []  # 京东聚合销售表
+        self.output = set_support.SetSupport(dirname='support')
 
     @staticmethod
     def try_except(func):  # 在类内部定义一个异常处理方法
@@ -196,9 +197,8 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
-            
         )
 
         # df_pic：商品排序索引表, 给 powerbi 中的主推款排序用的,(从上月1号到今天的总花费进行排序)
@@ -337,7 +337,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -477,7 +477,7 @@ class MysqlDatasQuery:
             df['人群分类'].fillna('', inplace=True)
         if '人群分类' in df.columns.tolist():
             # 这行决定了，从文件中读取的分类信息优先级高于内部函数的分类规则
-            # 这个 lambda 适配人群名字中带有特定标识的分类，强匹配
+            # 这个 lambda 适配人群名字中带有特定标识的分类，强匹配，自定义命名
             df['人群分类'] = df.apply(
                 lambda x: self.set_crowd(keyword=str(x['人群名字']), as_file=False) if x['人群分类'] == ''
                 else x['人群分类'], axis=1
@@ -527,7 +527,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -663,7 +663,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -787,7 +787,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -900,7 +900,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -957,7 +957,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -1016,7 +1016,6 @@ class MysqlDatasQuery:
             filename=None,  # 用来追踪处理进度
             reset_id=False,  # 是否重置自增列
             set_typ=set_typ,
-            
         )
         return True
 
@@ -1123,7 +1122,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -1172,7 +1171,6 @@ class MysqlDatasQuery:
             filename=None,  # 用来追踪处理进度
             reset_id=False,  # 是否重置自增列
             set_typ=set_typ,
-            
         )
         return True
 
@@ -1276,7 +1274,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -1311,7 +1309,7 @@ class MysqlDatasQuery:
         #     drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
         #     count=None,
         #     filename=None,  # 用来追踪处理进度
-        #     reset_id=False,  # 是否重置自增列
+        #     reset_id=True,  # 是否重置自增列
         #     set_typ=set_typ,
         #
         # )
@@ -1380,7 +1378,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -1482,7 +1480,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -1557,7 +1555,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -1623,7 +1621,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -1707,9 +1705,8 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
-            
         )
         return True
 
@@ -1898,6 +1895,7 @@ class MysqlDatasQuery:
         start_date, end_date = self.months_data(num=self.months)
         projection = {
             '日期': 1,
+            '场景id': 1,
             '场景名字': 1,
             '花费': 1,
             '展现量': 1,
@@ -1921,10 +1919,10 @@ class MysqlDatasQuery:
         if len(df_tm) > 0:
             df_tm.rename(columns={'场景名字': '营销场景'}, inplace=True)
             df_tm = df_tm.groupby(
-                ['日期', '店铺名称', '营销场景', '花费'],
+                ['日期', '店铺名称', '场景id', '营销场景', '花费', '展现量'],
                 as_index=False).agg(
                 **{
-                    '展现量': ('展现量', np.max),
+                    # '展现量': ('展现量', np.max),
                     '点击量': ('点击量', np.max),
                     '加购量': ('总购物车数', np.max),
                     '成交笔数': ('总成交笔数', np.max),
@@ -1945,10 +1943,10 @@ class MysqlDatasQuery:
         if len(df_tb) > 0:
             df_tb.rename(columns={'场景名字': '营销场景'}, inplace=True)
             df_tb = df_tb.groupby(
-                ['日期', '店铺名称', '营销场景', '花费'],
+                ['日期', '店铺名称', '场景id', '营销场景', '花费', '展现量'],
                 as_index=False).agg(
                 **{
-                    '展现量': ('展现量', np.max),
+                    # '展现量': ('展现量', np.max),
                     '点击量': ('点击量', np.max),
                     '加购量': ('总购物车数', np.max),
                     '成交笔数': ('总成交笔数', np.max),
@@ -2207,7 +2205,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -2324,7 +2322,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
 
         )
@@ -2377,7 +2375,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
             
         )
@@ -2490,7 +2488,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -2739,6 +2737,7 @@ class MysqlDatasQuery:
                     '机会',
                     '推荐',
                     '智能定向',
+                    'AI',
                 ]
             },
             {
@@ -2900,7 +2899,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -3010,7 +3009,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -3081,7 +3080,7 @@ class MysqlDatasQuery:
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
             count=None,
             filename=None,  # 用来追踪处理进度
-            reset_id=False,  # 是否重置自增列
+            reset_id=True,  # 是否重置自增列
             set_typ=set_typ,
         )
         return True
@@ -3310,7 +3309,7 @@ if __name__ == '__main__':
     #         future_to_function = {
     #             executor.submit(
     #                 func_query,
-    #                 months=3,
+    #                 months=1,
     #                 less_dict=[],
     #             ),
     #         }

mdbq/mysql/mysql.py

@@ -4,6 +4,7 @@ import platform
 import getpass
 import re
 import time
+from fileinput import filename
 from functools import wraps
 import warnings
 import pymysql
@@ -117,13 +118,203 @@ class MysqlUpload:
                 print(f'{func.__name__}, {e}')  # 将异常信息返回
                 with open(error_file, 'a') as f:
                     now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                    f.write(f'\n{now}\n')
+                    f.write(f'\n{now} \n')
                     # f.write(f'报错的文件:\n{e.__traceback__.tb_frame.f_globals["__file__"]}\n')  # 发生异常所在的文件
                 traceback.print_exc(file=open(error_file, 'a'))  # 返回完整的堆栈信息
                 print(f'更多信息请查看日志文件: {error_file}')
 
         return wrapper
 
+    def cover_doc_dtypes(self, dict_data):
+        """ 清理字典键值 并转换数据类型  """
+        if not dict_data:
+            print(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
+            return
+        __res_dict = {}
+        new_dict_data = {}
+        for k, v in dict_data.items():
+            k = str(k).lower()
+            k = re.sub(r'[()\-，,$&~^、 （）\"\'“”=·/。》《><！!`]', '_', k, re.IGNORECASE)
+            k = k.replace('）', '')
+            k = re.sub(r'_{2,}', '_', k)
+            k = re.sub(r'_+$', '', k)
+            result1 = re.findall(r'编码|_?id|货号|款号|文件大小', k, re.IGNORECASE)
+            result2 = re.findall(r'占比$|投产$|产出$|roi$|率$', k, re.IGNORECASE)
+            result3 = re.findall(r'同比$|环比$', k, re.IGNORECASE)
+            result4 = re.findall(r'花费$|消耗$|金额$', k, re.IGNORECASE)
+
+            date_type = is_valid_date(v)  # 判断日期时间
+            int_num = is_integer(v)  # 判断整数
+            count_int, count_float = count_decimal_places(v)  # 判断小数，返回小数位数
+            if result1:  # 京东sku/spu商品信息
+                __res_dict.update({k: 'varchar(100)'})
+            elif k == '日期':
+                __res_dict.update({k: 'DATE'})
+            elif k == '更新时间':
+                __res_dict.update({k: 'TIMESTAMP'})
+            elif result2:  # 小数
+                __res_dict.update({k: 'decimal(10,4)'})
+            elif date_type == 1:  # 纯日期
+                __res_dict.update({k: 'DATE'})
+            elif date_type == 2:  # 日期+时间
+                __res_dict.update({k: 'DATETIME'})
+            elif int_num:
+                __res_dict.update({k: 'INT'})
+            elif count_float > 0:
+                if count_int + count_float > 10:
+                    # if count_float > 5:
+                    #     v = round(float(v), 4)
+                    if count_float >= 6:
+                        __res_dict.update({k: 'decimal(14,6)'})
+                    else:
+                        __res_dict.update({k: 'decimal(14,4)'})
+                elif count_float >= 6:
+                    __res_dict.update({k: 'decimal(14,6)'})
+                elif count_float >= 4:
+                    __res_dict.update({k: 'decimal(12,4)'})
+                else:
+                    __res_dict.update({k: 'decimal(10,2)'})
+            else:
+                __res_dict.update({k: 'varchar(255)'})
+            new_dict_data.update({k: v})
+        __res_dict.update({'数据主体': 'longblob'})
+        return __res_dict, new_dict_data
+
+    # @try_except
+    def doc_to_sql(self, db_name, table_name, dict_data, set_typ={}, remove_by_key=None, allow_not_null=False, filename=None, reset_id=False):
+        """
+        db_name:
+        table_name:
+        remove_by_key: 设置时先删除数据再插入，不设置则直接添加
+        dict_data:
+        set_typ:
+        allow_not_null:
+        filename:
+        reset_id:
+        """
+        if '数据主体' not in dict_data.keys():
+            print(f'dict_data 中"数据主体"键不能为空')
+            return
+
+        connection = pymysql.connect(**self.config)  # 连接数据库
+        with connection.cursor() as cursor:
+            cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
+            database_exists = cursor.fetchone()
+            if not database_exists:
+                # 如果数据库不存在，则新建
+                if '8.138.27' in str(self.host) or platform.system() == "Linux":  # 阿里云 mysql 低版本不支持 0900
+                    sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_unicode_ci"
+                    self.config.update({'charset': 'utf8mb4_unicode_ci'})
+                if '192.168.1.100' in str(self.host):
+                    sql = f"CREATE DATABASE `{db_name}`"
+                else:
+                    sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
+                cursor.execute(sql)
+                connection.commit()
+                print(f"创建Database: {db_name}")
+
+        self.config.update({'database': db_name})  # 添加更新 config 字段
+        connection = pymysql.connect(**self.config)  # 重新连接数据库
+        with connection.cursor() as cursor:
+            # 1. 查询表, 不存在则创建一个空表
+            sql = "SHOW TABLES LIKE %s;"  # 有特殊字符不需转义
+            cursor.execute(sql, (table_name))
+            if not cursor.fetchone():
+                sql = f"CREATE TABLE IF NOT EXISTS `{table_name}` (id INT AUTO_INCREMENT PRIMARY KEY);"
+                cursor.execute(sql)
+                print(f'创建 mysql 表: {table_name}')
+
+            new_dict = {}
+            [new_dict.update({k: v}) for k, v in dict_data.items() if k != '数据主体']
+            # 清理列名中的非法字符
+            dtypes, new_dict = self.cover_doc_dtypes(new_dict)
+            if set_typ:
+                # 更新自定义的列数据类型
+                for k, v in dtypes.items():
+                    # 确保传进来的 set_typ 键存在于实际的 df 列才 update
+                    [dtypes.update({k: inside_v}) for inside_k, inside_v in set_typ.items() if k == inside_k]
+
+            # 检查列
+            sql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s;"
+            cursor.execute(sql, (db_name, table_name))
+            col_exist = [item['COLUMN_NAME'] for item in cursor.fetchall()]  # 已存在的所有列
+
+            col_not_exist = [col for col in set_typ.keys() if col not in col_exist]  # 不存在的列
+            # 不存在则新建列
+            if col_not_exist:  # 数据表中不存在的列
+                for col in col_not_exist:
+                    #  创建列，需转义
+                    if allow_not_null:
+                        sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {set_typ[col]};"
+                    else:
+                        sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {set_typ[col]} NOT NULL;"
+                    cursor.execute(sql)
+                    print(f"添加列: {col}({set_typ[col]})")  # 添加列并指定数据类型
+
+                    if col == '日期':
+                        sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
+                        print(f"设置为索引: {col}({set_typ[col]})")
+                        cursor.execute(sql)
+            connection.commit()  # 提交事务
+
+            if remove_by_key:
+                # 删除数据
+                se_key = ', '.join(remove_by_key)
+                condition = []
+                for up_col in remove_by_key:
+                    condition += [f'`{up_col}` = "{dict_data[up_col]}"']
+                condition = ' AND '.join(condition)
+                # print(condition)
+                sql = f"SELECT {se_key} FROM `{table_name}` WHERE {condition}"
+                cursor.execute(sql)
+                result = cursor.fetchall()
+                if result:
+                    sql = f'DELETE FROM `{table_name}` WHERE {condition};'
+                    cursor.execute(sql)
+
+            # 插入数据到数据库
+            # 有数据格式错误问题，所以分开处理，将数据主体移到最后面用占位符
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f'{now} 正在更新: mysql ({self.host}:{self.port}) {db_name}/{table_name} -> {filename}')
+            if new_dict:
+                cols = ', '.join(f"`{item}`" for item in new_dict.keys())  # 列名需要转义
+                values = ', '.join([f'"{item}"' for item in new_dict.values()])  # 值要加引号
+                cols = ', '.join([cols, '数据主体'])
+                binary_data = dict_data['数据主体']
+                sql = f"INSERT INTO `{table_name}` ({cols}) VALUES ({values}, %s)"
+                # print(sql)
+                cursor.execute(sql, binary_data)
+            else:
+                sql = f"""INSERT INTO `{table_name}` (数据主体) VALUES (%s);"""
+                cursor.execute(sql, dict_data['数据主体'])
+
+            if reset_id:
+                # 6. 重置自增列
+                try:
+                    # 查询所有复合主键
+                    sql = (
+                        f"SELECT `COLUMN_NAME` AS `PrimaryKey` FROM `information_schema`.`COLUMNS` "
+                        f"WHERE `TABLE_SCHEMA` = '{db_name}'AND `TABLE_NAME` = '{table_name}' AND `COLUMN_KEY` = 'PRI';"
+                    )
+                    cursor.execute(sql)
+                    result = cursor.fetchall()  # 复合主键数
+                    if len(result) <= 1:  # 如果存在复合主键，则不能直接删除 id 键，其他主键可能不是唯一，会报错
+                        cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
+                        result = cursor.fetchone()
+                        if result:
+                            cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
+                        cursor.execute(
+                            f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
+                        cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
+                        # print(f'重置自增id')
+                    else:
+                        print(f'{table_name} 当前表存在复合主键: {result}, 无法重置自增id')
+                except Exception as e:
+                    print(f'{e}')
+                    connection.rollback()
+            connection.commit()
+
+
     @try_except
     def dict_to_mysql(self, db_name, table_name, dict_data, icm_update=None, main_key=None, unique_main_key=None, index_length=100, set_typ=None, allow_not_null=False, cut_data=None):
         """
@@ -188,7 +379,7 @@ class MysqlUpload:
                 print(f'创建 mysql 表: {table_name}')
 
             # 根据 dict_data 的值添加指定的数据类型
-            dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'mediumtext',...}
+            dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'varchar(100)',...}
             if set_typ:
                 # 更新自定义的列数据类型
                 for k, v in dtypes.items():
@@ -398,6 +589,9 @@ class MysqlUpload:
         df.replace(to_replace=['"'], value='', regex=True, inplace=True)
         cols = df.columns.tolist()
         for col in cols:
+            if col == 'id':
+                df.pop('id')
+                continue
             df[col] = df[col].apply(lambda x: float(re.sub(r'%$', '', str(x))) / 100 if (
                     str(x) != '' and str(x).endswith('%')) and not re.findall('[\\u4e00-\\u9fa5]', str(x)) else '0.0' if str(x) == '0%' else x)
             try:
@@ -571,9 +765,9 @@ class MysqlUpload:
             connection.commit()  # 提交事务
 
             if df_sql:
-                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
+                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                 print(
-                    f'{now}正在更新: mysql ({self.host}:{self.port}) {db_name}/{table_name}, {count}, {self.filename}')
+                    f'{now} 正在更新: mysql ({self.host}:{self.port}) {db_name}/{table_name}, {count}, {self.filename}')
                 engine = create_engine(
                     f"mysql+pymysql://{self.username}:{self.password}@{self.host}:{self.port}/{db_name}")  # 创建数据库引擎
                 # df.to_csv('/Users/xigua/Downloads/mysql.csv', index=False, header=True, encoding='utf-8_sig')
@@ -587,18 +781,29 @@ class MysqlUpload:
                 )
                 if reset_id:
                     pass
-                    # # 6. 重置自增列
-                    # try:
-                    #     cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
-                    #     result = cursor.fetchone()
-                    #     if result:
-                    #         cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
-                    #     cursor.execute(
-                    #         f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
-                    #     cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
-                    # except Exception as e:
-                    #     print(f'{e}')
-                    #     connection.rollback()
+                    # 6. 重置自增列
+                    try:
+                        # 查询所有复合主键
+                        sql = (
+                            f"SELECT `COLUMN_NAME` AS `PrimaryKey` FROM `information_schema`.`COLUMNS` "
+                            f"WHERE `TABLE_SCHEMA` = '{db_name}'AND `TABLE_NAME` = '{table_name}' AND `COLUMN_KEY` = 'PRI';"
+                        )
+                        cursor.execute(sql)
+                        result = cursor.fetchall()  # 复合主键数
+                        if len(result) <= 1:  # 如果存在复合主键，则不能直接删除 id 键，其他主键可能不是唯一，会报错
+                            cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
+                            result = cursor.fetchone()
+                            if result:
+                                cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
+                            cursor.execute(
+                                f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
+                            cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
+                            # print(f'重置自增id')
+                        else:
+                            print(f'{table_name} 当前表存在复合主键: {result}, 无法重置自增id')
+                    except Exception as e:
+                        print(f'{e}')
+                        connection.rollback()
                 connection.commit()  # 提交事务
                 connection.close()
                 return
@@ -607,8 +812,11 @@ class MysqlUpload:
             if move_insert and '日期' in df.columns.tolist():
                 # 移除数据
                 dates = df['日期'].values.tolist()
+                # print(dates)
+                dates = [pd.to_datetime(item) for item in dates]  # 需要先转换类型才能用 min, max
                 start_date = pd.to_datetime(min(dates)).strftime('%Y-%m-%d')
                 end_date = (pd.to_datetime(max(dates)) + datetime.timedelta(days=1)).strftime('%Y-%m-%d')
+
                 sql = f"DELETE FROM `{table_name}` WHERE {'日期'} BETWEEN '%s' AND '%s'" % (start_date, end_date)
                 cursor.execute(sql)
                 connection.commit()
@@ -625,18 +833,28 @@ class MysqlUpload:
                 )
                 # 6. 重置自增列
                 if reset_id:
-                    pass
-                    # try:
-                    #     cursor.execute(f"SHOW COLUMNS FROM `{table_name}` LIKE 'id'")
-                    #     result = cursor.fetchone()
-                    #     if result:
-                    #         cursor.execute(f"ALTER TABLE `{table_name}` DROP COLUMN id;")  # 删除 id  列
-                    #     cursor.execute(
-                    #         f"ALTER TABLE `{table_name}` ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
-                    #     cursor.execute(f"ALTER TABLE `{table_name}` AUTO_INCREMENT = 1")  # 设置自增从 1 开始
-                    # except Exception as e:
-                    #     print(f'{e}')
-                    #     connection.rollback()
+                    try:
+                        # 查询所有复合主键
+                        sql = (
+                            f"SELECT `COLUMN_NAME` AS `PrimaryKey` FROM `information_schema`.`COLUMNS` "
+                            f"WHERE `TABLE_SCHEMA` = '{db_name}'AND `TABLE_NAME` = '{table_name}' AND `COLUMN_KEY` = 'PRI';"
+                        )
+                        cursor.execute(sql)
+                        result = cursor.fetchall()  # 复合主键数
+                        if len(result) <= 1:  # 如果存在复合主键，则不能直接删除 id 键，其他主键可能不是唯一，会报错
+                            cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
+                            result = cursor.fetchone()
+                            if result:
+                                cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
+                            cursor.execute(
+                                f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
+                            cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
+                            # print(f'重置自增id')
+                        else:
+                            print(f'{table_name} 当前表存在复合主键: {result}, 无法重置自增id')
+                    except Exception as e:
+                        print(f'{e}')
+                        connection.rollback()
                 connection.close()
                 return
 
@@ -730,22 +948,78 @@ class MysqlUpload:
                     # print(f'mysql -> df_to_mysql 报错: {e}, {self.filename}')
                     # breakpoint()
 
-            # # 6. 重置自增列
-            # try:
-            #     cursor.execute(f"SHOW COLUMNS FROM `{table_name}` LIKE 'id'")
-            #     result = cursor.fetchone()
-            #     if result:
-            #         cursor.execute(f"ALTER TABLE `{table_name}` DROP COLUMN id;")  # 删除 id  列
-            #     cursor.execute(
-            #         f"ALTER TABLE `{table_name}` ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
-            #     cursor.execute(f"ALTER TABLE `{table_name}` AUTO_INCREMENT = 1")  # 设置自增从 1 开始
-            # except Exception as e:
-            #     print(f'{table_name}, -> {e}')
-            #     connection.rollback()
+            # 6. 重置自增列
+            if reset_id:
+                try:
+                    # 查询所有复合主键
+                    sql = (
+                        f"SELECT `COLUMN_NAME` AS `PrimaryKey` FROM `information_schema`.`COLUMNS` "
+                        f"WHERE `TABLE_SCHEMA` = '{db_name}'AND `TABLE_NAME` = '{table_name}' AND `COLUMN_KEY` = 'PRI';"
+                    )
+                    cursor.execute(sql)
+                    result = cursor.fetchall()  # 复合主键数
+                    if len(result) <= 1:  # 如果存在复合主键，则不能直接删除 id 键，其他主键可能不是唯一，会报错
+                        cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
+                        result = cursor.fetchone()
+                        if result:
+                            cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
+                        cursor.execute(
+                            f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
+                        cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
+                        # print(f'重置自增id')
+                    else:
+                        print(f'{table_name} 当前表存在复合主键: {result}, 无法重置自增id')
+                except Exception as e:
+                    print(f'{e}')
+                    connection.rollback()
         connection.commit()  # 提交事务
         connection.close()
 
-    # @try_except
+    @try_except
+    def read_doc_data(self, table_name, db_name='pdf文件', column='文件名', filename=None, save_path='/Users/xigua/Downloads'):
+        """
+        db_name:
+        table_name:
+        column: 读取哪一列
+        filename: 文件名称
+        save_path: 保存位置
+        """
+        if not filename:
+            print(f'未指定文件名: filename')
+            return
+        connection = pymysql.connect(**self.config)  # 连接数据库
+        # try:
+        with connection.cursor() as cursor:
+            cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
+            database_exists = cursor.fetchone()
+            if not database_exists:
+                print(f"Database {db_name} 数据库不存在")
+                return
+        self.config.update({'database': db_name})
+        connection = pymysql.connect(**self.config)  # 重新连接数据库
+        with connection.cursor() as cursor:
+            # 1. 查询表
+            sql = "SHOW TABLES LIKE %s;"  # 有特殊字符不需转义
+            cursor.execute(sql, (table_name))
+            if not cursor.fetchone():
+                print(f'{table_name} -> 数据表不存在')
+                return
+
+            # 读取数据
+            condition = f'`{column}` = "{filename}"'
+            sql = f"SELECT `{column}`, `数据主体` FROM `{table_name}` WHERE {condition}"
+            cursor.execute(sql)
+            results = cursor.fetchall()
+            if results:
+                for result in results:
+                    # 将二进制数据写入到文件
+                    with open(os.path.join(save_path, filename), 'wb') as f:
+                        f.write(result['数据主体'])
+                        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        print(f'{now} 写入本地文件: ({self.host}:{self.port}) {db_name}/{table_name} -> {os.path.join(save_path, filename)}')
+        connection.close()
+
+
     def read_mysql(self, table_name, start_date, end_date, db_name='远程数据源', date_name='日期'):
         """ 读取指定数据表，可指定日期范围，返回结果: df """
         start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
@@ -761,8 +1035,8 @@ class MysqlUpload:
                     print(f"Database {db_name} 数据库不存在")
                     return df
                 else:
-                    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                    print(f'{now}mysql 正在查询表: {table_name}, 范围: {start_date}~{end_date}')
+                    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    print(f'{now} mysql 正在查询表: {table_name}, 范围: {start_date}~{end_date}')
         except:
             return df
         finally:
@@ -789,11 +1063,11 @@ class MysqlUpload:
         if len(df) == 0:
             print(f'database: {db_name}, table: {table_name} 查询的数据为空')
         else:
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             cost_time = int(time.time() - before_time)
             if cost_time < 1:
                 cost_time = round(time.time() - before_time, 2)
-            print(f'{now}mysql ({self.host}) 表: {table_name} 获取数据长度: {len(df)}, 用时: {cost_time} 秒')
+            print(f'{now} mysql ({self.host}) 表: {table_name} 获取数据长度: {len(df)}, 用时: {cost_time} 秒')
         return df
 
     def upload_pandas(self, update_path, db_name, days=None):
@@ -821,8 +1095,8 @@ class MysqlUpload:
                         if name.endswith('.csv') and 'baidu' not in name:
                             df = pd.read_csv(os.path.join(root, name), encoding='utf-8_sig', header=0, na_filter=False)
                             # if '日期' not in df.columns.tolist():
-                            #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                            #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
+                            #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            #     print(f'{now} {root_file} 缺少日期列, 不支持上传 mysql')
                             #     continue
                             if '日期' in df.columns.tolist():
                                 df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
@@ -834,8 +1108,8 @@ class MysqlUpload:
                 if f_path.endswith('.csv') and 'baidu' not in f_path:
                     df = pd.read_csv(f_path, encoding='utf-8_sig', header=0, na_filter=False)
                     # if '日期' not in df.columns.tolist():
-                    #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                    #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
+                    #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    #     print(f'{now} {root_file} 缺少日期列, 不支持上传 mysql')
                     #     continue
                     if '日期' not in df.columns.tolist():
                         df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
@@ -886,7 +1160,7 @@ class OptimizeDatas:
                 print(f'{func.__name__}, {e}')  # 将异常信息返回
                 with open(error_file, 'a') as f:
                     now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                    f.write(f'\n{now}\n')
+                    f.write(f'\n{now} \n')
                     # f.write(f'报错的文件:\n{e.__traceback__.tb_frame.f_globals["__file__"]}\n')  # 发生异常所在的文件
                 traceback.print_exc(file=open(error_file, 'a'))  # 返回完整的堆栈信息
                 print(f'更多信息请查看日志文件: {error_file}')
@@ -899,8 +1173,8 @@ class OptimizeDatas:
         需要设置 self.db_name_lists
         """
         if not self.db_name_lists:
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-            print(f'{now}尚未设置参数: self.db_name_lists')
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f'{now} 尚未设置参数: self.db_name_lists')
             return
         for db_name in self.db_name_lists:
             self.db_name = db_name
@@ -909,13 +1183,13 @@ class OptimizeDatas:
     def optimize(self, except_key=['更新时间']):
         """ 更新一个数据库 移除冗余数据 """
         if not self.db_name:
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-            print(f'{now}尚未设置参数: self.db_name')
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f'{now} 尚未设置参数: self.db_name')
             return
         tables = self.table_list(db_name=self.db_name)
         if not tables:
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-            print(f'{now}{self.db_name} -> 数据表不存在')
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f'{now} {self.db_name} -> 数据表不存在')
             return
 
         # 日期初始化
@@ -932,8 +1206,8 @@ class OptimizeDatas:
         start_date_before = self.start_date
         end_date_before = self.end_date
 
-        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-        print(f'{now}mysql({self.host}: {self.port}) {self.db_name} 数据库优化中(日期长度: {self.days} 天)...')
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} mysql({self.host}: {self.port}) {self.db_name} 数据库优化中(日期长度: {self.days} 天)...')
         for table_dict in tables:
             for key, table_name in table_dict.items():
                 # if '店铺指标' not in table_name:
@@ -946,8 +1220,8 @@ class OptimizeDatas:
                     cursor.execute(sql)
                     result = cursor.fetchone()
                     if not result:
-                        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                        print(f'{now}数据表: {table_name}, 数据长度为 0')
+                        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        print(f'{now} 数据表: {table_name}, 数据长度为 0')
                         continue  # 检查数据表是否为空
 
                     cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")  # 查询数据表的列信息
@@ -979,21 +1253,32 @@ class OptimizeDatas:
                     else:  # 不存在日期列的情况
                         self.delete_duplicate2(table_name=table_name, except_key=except_key)
 
-                    # # 5. 重置自增列 (id 列)
-                    # try:
-                    #     cursor.execute(f"SHOW COLUMNS FROM `{table_name}` LIKE 'id'")
-                    #     result = cursor.fetchone()
-                    #     if result:
-                    #         cursor.execute(f"ALTER TABLE `{table_name}` DROP COLUMN id;")  # 删除 id  列
-                    #     cursor.execute(
-                    #         f"ALTER TABLE `{table_name}` ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
-                    #     cursor.execute(f"ALTER TABLE `{table_name}` AUTO_INCREMENT = 1")  # 设置自增从 1 开始
-                    # except Exception as e:
-                    #     print(f'{e}')
-                    #     self.connection.rollback()
+                    # 6. 重置自增列
+                    try:
+                        # 查询所有复合主键
+                        sql = (
+                            f"SELECT `COLUMN_NAME` AS `PrimaryKey` FROM `information_schema`.`COLUMNS` "
+                            f"WHERE `TABLE_SCHEMA` = '{self.db_name}'AND `TABLE_NAME` = '{table_name}' AND `COLUMN_KEY` = 'PRI';"
+                        )
+                        cursor.execute(sql)
+                        result = cursor.fetchall()  # 复合主键数
+                        if len(result) <= 1:  # 如果存在复合主键，则不能直接删除 id 键，其他主键可能不是唯一，会报错
+                            cursor.execute(f"SHOW COLUMNS FROM {table_name} LIKE 'id'")
+                            result = cursor.fetchone()
+                            if result:
+                                cursor.execute(f"ALTER TABLE {table_name} DROP COLUMN id;")  # 删除 id  列
+                            cursor.execute(
+                                f"ALTER TABLE {table_name} ADD column id INT AUTO_INCREMENT PRIMARY KEY FIRST;")
+                            cursor.execute(f"ALTER TABLE {table_name} AUTO_INCREMENT = 1")  # 设置自增从 1 开始
+                            # print(f'重置自增id')
+                        else:
+                            print(f'{table_name} 当前表存在复合主键: {result}, 无法重置自增id')
+                    except Exception as e:
+                        print(f'{e}')
+                        self.connection.rollback()
                 self.connection.close()
-        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-        print(f'{now}mysql({self.host}: {self.port}) {self.db_name} 数据库优化完成!')
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        print(f'{now} mysql({self.host}: {self.port}) {self.db_name} 数据库优化完成!')
 
     def delete_duplicate(self, table_name, date, except_key=['更新时间']):
         datas = self.table_datas(db_name=self.db_name, table_name=str(table_name), date=date)
@@ -1026,8 +1311,8 @@ class OptimizeDatas:
                 # 移除冗余数据
                 sql = f"DELETE FROM `{table_name}` WHERE id IN ({placeholders})"
                 cursor.execute(sql, duplicate_id)
-                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                print(f"{now}{table_name} -> {date.strftime('%Y-%m-%d')} before: {len(datas)}, remove: {cursor.rowcount}")
+                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                print(f"{now} {table_name} -> {date.strftime('%Y-%m-%d')} before: {len(datas)}, remove: {cursor.rowcount}")
             self.connection.commit()  # 提交事务
         except Exception as e:
             print(f'{self.db_name}/{table_name}, {e}')
@@ -1064,8 +1349,8 @@ class OptimizeDatas:
                 # 移除冗余数据
                 sql = f"DELETE FROM `{table_name}` WHERE id IN ({placeholders})"
                 cursor.execute(sql, duplicate_id)
-                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                print(f"{now}{table_name} -> before: {len(datas)}, "
+                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                print(f"{now} {table_name} -> before: {len(datas)}, "
                       f"remove: {cursor.rowcount}")
             self.connection.commit()  # 提交事务
         except Exception as e:
@@ -1089,8 +1374,8 @@ class OptimizeDatas:
                 cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
                 database_exists = cursor.fetchone()
                 if not database_exists:
-                    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                    print(f'{now}{db_name}: 数据表不存在!')
+                    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    print(f'{now} {db_name}: 数据表不存在!')
                     return
         except Exception as e:
             print(f'002 {e}')

{mdbq-3.2.10.dist-info → mdbq-3.2.12.dist-info}/METADATA

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

{mdbq-3.2.10.dist-info → mdbq-3.2.12.dist-info}/RECORD

@@ -1,11 +1,11 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
 mdbq/__version__.py,sha256=y9Mp_8x0BCZSHsdLT_q5tX9wZwd5QgqrSIENLrb6vXA,62
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
-mdbq/aggregation/aggregation.py,sha256=kdWeVjvUoWOZhidez0FyMtutIrPwnjLCY7USaQVNxRk,76336
+mdbq/aggregation/aggregation.py,sha256=cVp7MLFOSOAtfuCqjZYW7S3mEdw2Gc_jEdqCeWz7qh0,80264
 mdbq/aggregation/df_types.py,sha256=U9i3q2eRPTDY8qAPTw7irzu-Tlg4CIySW9uYro81wdk,8125
 mdbq/aggregation/mysql_types.py,sha256=YTGyrF9vcRgfkQbpT-e-JdJ7c7VF1dDHgyx9YZRES8w,10934
 mdbq/aggregation/optimize_data.py,sha256=RXIv7cACCgYyehAxMjUYi_S7rVyjIwXKWMaM3nduGtA,3068
-mdbq/aggregation/query_data.py,sha256=GbmvkRYEv_xg90vHp2FszjFZuMqO3ZPSEp6lZrnOrIE,148227
+mdbq/aggregation/query_data.py,sha256=2--y1VNYhL7lCeVA9WjIHiz3K_2JYm9agFqWd5jaeIc,148341
 mdbq/aggregation/query_data_bak.py,sha256=r1FU0C4zjXln7oVSrRkElh4Ehl-9mYhGcq57jLbViUA,104071
 mdbq/aggregation/query_data_bak20241124.py,sha256=oY95ZK3qt3Wx9pdZKZ5cvDh45Yi5yGj1kl8G6riumHA,144513
 mdbq/bdup/__init__.py,sha256=AkhsGk81SkG1c8FqDH5tRq-8MZmFobVbN60DTyukYTY,28
@@ -28,7 +28,7 @@ mdbq/log/mylogger.py,sha256=oaT7Bp-Hb9jZt52seP3ISUuxVcI19s4UiqTeouScBO0,3258
 mdbq/mongo/__init__.py,sha256=SILt7xMtQIQl_m-ik9WLtJSXIVf424iYgCfE_tnQFbw,13
 mdbq/mongo/mongo.py,sha256=v9qvrp6p1ZRWuPpbSilqveiE0FEcZF7U5xUPI0RN4xs,31880
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
-mdbq/mysql/mysql.py,sha256=z3RXzPiVQzJzPBoyLr1XL5QXAtXehjbkxWVoBCQBaqY,64373
+mdbq/mysql/mysql.py,sha256=ZG6BMfoXg6YGnHqv7GfwPwd7RXjoetCAFqPnbdHWqOM,79507
 mdbq/mysql/recheck_mysql.py,sha256=rgTpvDMWYTyEn7UQdlig-pdXDluTgiU8JG6lkMh8DV0,8665
 mdbq/mysql/s_query.py,sha256=MbIprZ4yJDAZ9AahZPzl7hqS695Vs0P-AJNwAtA_EEc,9287
 mdbq/mysql/year_month_day.py,sha256=VgewoE2pJxK7ErjfviL_SMTN77ki8GVbTUcao3vFUCE,1523
@@ -46,7 +46,7 @@ mdbq/req_post/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/req_post/req_tb.py,sha256=qg7pet73IgKGmCwxaeUyImJIoeK_pBQT9BBKD7fkBNg,36160
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=nIKKZOZbemKqcrikcrMmtksLgJjjzeU0I99teBgU1jE,22439
-mdbq-3.2.10.dist-info/METADATA,sha256=l7LN00jP2XEWyB9qTPGKZIbV0Aucaa57dyB50mgImJU,244
-mdbq-3.2.10.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-mdbq-3.2.10.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.2.10.dist-info/RECORD,,
+mdbq-3.2.12.dist-info/METADATA,sha256=W62uxvamVOW_S6O91kqwl5N36Nh8QzvKHF-C5ZyiD-w,244
+mdbq-3.2.12.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+mdbq-3.2.12.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.2.12.dist-info/RECORD,,