mdbq 2.9.4__py3-none-any.whl → 2.9.6__py3-none-any.whl

mdbq/aggregation/aggregation.py

@@ -919,8 +919,8 @@ class DatabaseUpdateBak:
                             move_insert=True,  # 先删除，再插入
                             df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
                             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+                            count=None,
                             filename=rt_filename,  # 用来追踪处理进度
-                            service_database=service_database,  # 字典
                         )
                 df_to_json.as_json_file()  # 写入 json 文件, 包含数据的 dtypes 信息
 
@@ -1083,8 +1083,8 @@ class DatabaseUpdateBak:
                     move_insert=True,  # 先删除，再插入
                     df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
                     drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+                    count=None,
                     filename=None,  # 用来追踪处理进度
-                    service_database=service_database,  # 用来追踪处理进度
                 )
         # return df
 
@@ -1116,8 +1116,8 @@ class DatabaseUpdateBak:
                     move_insert=False,  # 先删除，再插入
                     df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
                     drop_duplicates=True,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+                    count=None,
                     filename=None,  # 用来追踪处理进度
-                    service_database=service_database,  # 用来追踪处理进度
                 )
 
 
@@ -1189,7 +1189,8 @@ def upload_dir(path, db_name, collection_name, json_path=None):
                               move_insert=False,  # 先删除，再插入
                               df_sql = True,
                               drop_duplicates=False,
-                              filename=name, count=f'{i}/{count}',
+                              count=f'{i}/{count}',
+                              filename=name,
                               )
                 # nas.df_to_mysql(df=df, db_name=db_name, table_name=collection_name, drop_duplicates=True,)
             except Exception as e:
@@ -1210,15 +1211,16 @@ def one_file_to_mysql(file, db_name, table_name):
         df=df,
         db_name=db_name,
         table_name=table_name,
-        filename=filename,
         move_insert=False,
         df_sql=True,
         drop_duplicates=False,
+        count=None,
+        filename=filename,
     )
 
 
 def test():
-    path = r'/Users/xigua/Downloads/DMP报表'
+    path = r'/Users/xigua/数据中心/原始文件3/达摩盘/dmp人群报表'
 
     results = []
     for root, dirs, files in os.walk(path, topdown=False):
@@ -1231,8 +1233,10 @@ def test():
                 if len(df) == 0:
                     continue
                 if '达摩盘消耗占比' in df.columns.tolist():
-                    print(name)
                     df.pop('达摩盘消耗占比')
+                if '更新时间' not in df.columns.tolist():
+                    print(name)
+                    df['更新时间'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                     # df.insert(loc=1, column='店铺名称', value='万里马官方旗舰店')
                     # df['更新时间'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                     df.to_csv(os.path.join(root, name), encoding='utf-8_sig', index=False, header=True)
@@ -1278,14 +1282,13 @@ if __name__ == '__main__':
     # )
 
     # test()
-
-    col = 1
+    col = 0
     if col:
         # 上传一个目录到指定数据库
-        db_name = '达摩盘3'
-        table_name = 'dmp人群报表'
+        db_name = '生意参谋3'
+        table_name = '店铺流量来源构成'
         upload_dir(
-            path=r'/Users/xigua/Downloads/DMP报表',
+            path=r'/Users/xigua/数据中心/原始文件3/生意参谋/店铺流量来源',
             db_name=db_name,
             collection_name=table_name,
         )

mdbq/aggregation/query_data.py

@@ -2119,8 +2119,9 @@ def date_table():
         move_insert=True,  # 先删除，再插入
         df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
         drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+        count=None,
         filename=None,  # 用来追踪处理进度
-        service_database=service_database,  # 用来追踪处理进度
+        set_typ={},
     )
 
 
@@ -2284,7 +2285,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
                 # df_sql=True,
                 drop_duplicates=False,
                 icm_update=['商品id'],
-                service_database=service_database,
+                count=None,
+                filename=None,
+                set_typ={},
             )
             g.sp_index_datas = pd.DataFrame()  # 重置，不然下个循环会继续刷入数据库
         # g.as_csv(df=df, filename=table_name + '.csv')  # 导出 csv
@@ -2297,7 +2300,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
                 # df_sql=True,
                 # drop_duplicates=False,
                 # icm_update=unique_key_list,
-                service_database=service_database,
+                count=None,
+                filename=None,
+                set_typ={},
             )  # 3. 回传数据库
         else:  # 没有日期列的就用主键排重
             m.df_to_mysql(
@@ -2308,7 +2313,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
                 # df_sql=True,
                 drop_duplicates=False,
                 icm_update=unique_key_list,
-                service_database=service_database,
+                count=None,
+                filename=None,
+                set_typ={},
             )  # 3. 回传数据库
     if is_juhe:
         res = g.performance(bb_tg=True)   # 盈亏表，依赖其他表，单独做
@@ -2320,7 +2327,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
             # df_sql=True,
             # drop_duplicates=False,
             # icm_update=['日期', '商品id'],  # 设置唯一主键
-            service_database=service_database,
+            count=None,
+            filename=None,
+            set_typ={},
         )
         res = g.performance(bb_tg=False)  # 盈亏表，依赖其他表，单独做
         m.df_to_mysql(
@@ -2331,7 +2340,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
             # df_sql=True,
             # drop_duplicates=False,
             # icm_update=['日期', '商品id'],  # 设置唯一主键
-            service_database=service_database,
+            count=None,
+            filename=None,
+            set_typ={},
         )
         res = g.performance_concat(bb_tg=False)  # 推广主体合并直播表，依赖其他表，单独做
         m.df_to_mysql(
@@ -2342,7 +2353,9 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
             # df_sql=True,
             # drop_duplicates=False,
             # icm_update=['日期', '推广渠道', '营销场景', '商品id', '花费', '展现量', '点击量'],  # 设置唯一主键
-            service_database=service_database,
+            count=None,
+            filename=None,
+            set_typ={},
         )
         res = g.performance_jd(jd_tg=False)  # 盈亏表，依赖其他表，单独做
         m.df_to_mysql(
@@ -2353,18 +2366,32 @@ def data_aggregation(months=1, is_juhe=True, less_dict=[]):
             # df_sql=True,
             # drop_duplicates=False,
             # icm_update=['日期', '跟单sku_id', '货号', '花费'],  # 设置唯一主键
-            service_database=service_database,
+            count=None,
+            filename=None,
+            set_typ={},
         )
 
 
 def main(days=100, months=3):
-    # 更新日期表
+    # 1. 更新日期表  更新货品年份基准表， 属性设置 3 - 货品年份基准
     date_table()
-    # 更新货品年份基准表， 属性设置 3 - 货品年份基准
     p = products.Products()
     p.to_mysql()
 
-    # 数据聚合
+    # 2. 清理非聚合数据库
+    system = platform.system()  # 本机系统
+    host_name = socket.gethostname()  # 本机名
+    conf = myconfig.main()
+    db_list = conf[system][host_name]['mysql']['数据库集']
+    not_juhe_db_list = [item for item in db_list if item != '聚合数据']
+    optimize_data.op_data(
+        db_name_lists=not_juhe_db_list,
+        days=31,  # 原始数据不需要设置清理太长
+        is_mongo=False,
+        is_mysql=True,
+    )
+
+    # 3. 数据聚合
     data_aggregation(
         months=months,
         is_juhe=True,  # 生成聚合表
@@ -2372,13 +2399,9 @@ def main(days=100, months=3):
     )
     time.sleep(60)
 
-    system = platform.system()  # 本机系统
-    host_name = socket.gethostname()  # 本机名
-    conf = myconfig.main()
-    db_list = conf[system][host_name]['mysql']['数据库集']
-    # 清理所有库
+    # 4. 清理聚合数据
     optimize_data.op_data(
-        db_name_lists=db_list,
+        db_name_lists=['聚合数据'],
         days=days,
         is_mongo=False,
         is_mysql=True,

mdbq/config/products.py

@@ -141,22 +141,12 @@ class Products:
                 dict_data=dict_data,
                 # icm_update=['日期', '店铺名称', '宝贝id'],  # 唯一组合键
                 unique_main_key=['商品id'],
-                set_type={
+                set_typ={
                     '商品id': 'mediumtext',
                     '平台': 'mediumtext',
                     '上市年份': 'mediumtext',
                 },
             )
-        # m.df_to_mysql(
-        #     df=df,
-        #     db_name='属性设置3',
-        #     table_name='货品年份基准',
-        #     move_insert = False,
-        #     df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
-        #     drop_duplicates=True,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
-        #     icm_update=[],
-        #     service_database=service_database,  # 用来追踪处理进度
-        # )
 
     def market_date(self, product_id: int):
         try:

mdbq/mysql/mysql.py

@@ -133,7 +133,7 @@ class MysqlUpload:
         return wrapper
 
     @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_type=None):
+    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):
         """
         插入字典数据
         dict_data： 字典
@@ -141,7 +141,7 @@ class MysqlUpload:
         unique_main_key： 指定唯一索引列
         index_length: 索引长度
         icm_update: 增量更正，指定后 main_key 只用于检查/创建列，不能更新数据
-        set_type: {}
+        set_typ: {}
         """
         if not main_key:
             main_key = []
@@ -177,8 +177,11 @@ class MysqlUpload:
 
             # 根据 dict_data 的值添加指定的数据类型
             dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'mediumtext',...}
-            if set_type:
-                dtypes.update(set_type)  # 自定义的数据类型
+            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;"
@@ -306,6 +309,7 @@ class MysqlUpload:
         connection.close()
 
     def cover_dict_dtypes(self, dict_data):
+        """ 清理字典键值 并转换数据类型  """
         if not dict_data:
             print(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
             return
@@ -339,7 +343,7 @@ class MysqlUpload:
             elif str(v) == '':
                 __res_dict.update({k: 'mediumtext'})
             elif result2:  # 小数
-                __res_dict.update({k: 'decimal(10,4)'})
+                __res_dict.update({k: 'decimal(12,4)'})
             elif date_type == 1:  # 纯日期
                 __res_dict.update({k: 'DATE'})
             elif date_type == 2:  # 日期+时间
@@ -352,7 +356,7 @@ class MysqlUpload:
                         v = round(float(v), 4)
                     __res_dict.update({k: 'decimal(12,4)'})
                 elif count_float >= 6:
-                    __res_dict.update({k: 'decimal(12,6)'})
+                    __res_dict.update({k: 'decimal(14,6)'})
                 elif count_float >= 4:
                     __res_dict.update({k: 'decimal(10,4)'})
                 else:
@@ -362,12 +366,78 @@ class MysqlUpload:
             new_dict_data.update({k: v})
         return __res_dict, new_dict_data
 
+    def cover_df(self, df):
+        """ 清理 df 的值和列名 """
+        df.replace([np.inf, -np.inf], 0, inplace=True)  # 清理一些非法值
+        df.replace(to_replace=['\\N', '-', '--', '', 'nan', 'NAN'], value=0, regex=False, inplace=True)  # 替换掉特殊字符
+        df.replace(to_replace=[','], value='', regex=True, inplace=True)
+        df.replace(to_replace=['="'], value='', regex=True, inplace=True)  # ="和"不可以放在一起清洗, 因为有: id=86785565
+        df.replace(to_replace=['"'], value='', regex=True, inplace=True)
+        cols = df.columns.tolist()
+        for col in cols:
+            df[col] = df[col].apply(lambda x: float(re.sub(r'%$', '', str(x))) / 100 if (
+                    str(x) != '' and str(x).endswith('%')) else '0.0' if str(x) == '0%' else x)
+            try:
+                df[col] = df[col].apply(
+                    lambda x: int(x) if '_' not in str(x) and '.' not in str(x) else x)  # 不含小数点尝试转整数
+            except:
+                pass
+            if df[col].dtype == 'object':
+                try:
+                    df[col] = df[col].apply(lambda x: float(x) if '.' in str(x) and '_' not in str(x) else x)
+                except:
+                    pass
+            new_col = col.lower()
+            new_col = re.sub(r'[()\-，,&~^、 （）\"\'“”=·/。》《><！!`]', '_', new_col, re.IGNORECASE)
+            new_col = new_col.replace('）', '')
+            new_col = re.sub(r'_{2,}', '_', new_col)
+            new_col = re.sub(r'_+$', '', new_col)
+            df.rename(columns={col: new_col}, inplace=True)
+        df.fillna(0, inplace=True)
+        return df
+
+    def convert_df_dtypes(self, df: pd.DataFrame):
+        """ 清理 df 的值和列名，并转换数据类型 """
+        df = self.cover_df(df=df)  # 清理 df 的值和列名
+        [pd.to_numeric(df[col], errors='ignore') for col in df.columns.tolist()]
+        dtypes = df.dtypes.to_dict()
+        __res_dict = {}
+        for k, v in dtypes.items():
+            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)
+
+            if result1:  # id/sku/spu商品信息
+                __res_dict.update({k: 'varchar(50)'})
+            elif result2:  # 小数
+                __res_dict.update({k: 'decimal(10,4)'})
+            elif result3:  # 小数
+                __res_dict.update({k: 'decimal(12,4)'})
+            elif result4:  # 小数
+                __res_dict.update({k: 'decimal(12,2)'})
+            elif k == '日期':
+                __res_dict.update({k: 'DATE'})
+            elif k == '更新时间':
+                __res_dict.update({k: 'TIMESTAMP'})
+            elif v == 'int64':
+                __res_dict.update({k: 'int'})
+            elif v == 'float64':
+                __res_dict.update({k: 'decimal(10,4)'})
+            elif v == 'bool':
+                __res_dict.update({k: 'BOOLEAN'})
+            elif v == 'datetime64[ns]':
+                __res_dict.update({k: 'datetime'})
+            else:
+                __res_dict.update({k: 'varchar(255)'})
+        return __res_dict, df
+
     @try_except
-    def df_to_mysql(self, df, table_name, db_name='远程数据源', icm_update=[], service_database={'xigua_lx': 'mysql'}, move_insert=False, df_sql=False, drop_duplicates=False, filename=None, count=None, json_path=None, reset_id=False):
+    def df_to_mysql(self, df, db_name, table_name, set_typ=None, icm_update=[], move_insert=False, df_sql=False, drop_duplicates=False,
+                    filename=None, count=None, reset_id=False):
         """
-        将 df 写入数据库
-        db_name: 数据库名称
-        table_name: 集合/表名称
+        db_name: 数据库名
+        table_name: 表名
         move_insert: 根据df 的日期，先移除数据库数据，再插入, df_sql, drop_duplicates, icm_update 都要设置为 False
         原则上只限于聚合数据使用，原始数据插入时不要设置
 
@@ -376,8 +446,6 @@ class MysqlUpload:
         icm_update: 增量更新, 在聚合数据中使用，原始文件不要使用，设置此参数时需将 drop_duplicates 改为 False
                 使用增量更新: 必须确保 icm_update 传进来的列必须是数据表中唯一主键，值不会发生变化，不会重复，否则可能产生错乱覆盖情况
         filename: 用来追踪处理进度，传这个参数是方便定位产生错误的文件
-        service_database: 这个参数是用来设置更新哪台服务器的 types 信息到本地 json 文件
-        json_path: 这个参数同样也是是用来设置更新 json 文件
         """
         self.filename = filename
         if isinstance(df, pd.DataFrame):
@@ -391,8 +459,13 @@ class MysqlUpload:
             print(f'{db_name} 不能为 None')
             return
 
-        cv = converter.DataFrameConverter()
-        df = cv.convert_df_cols(df=df)  # 清理 dataframe 非法值
+        # 清理 dataframe 非法值，并转换获取数据类型
+        dtypes, df = self.convert_df_dtypes(df)
+        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]
 
         connection = pymysql.connect(**self.config)  # 连接数据库
         with connection.cursor() as cursor:
@@ -422,15 +495,6 @@ class MysqlUpload:
                 cursor.execute(sql)
                 print(f'创建 mysql 表: {table_name}')
 
-            for service_name, database in service_database.items():
-                # 2. 列数据类型转换，将 df 数据类型转换为 mysql 的数据类型
-                dtypes, cl, db_n, tb_n = self.convert_dtypes(df=df, db_name=db_name, table_name=table_name, path=json_path, service_name=service_name)
-                for dy in dtypes.keys():
-                    if '日期' == dy:
-                        dtypes.update({'日期': 'DATE'})
-                    if '更新时间' == dy:
-                        dtypes.update({'更新时间': 'TIMESTAMP'})
-
             #  有特殊字符不需转义
             sql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s;"
             cursor.execute(sql, (db_name, table_name))
@@ -456,7 +520,8 @@ class MysqlUpload:
 
             if df_sql:
                 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}')
+                print(
+                    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_sql(
@@ -466,45 +531,23 @@ class MysqlUpload:
                     index=False,
                     chunksize=1000
                 )
-                # print(f'重置自增')
-                # # 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()
-
-                if cl and db_n and tb_n:
-                    mysql_types.mysql_all_dtypes(db_name=db_name, table_name=table_name)  # 更新一个表的 dtypes
-                elif cl and db_n:
-                    mysql_types.mysql_all_dtypes(db_name=db_name)  # 更新一个数据库的 dtypes
-                elif cl:
-                    mysql_types.mysql_all_dtypes()  # 更新所有数据库所有数据表的 dtypes 信息到本地 json
-
+                if reset_id:
+                    # 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()
+                connection.commit()  # 提交事务
                 connection.close()
                 return
 
-            # print(cl, db_n, tb_n)
-            # 返回这些结果的目的是等添加完列再写 json 文件才能读到 types 信息
-            # ⚠️ mysql_all_dtypes 函数默认只读取 xigua_lx 的数据库信息，不会读取其他系统
-            if cl and db_n and tb_n:
-                mysql_types.mysql_all_dtypes(db_name=db_name, table_name=table_name)  # 更新一个表的 dtypes
-            elif cl and db_n:
-                mysql_types.mysql_all_dtypes(db_name=db_name)  # 更新一个数据库的 dtypes
-            elif cl:
-                mysql_types.mysql_all_dtypes()  # 更新所有数据库所有数据表的 dtypes 信息到本地 json
-
-            # 4. 更新插入数据
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-            for service_name, database in service_database.items():
-                print(f'{now}正在更新 mysql ({self.host}:{self.port}) {db_name}/{table_name}, {count}, {service_name}, {self.filename}')
-
             # 5. 移除指定日期范围内的数据，原则上只限于聚合数据使用，原始数据插入时不要设置
             if move_insert and '日期' in df.columns.tolist():
                 # 移除数据
@@ -546,7 +589,6 @@ class MysqlUpload:
                 # data 是传进来待处理的数据, 不是数据库数据
                 # data 示例: {'日期': Timestamp('2024-08-27 00:00:00'), '推广费余额': 33299, '品销宝余额': 2930.73, '短信剩余': 67471}
                 try:
-
                     condition = []
                     for k, v in data.items():
                         condition += [f'`{k}` = "{v}"']
@@ -571,7 +613,8 @@ class MysqlUpload:
                         cursor.execute(sql, (db_name, {table_name}))
                         columns = cursor.fetchall()
                         cols_exist = [col['COLUMN_NAME'] for col in columns]  # 数据表的所有列, 返回 list
-                        update_col = [item for item in cols_exist if item not in icm_update and item != 'id']  # 除了主键外的其他列
+                        update_col = [item for item in cols_exist if
+                                      item not in icm_update and item != 'id']  # 除了主键外的其他列
 
                         # unique_keys 示例: `日期`, `余额`
                         unique_keys = ', '.join(f"`{item}`" for item in update_col)  # 列名需要转义
@@ -607,7 +650,8 @@ class MysqlUpload:
                                 if change_values:  # change_values 有数据返回，表示值需要更新
                                     if not_change_col:
                                         not_change_values = [f'`{col}` = "{str(data[col])}"' for col in not_change_col]
-                                        not_change_values = ' AND '.join(not_change_values)  # 示例: `短信剩余` = '888' AND `test1` = '93'
+                                        not_change_values = ' AND '.join(
+                                            not_change_values)  # 示例: `短信剩余` = '888' AND `test1` = '93'
                                         # print(change_values, not_change_values)
                                         condition += f' AND {not_change_values}'  # 重新构建完整的查询条件，将未发生变化的列加进查询条件
                                     change_values = ', '.join(f"{item}" for item in change_values)  # 注意这里 item 外面没有反引号
@@ -641,107 +685,6 @@ class MysqlUpload:
         connection.commit()  # 提交事务
         connection.close()
 
-    def convert_dtypes(self, df, db_name, table_name, path=None, service_name=None):
-        """
-        根据本地 json 转换 df 的类型为 mysql 专有的数据类型
-        可能不存在本地 json 文件 (函数按指定规则转换并更新 json)
-        允许通过 json 文件手动添加或修改列的数据类型(仅影响初创数据表)
-        """
-        cols = df.columns.tolist()
-        # path = set_support.SetSupport(dirname='support').dirname
-        d = mysql_types.DataTypes(path=path, service_name=service_name)
-        # 从本地文件中读取 dtype 信息
-        dtypes, cl, db_n, tb_n = d.load_dtypes(cl='mysql', db_name=db_name, table_name=table_name)
-        # 可能会因为没有 json 文件, 返回 None
-        if dtypes:
-            # 按照文件记录更新 dtypes
-            dtypes.update({col: dtypes[col] for col in cols if col in dtypes.keys()})
-            # 可能存在部分列不在文件记录中
-            col_not_exist = [col for col in cols if col not in dtypes.keys()]
-            # 这些列不存在于 df 中, 必须移除
-            [dtypes.pop(col) for col in list(dtypes.keys()) if col not in cols]
-        else:  # 没有 json 文件时
-            dtypes = df.dtypes.apply(str).to_dict()  # 将 dataframe 数据类型转为字典形式
-            col_not_exist = cols
-        # 对文件不存在的列信息进行数据类型转换(按指定规则)
-        dtypes.update({col: self.convert_dtype_to_sql(df=df, col=col, dtype=df[col].dtype) for col in col_not_exist})
-        # print(dtypes)
-        # 至此 df 中全部列类型已经转换完成
-        # 返回结果, 示例: {'上市年份': 'mediumtext', '商品id': 'mediumtext', '平台': 'mediumtext'}
-        return dtypes, cl, db_n, tb_n  # 返回这些结果的目的是等添加完列再写 json 文件才能读到 types 信息
-
-    def convert_dtype_to_sql(self, df, col, dtype):
-        """ 按照以下规则转换DataFrame列的数据类型为 MYSQL 专有的数据类型 """
-
-        def find_longest_decimal_value(number_list):
-            # 针对小数设置的函数, 用来获取列表中小数位数最长的值
-            longest_value = None
-            max_decimals = 0
-            for num in number_list:
-                try:
-                    decimal_places = len(str(num).split('.')[1])
-                    if decimal_places > max_decimals:
-                        max_decimals = decimal_places
-                        longest_value = num
-                except:
-                    longest_value = num
-                    continue
-            return longest_value
-
-        if '商品编码' in col:  # 京东sku/spu商品信息
-            return 'mediumtext'
-        if '文件大小' in col:  # bw 程序
-            return 'mediumtext'
-        if col.endswith('占比') and (df[col].dtype == 'float' or df[col].dtype == 'int'):
-            return 'decimal(10,4)'
-        elif dtype == 'datetime64[ns]':
-            return 'DATETIME'  # 使用 DATE 后续排重可能会引发不能排重
-        elif dtype == 'int32':
-            max_num = str(max(df[col].tolist()))
-            if len(max_num) >= 10:  # 数值长度超限转为 mediumtext
-                return 'mediumtext'
-            return 'INT'
-        elif dtype == 'int64':
-            max_num = str(max(df[col].tolist()))
-            if len(max_num) >= 10:
-                return 'mediumtext'
-            return 'INT'
-        elif dtype == 'float64':
-            res = find_longest_decimal_value(df[col].tolist())  # 取小数位数最长的值
-            if 'e' in str(res):
-                res = round(float(res), 4)
-            int_step = len(str(res).split('.')[0])   # 整数位数长度
-            f_step = len(str(res).split('.')[1])  # 小数位数长度
-
-            if int_step >= 12:
-                return 'mediumtext'  # mysql 中不要使用 float 和 double 类型，会影响计算结果
-            elif int_step >= 8 and f_step >= 0:
-                return 'decimal(16, 2)'
-            elif int_step >= 6 and f_step >= 0:
-                return 'decimal(10, 2)'
-            elif int_step >= 4 and f_step >= 0:
-                return 'decimal(10, 2)'
-            elif int_step >= 2 and f_step >= 6:
-                return 'decimal(12, 4)'
-            elif int_step >= 2 and f_step > 4:
-                return 'decimal(12, 4)'
-            elif int_step >= 2 and f_step > 2:
-                return 'decimal(10, 4)'
-            elif int_step >= 2 and f_step >= 0:
-                return 'decimal(10, 2)'
-            elif int_step >= 1 and f_step >= 6:
-                return 'decimal(12, 4)'
-            elif int_step >= 1 and f_step > 4:
-                return 'decimal(12, 4)'
-            elif int_step >= 1 and f_step > 2:
-                return 'decimal(10, 4)'
-            else:
-                return 'decimal(10, 2)'
-        elif dtype == 'object':
-            return 'mediumtext'
-        else:
-            return 'mediumtext'
-
     # @try_except
     def read_mysql(self, table_name, start_date, end_date, db_name='远程数据源', date_name='日期'):
         """ 读取指定数据表，可指定日期范围，返回结果: df """
@@ -1175,6 +1118,8 @@ if __name__ == '__main__':
     username, password, host, port = data['username'], data['password'], data['host'], data['port']
     print(username, password, host, port)
 
-    ss = '2024-11-08'
-    ss= re.sub(r'\\N', '0', ss)
-    print(ss, '111')
+    df = pd.read_excel('/Users/xigua/Downloads/66563857.xlsx')
+    ss = MysqlUpload(username, password, host, port)
+    res, data = ss.convert_df_dtypes(df=df)
+    print(data)
+    print(res)

mdbq/mysql/recheck_mysql.py

@@ -150,8 +150,8 @@ class ReCheckMysql:
             move_insert=True,  # 先删除，再插入
             df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
             drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+            count=None,
             filename='',  # 用来追踪处理进度
-            service_database={'company': 'mysql'},  # 字典
         )
 
 

mdbq/req_post/req_tb.py

@@ -611,8 +611,8 @@ def company_run(service_databases=[]):
                         move_insert=False,  # 先删除，再插入
                         df_sql=False,  # 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重
                         drop_duplicates=False,  # 值为 True 时检查重复数据再插入，反之直接上传，会比较慢
+                        count=None,
                         filename=None,  # 用来追踪处理进度
-                        service_database=dt,  # 字典
                     )
                     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
                     print(f'{now} {db_name} -> {table_name}: 已入库')