mdbq 3.6.13__py3-none-any.whl → 3.6.15__py3-none-any.whl

mdbq/mysql/mysql.py

@@ -16,6 +16,7 @@ import calendar
 from mdbq.config import set_support
 from mdbq.config import myconfig
 import traceback
+import logging
 
 warnings.filterwarnings('ignore')
 """
@@ -29,6 +30,7 @@ warnings.filterwarnings('ignore')
 
 """
 error_file = os.path.join(set_support.SetSupport(dirname='support').dirname, 'error.log')
+logger = logging.getLogger(__name__)
 
 
 def is_valid_date(date_string):
@@ -119,14 +121,14 @@ class MysqlUpload:
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                print(f'{func.__name__}, {e}')  # 将异常信息返回
+                logger.info(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'函数注释内容(用于定位函数): {func.__doc__} \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}')
+                logger.info(f'更多信息请查看日志文件: {error_file}')
 
         return wrapper
 
@@ -137,16 +139,16 @@ class MysqlUpload:
                 connection = pymysql.connect(**_config)  # 连接数据库
                 return connection
             except Exception as e:
-                print(f'连接失败，正在重试: {attempts}/{max_try} {e}')
+                logger.info(f'连接失败，正在重试: {attempts}/{max_try} {e}')
                 attempts += 1
                 time.sleep(30)
-        print(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
+        logger.info(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
         return None
 
     def cover_doc_dtypes(self, dict_data):
         """ 清理字典键值 并转换数据类型  """
         if not dict_data:
-            print(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
+            logger.info(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
             return
         __res_dict = {}
         new_dict_data = {}
@@ -213,7 +215,7 @@ class MysqlUpload:
         if not self.config:
             return
         if '数据主体' not in dict_data.keys():
-            print(f'dict_data 中"数据主体"键不能为空')
+            logger.info(f'dict_data 中"数据主体"键不能为空')
             return
 
         # connection = pymysql.connect(**self.config)  # 连接数据库
@@ -234,7 +236,7 @@ class MysqlUpload:
                     sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
                 cursor.execute(sql)
                 connection.commit()
-                print(f"创建Database: {db_name}")
+                logger.info(f"创建Database: {db_name}")
 
         self.config.update({'database': db_name})  # 添加更新 config 字段
         # connection = pymysql.connect(**self.config)  # 重新连接数据库
@@ -248,7 +250,7 @@ class MysqlUpload:
             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}')
+                logger.info(f'创建 mysql 表: {table_name}')
 
             new_dict = {}
             [new_dict.update({k: v}) for k, v in dict_data.items() if k != '数据主体']
@@ -275,11 +277,11 @@ class MysqlUpload:
                     else:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {set_typ[col]} NOT NULL;"
                     cursor.execute(sql)
-                    print(f"添加列: {col}({set_typ[col]})")  # 添加列并指定数据类型
+                    logger.info(f"添加列: {col}({set_typ[col]})")  # 添加列并指定数据类型
 
                     if col == '日期':
                         sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
-                        print(f"设置为索引: {col}({set_typ[col]})")
+                        logger.info(f"设置为索引: {col}({set_typ[col]})")
                         cursor.execute(sql)
             connection.commit()  # 提交事务
 
@@ -290,7 +292,7 @@ class MysqlUpload:
                 for up_col in remove_by_key:
                     condition += [f'`{up_col}` = "{dict_data[up_col]}"']
                 condition = ' AND '.join(condition)
-                # print(condition)
+                # logger.info(condition)
                 sql = f"SELECT {se_key} FROM `{table_name}` WHERE {condition}"
                 cursor.execute(sql)
                 result = cursor.fetchall()
@@ -300,15 +302,14 @@ class MysqlUpload:
 
             # 插入数据到数据库
             # 有数据格式错误问题，所以分开处理，将数据主体移到最后面用占位符
-            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            print(f'{now} 正在更新: mysql ({self.host}:{self.port}) {db_name}/{table_name} -> {filename}')
+            logger.info(f'正在更新: 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)
+                # logger.info(sql)
                 cursor.execute(sql, binary_data)
             else:
                 sql = f"""INSERT INTO `{table_name}` (数据主体) VALUES (%s);"""
@@ -338,11 +339,11 @@ class MysqlUpload:
                         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')
+                        # logger.info(f'重置自增id')
                     else:
-                        print(f'{table_name} 存在复合主键: 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
+                        logger.info(f'{table_name} 存在复合主键: 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
                 except Exception as e:
-                    print(f'333 {table_name} {e}')
+                    logger.info(f'333 {table_name} {e}')
                     connection.rollback()
             connection.commit()
 
@@ -362,7 +363,7 @@ class MysqlUpload:
             return
         if icm_update:
             if main_key or unique_main_key:
-                print(f'icm_update/unique_main_key/unique_main_key 参数不能同时设定')
+                logger.info(f'icm_update/unique_main_key/unique_main_key 参数不能同时设定')
                 return
         if not main_key:
             main_key = []
@@ -370,7 +371,7 @@ class MysqlUpload:
             unique_main_key = []
 
         if not dict_data_list:
-            print(f'dict_data_list 不能为空 ')
+            logger.info(f'dict_data_list 不能为空 ')
             return
         dict_data = dict_data_list[0]
         if cut_data:
@@ -383,9 +384,9 @@ class MysqlUpload:
                     elif str(cut_data).lower() == 'month':
                         table_name = f'{table_name}_{__y_m}'
                     else:
-                        print(f'参数不正确，cut_data应为 year 或 month ')
+                        logger.info(f'参数不正确，cut_data应为 year 或 month ')
                 except Exception as e:
-                    print(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
+                    logger.info(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
 
         # connection = pymysql.connect(**self.config)  # 连接数据库
         connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=10)
@@ -405,7 +406,7 @@ class MysqlUpload:
                     sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
                 cursor.execute(sql)
                 connection.commit()
-                print(f"创建Database: {db_name}")
+                logger.info(f"创建Database: {db_name}")
 
         self.config.update({'database': db_name})  # 添加更新 config 字段
         # connection = pymysql.connect(**self.config)  # 重新连接数据库
@@ -419,7 +420,7 @@ class MysqlUpload:
             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}')
+                logger.info(f'创建 mysql 表: {table_name}')
 
             # 根据 dict_data 的值添加指定的数据类型
             dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'varchar(100)',...}
@@ -443,13 +444,13 @@ class MysqlUpload:
                     else:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
                     # sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
-                    # print(sql)
+                    # logger.info(sql)
                     cursor.execute(sql)
-                    print(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
+                    logger.info(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
 
                     if col in main_key or col == '日期':
                         sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
-                        print(f"设置为索引: {col}({dtypes[col]})")
+                        logger.info(f"设置为索引: {col}({dtypes[col]})")
                         cursor.execute(sql)
                     if col in unique_main_key:
                         if dtypes[col] == 'mediumtext':
@@ -464,22 +465,22 @@ class MysqlUpload:
                     #     if not result:
                     #         if col in main_key:
                     #             sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
-                    #             print(f"设置为索引: {col}({dtypes[col]})")
+                    #             logger.info(f"设置为索引: {col}({dtypes[col]})")
                     #             cursor.execute(sql)
                     #         elif col in unique_main_key:
                     #             if dtypes[col] == 'mediumtext':
                     #                 sql = f"CREATE INDEX UNIQUE index_name ON `{table_name}` (`{col}`({index_length}));"
                     #             else:
                     #                 sql = f"CREATE INDEX UNIQUE index_name ON `{table_name}` (`{col}`);"
-                    #             print(f"设置唯一索引: {col}({dtypes[col]})")
-                    #             print(sql)
+                    #             logger.info(f"设置唯一索引: {col}({dtypes[col]})")
+                    #             logger.info(sql)
                     #             cursor.execute(sql)
             connection.commit()  # 提交事务
             """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
             """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
             # 处理插入的数据
             for dict_data in dict_data_list:
-                # print(dict_data)
+                # logger.info(dict_data)
                 dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'varchar(100)',...}
                 if icm_update:
                     """ 使用增量更新: 需确保 icm_update['主键'] 传进来的列组合是数据表中唯一，值不会发生变化且不会重复，否则可能产生覆盖 """
@@ -496,7 +497,7 @@ class MysqlUpload:
                         condition += [f'`{up_col}` = "{dict_data[up_col]}"']
                     condition = ' AND '.join(condition)  # condition值示例: `品销宝余额` = '2930.73' AND `短信剩余` = '67471'
                     sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE {condition}"
-                    # print(sql)
+                    # logger.info(sql)
                     # sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE `创建时间` = '2014-09-19 14:32:33'"
                     cursor.execute(sql)
                     results = cursor.fetchall()  # results 是数据库取出的数据
@@ -515,7 +516,7 @@ class MysqlUpload:
                                     mysql_value = re.sub(r'0+$', '', mysql_value)
                                     mysql_value = re.sub(r'\.$', '', mysql_value)
                                 if df_value != mysql_value:  # 传进来的数据和数据库比较, 有变化
-                                    # print(f'{dict_data['日期']}{dict_data['商品id']}{col} 列的值有变化，{str(dict_data[col])}  !=  {str(result[col])}')
+                                    # logger.info(f'{dict_data['日期']}{dict_data['商品id']}{col} 列的值有变化，{str(dict_data[col])}  !=  {str(result[col])}')
                                     change_values += [f"`{col}` = \"{str(dict_data[col])}\""]
                                     change_col.append(col)
                             not_change_col = [item for item in update_col if item not in change_col]
@@ -525,11 +526,11 @@ class MysqlUpload:
                                     not_change_values = [f'`{col}` = "{str(dict_data[col])}"' for col in not_change_col]
                                     not_change_values = ' AND '.join(
                                         not_change_values)  # 示例: `短信剩余` = '888' AND `test1` = '93'
-                                    # print(change_values, not_change_values)
+                                    # logger.info(change_values, not_change_values)
                                     condition += f' AND {not_change_values}'  # 重新构建完整的查询条件，将未发生变化的列加进查询条件
                                 change_values = ', '.join(f"{item}" for item in change_values)  # 注意这里 item 外面没有反引号
                                 sql = "UPDATE `%s` SET %s WHERE %s" % (table_name, change_values, condition)
-                                # print(sql)
+                                # logger.info(sql)
                                 cursor.execute(sql)
                     else:  # 没有数据返回，则直接插入数据
                         cols = ', '.join(f"`{item}`" for item in dict_data.keys())  # 列名需要转义
@@ -556,7 +557,7 @@ class MysqlUpload:
 
                 # 构建 sql
                 sql = f"INSERT INTO %s (%s) VALUES (%s) ON DUPLICATE KEY UPDATE %s" % (table_name, keys_data, values_data, update_datas)
-                # print(sql)
+                # logger.info(sql)
                 cursor.execute(sql)
                 connection.commit()  # 提交数据库
         connection.close()
@@ -577,7 +578,7 @@ class MysqlUpload:
             return
         if icm_update:
             if main_key or unique_main_key:
-                print(f'icm_update/unique_main_key/unique_main_key 参数不能同时设定')
+                logger.info(f'icm_update/unique_main_key/unique_main_key 参数不能同时设定')
                 return
         if not main_key:
             main_key = []
@@ -594,9 +595,9 @@ class MysqlUpload:
                     elif str(cut_data).lower() == 'month':
                         table_name = f'{table_name}_{__y_m}'
                     else:
-                        print(f'参数不正确，cut_data应为 year 或 month ')
+                        logger.info(f'参数不正确，cut_data应为 year 或 month ')
                 except Exception as e:
-                    print(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
+                    logger.info(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
 
         # connection = pymysql.connect(**self.config)  # 连接数据库
         connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=10)
@@ -616,7 +617,7 @@ class MysqlUpload:
                     sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
                 cursor.execute(sql)
                 connection.commit()
-                print(f"创建Database: {db_name}")
+                logger.info(f"创建Database: {db_name}")
 
         self.config.update({'database': db_name})  # 添加更新 config 字段
         # connection = pymysql.connect(**self.config)  # 重新连接数据库
@@ -630,7 +631,7 @@ class MysqlUpload:
             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}')
+                logger.info(f'创建 mysql 表: {table_name}')
 
             # 根据 dict_data 的值添加指定的数据类型
             dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'varchar(100)',...}
@@ -654,13 +655,13 @@ class MysqlUpload:
                     else:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
                     # sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
-                    # print(sql)
+                    # logger.info(sql)
                     cursor.execute(sql)
-                    print(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
+                    logger.info(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
 
                     if col in main_key or col == '日期':
                         sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
-                        print(f"设置为索引: {col}({dtypes[col]})")
+                        logger.info(f"设置为索引: {col}({dtypes[col]})")
                         cursor.execute(sql)
                     if col in unique_main_key:
                         if dtypes[col] == 'mediumtext':
@@ -675,15 +676,15 @@ class MysqlUpload:
                     #     if not result:
                     #         if col in main_key:
                     #             sql = f"CREATE INDEX index_name ON `{table_name}`(`{col}`);"
-                    #             print(f"设置为索引: {col}({dtypes[col]})")
+                    #             logger.info(f"设置为索引: {col}({dtypes[col]})")
                     #             cursor.execute(sql)
                     #         elif col in unique_main_key:
                     #             if dtypes[col] == 'mediumtext':
                     #                 sql = f"CREATE INDEX UNIQUE index_name ON `{table_name}` (`{col}`({index_length}));"
                     #             else:
                     #                 sql = f"CREATE INDEX UNIQUE index_name ON `{table_name}` (`{col}`);"
-                    #             print(f"设置唯一索引: {col}({dtypes[col]})")
-                    #             print(sql)
+                    #             logger.info(f"设置唯一索引: {col}({dtypes[col]})")
+                    #             logger.info(sql)
                     #             cursor.execute(sql)
             connection.commit()  # 提交事务
             """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
@@ -704,7 +705,7 @@ class MysqlUpload:
                     condition += [f'`{up_col}` = "{dict_data[up_col]}"']
                 condition = ' AND '.join(condition)  # condition值示例: `品销宝余额` = '2930.73' AND `短信剩余` = '67471'
                 sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE {condition}"
-                # print(sql)
+                # logger.info(sql)
                 # sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE `创建时间` = '2014-09-19 14:32:33'"
                 cursor.execute(sql)
                 results = cursor.fetchall()  # results 是数据库取出的数据
@@ -723,7 +724,7 @@ class MysqlUpload:
                                 mysql_value = re.sub(r'0+$', '', mysql_value)
                                 mysql_value = re.sub(r'\.$', '', mysql_value)
                             if df_value != mysql_value:  # 传进来的数据和数据库比较, 有变化
-                                # print(f'{dict_data['日期']}{dict_data['商品id']}{col} 列的值有变化，{str(dict_data[col])}  !=  {str(result[col])}')
+                                # logger.info(f'{dict_data['日期']}{dict_data['商品id']}{col} 列的值有变化，{str(dict_data[col])}  !=  {str(result[col])}')
                                 change_values += [f"`{col}` = \"{str(dict_data[col])}\""]
                                 change_col.append(col)
                         not_change_col = [item for item in update_col if item not in change_col]
@@ -733,11 +734,11 @@ class MysqlUpload:
                                 not_change_values = [f'`{col}` = "{str(dict_data[col])}"' for col in not_change_col]
                                 not_change_values = ' AND '.join(
                                     not_change_values)  # 示例: `短信剩余` = '888' AND `test1` = '93'
-                                # print(change_values, not_change_values)
+                                # logger.info(change_values, not_change_values)
                                 condition += f' AND {not_change_values}'  # 重新构建完整的查询条件，将未发生变化的列加进查询条件
                             change_values = ', '.join(f"{item}" for item in change_values)  # 注意这里 item 外面没有反引号
                             sql = "UPDATE `%s` SET %s WHERE %s" % (table_name, change_values, condition)
-                            # print(sql)
+                            # logger.info(sql)
                             cursor.execute(sql)
                 else:  # 没有数据返回，则直接插入数据
                     cols = ', '.join(f"`{item}`" for item in dict_data.keys())  # 列名需要转义
@@ -765,7 +766,7 @@ class MysqlUpload:
 
             # 构建 sql
             sql = f"INSERT INTO %s (%s) VALUES (%s) ON DUPLICATE KEY UPDATE %s" % (table_name, keys_data, values_data, update_datas)
-            # print(sql)
+            # logger.info(sql)
             cursor.execute(sql)
             connection.commit()  # 提交数据库
         connection.close()
@@ -773,7 +774,7 @@ class MysqlUpload:
     def cover_dict_dtypes(self, dict_data):
         """ 清理字典键值 并转换数据类型  """
         if not dict_data:
-            print(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
+            logger.info(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
             return
         __res_dict = {}
         new_dict_data = {}
@@ -924,23 +925,23 @@ class MysqlUpload:
             return
         if icm_update:
             if move_insert or df_sql or drop_duplicates:
-                print(f'icm_update/move_insert/df_sql/drop_duplicates 参数不能同时设定')
+                logger.info(f'icm_update/move_insert/df_sql/drop_duplicates 参数不能同时设定')
                 return
         if move_insert:
             if icm_update or df_sql or drop_duplicates:
-                print(f'icm_update/move_insert/df_sql/drop_duplicates 参数不能同时设定')
+                logger.info(f'icm_update/move_insert/df_sql/drop_duplicates 参数不能同时设定')
                 return
 
         self.filename = filename
         if isinstance(df, pd.DataFrame):
             if len(df) == 0:
-                print(f'{db_name}: {table_name} 传入的 df 数据长度为0, {self.filename}')
+                logger.info(f'{db_name}: {table_name} 传入的 df 数据长度为0, {self.filename}')
                 return
         else:
-            print(f'{db_name}: {table_name} 传入的 df 不是有效的 dataframe 结构, {self.filename}')
+            logger.info(f'{db_name}: {table_name} 传入的 df 不是有效的 dataframe 结构, {self.filename}')
             return
         if not db_name or db_name == 'None':
-            print(f'{db_name} 不能为 None')
+            logger.info(f'{db_name} 不能为 None')
             return
 
         if cut_data:
@@ -956,9 +957,9 @@ class MysqlUpload:
                     elif str(cut_data).lower() == 'month':
                         table_name = f'{table_name}_{min_year}-{min_month}'
                     else:
-                        print(f'参数不正确，cut_data应为 year 或 month ')
+                        logger.info(f'参数不正确，cut_data应为 year 或 month ')
                 except Exception as e:
-                    print(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
+                    logger.info(f'{table_name} 将数据按年/月保存(cut_data)，但在转换日期时报错 -> {e}')
         # 清理 dataframe 非法值，并转换获取数据类型
         dtypes, df = self.convert_df_dtypes(df)
         if set_typ:
@@ -985,7 +986,7 @@ class MysqlUpload:
                     sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
                 cursor.execute(sql)
                 connection.commit()
-                print(f"创建Database: {db_name}")
+                logger.info(f"创建Database: {db_name}")
 
         self.config.update({'database': db_name})  # 添加更新 config 字段
         # connection = pymysql.connect(**self.config)  # 重新连接数据库
@@ -999,7 +1000,7 @@ class MysqlUpload:
             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}')
+                logger.info(f'创建 mysql 表: {table_name}')
 
             #  有特殊字符不需转义
             sql = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s;"
@@ -1017,7 +1018,7 @@ class MysqlUpload:
                     else:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
                     cursor.execute(sql)
-                    print(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
+                    logger.info(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
 
                     # 创建索引
                     if col == '日期':
@@ -1029,9 +1030,7 @@ class MysqlUpload:
             connection.commit()  # 提交事务
 
             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}')
+                logger.info(f'正在更新: 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')
@@ -1067,11 +1066,11 @@ class MysqlUpload:
                             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')
+                            # logger.info(f'重置自增id')
                         else:
-                            print(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
+                            logger.info(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
                     except Exception as e:
-                        print(f'333 {table_name} {e}')
+                        logger.info(f'333 {table_name} {e}')
                         connection.rollback()
                 connection.commit()  # 提交事务
                 connection.close()
@@ -1081,7 +1080,7 @@ class MysqlUpload:
             if move_insert and '日期' in df.columns.tolist():
                 # 移除数据
                 dates = df['日期'].values.tolist()
-                # print(dates)
+                # logger.info(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')
@@ -1123,11 +1122,11 @@ class MysqlUpload:
                         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')
+                        # logger.info(f'重置自增id')
                     else:
-                        print(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
+                        logger.info(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
                 except Exception as e:
-                    print(f'333 {table_name} {e}')
+                    logger.info(f'333 {table_name} {e}')
                     connection.rollback()
                 connection.close()
                 return
@@ -1144,20 +1143,20 @@ class MysqlUpload:
                     for k, v in data.items():
                         condition += [f'`{k}` = "{v}"']
                     condition = ' AND '.join(condition)  # 构建查询条件
-                    # print(condition)
+                    # logger.info(condition)
 
                     if drop_duplicates:  # 查重插入
                         sql = "SELECT %s FROM %s WHERE %s" % (cols, table_name, condition)
                         # sql = f"SELECT {cols} FROM `{table_name}` WHERE `创建时间` = '2014-09-19 14:32:33'"
                         cursor.execute(sql)
                         result = cursor.fetchall()  # 获取查询结果, 有结果返回 list 表示数据已存在(不重复插入)，没有则返回空 tuple
-                        # print(result)
+                        # logger.info(result)
                         if not result:  # 数据不存在则插入
                             sql = f"INSERT INTO `{table_name}` ({cols}) VALUES (%s);" % (values)
-                            # print(sql)
+                            # logger.info(sql)
                             cursor.execute(sql)
                         # else:
-                        #     print(f'重复数据不插入: {condition[:50]}...')
+                        #     logger.info(f'重复数据不插入: {condition[:50]}...')
                     elif icm_update:  # 增量更新, 专门用于聚合数据，其他库不要调用
                         """ 使用增量更新: 需确保 icm_update['主键'] 传进来的列必须是数据表中唯一主键，值不会发生变化且不会重复，否则可能产生覆盖情况 """
                         sql = 'SELECT COLUMN_NAME FROM information_schema.columns WHERE table_schema = %s AND table_name = %s'
@@ -1174,7 +1173,7 @@ class MysqlUpload:
                             condition += [f'`{up_col}` = "{data[up_col]}"']
                         condition = ' AND '.join(condition)  # condition值示例: `品销宝余额` = '2930.73' AND `短信剩余` = '67471'
                         sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE {condition}"
-                        # print(sql)
+                        # logger.info(sql)
                         # sql = f"SELECT {unique_keys} FROM `{table_name}` WHERE `创建时间` = '2014-09-19 14:32:33'"
                         cursor.execute(sql)
                         results = cursor.fetchall()  # results 是数据库取出的数据
@@ -1193,7 +1192,7 @@ class MysqlUpload:
                                         mysql_value = re.sub(r'0+$', '', mysql_value)
                                         mysql_value = re.sub(r'\.$', '', mysql_value)
                                     if df_value != mysql_value:  # 传进来的数据和数据库比较, 有变化
-                                        # print(f'{data['日期']}{data['商品id']}{col} 列的值有变化，{str(data[col])}  !=  {str(result[col])}')
+                                        # logger.info(f'{data['日期']}{data['商品id']}{col} 列的值有变化，{str(data[col])}  !=  {str(result[col])}')
                                         change_values += [f"`{col}` = \"{str(data[col])}\""]
                                         change_col.append(col)
                                 not_change_col = [item for item in update_col if item not in change_col]
@@ -1203,11 +1202,11 @@ class MysqlUpload:
                                         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'
-                                        # print(change_values, not_change_values)
+                                        # logger.info(change_values, not_change_values)
                                         condition += f' AND {not_change_values}'  # 重新构建完整的查询条件，将未发生变化的列加进查询条件
                                     change_values = ', '.join(f"{item}" for item in change_values)  # 注意这里 item 外面没有反引号
                                     sql = "UPDATE `%s` SET %s WHERE %s" % (table_name, change_values, condition)
-                                    # print(sql)
+                                    # logger.info(sql)
                                     cursor.execute(sql)
                         else:  # 没有数据返回，则直接插入数据
                             sql = f"INSERT INTO `{table_name}` ({cols}) VALUES ({values});"
@@ -1217,9 +1216,9 @@ class MysqlUpload:
                         cursor.execute(sql)
                 except Exception as e:
                     pass
-                    # print(data)
-                    # print(values)
-                    # print(f'mysql -> df_to_mysql 报错: {e}, {self.filename}')
+                    # logger.info(data)
+                    # logger.info(values)
+                    # logger.info(f'mysql -> df_to_mysql 报错: {e}, {self.filename}')
                     # breakpoint()
 
             if reset_id:
@@ -1246,11 +1245,11 @@ class MysqlUpload:
                         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')
+                        # logger.info(f'重置自增id')
                     else:
-                        print(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
+                        logger.info(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
                 except Exception as e:
-                    print(f'333 {table_name} {e}')
+                    logger.info(f'333 {table_name} {e}')
                     connection.rollback()
         connection.commit()  # 提交事务
         connection.close()
@@ -1265,7 +1264,7 @@ class MysqlUpload:
         save_path: 保存位置
         """
         if not filename:
-            print(f'未指定文件名: filename')
+            logger.info(f'未指定文件名: filename')
             return
         # connection = pymysql.connect(**self.config)  # 连接数据库
         connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=10)
@@ -1276,7 +1275,7 @@ class MysqlUpload:
             cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
             database_exists = cursor.fetchone()
             if not database_exists:
-                print(f"Database {db_name} 数据库不存在")
+                logger.info(f"Database {db_name} 数据库不存在")
                 return
         self.config.update({'database': db_name})
         # connection = pymysql.connect(**self.config)  # 重新连接数据库
@@ -1288,7 +1287,7 @@ class MysqlUpload:
             sql = "SHOW TABLES LIKE %s;"  # 有特殊字符不需转义
             cursor.execute(sql, (table_name))
             if not cursor.fetchone():
-                print(f'{table_name} -> 数据表不存在')
+                logger.info(f'{table_name} -> 数据表不存在')
                 return
 
             # 读取数据
@@ -1301,8 +1300,7 @@ class MysqlUpload:
                     # 将二进制数据写入到文件
                     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)}')
+                        logger.info(f'写入本地文件: ({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='日期'):
@@ -1320,11 +1318,10 @@ class MysqlUpload:
                 cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
                 database_exists = cursor.fetchone()
                 if not database_exists:
-                    print(f"Database {db_name} 数据库不存在")
+                    logger.info(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}')
+                    logger.info(f'mysql 正在查询表: {table_name}, 范围: {start_date}~{end_date}')
         except:
             return df
         finally:
@@ -1346,19 +1343,18 @@ class MysqlUpload:
                 columns = [desc[0] for desc in cursor.description]
                 df = pd.DataFrame(rows, columns=columns)  # 转为 df
         except Exception as e:
-            print(f'{e} {db_name} -> {table_name} 表不存在')
+            logger.info(f'{e} {db_name} -> {table_name} 表不存在')
             return df
         finally:
             connection.close()
 
         if len(df) == 0:
-            print(f'database: {db_name}, table: {table_name} 查询的数据为空')
+            logger.info(f'database: {db_name}, table: {table_name} 查询的数据为空')
         else:
-            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} 秒')
+            logger.info(f'mysql ({self.host}) 表: {table_name} 获取数据长度: {len(df)}, 用时: {cost_time} 秒')
         return df
 
     def upload_pandas(self, update_path, db_name, days=None):
@@ -1385,10 +1381,6 @@ class MysqlUpload:
                     for name in files:
                         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')
-                            #     continue
                             if '日期' in df.columns.tolist():
                                 df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
                                 df = df[df['日期'] >= start_date]
@@ -1398,10 +1390,6 @@ class MysqlUpload:
             elif os.path.isfile(f_path):
                 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')
-                    #     continue
                     if '日期' not in df.columns.tolist():
                         df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
                         df = df[df['日期'] >= start_date]
@@ -1449,14 +1437,14 @@ class OptimizeDatas:
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                print(f'{func.__name__}, {e}')  # 将异常信息返回
+                logger.info(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'函数注释内容(用于定位函数): {func.__doc__} \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}')
+                logger.info(f'更多信息请查看日志文件: {error_file}')
 
         return wrapper
 
@@ -1467,10 +1455,10 @@ class OptimizeDatas:
                 connection = pymysql.connect(**_config)  # 连接数据库
                 return connection
             except Exception as e:
-                print(f'连接失败，正在重试: {attempts}/{max_try} {e}')
+                logger.info(f'连接失败，正在重试: {attempts}/{max_try} {e}')
                 attempts += 1
                 time.sleep(30)
-        print(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
+        logger.info(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
         return None
 
     def optimize_list(self):
@@ -1479,8 +1467,7 @@ 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')
+            logger.info(f'尚未设置参数: self.db_name_lists')
             return
         for db_name in self.db_name_lists:
             self.db_name = db_name
@@ -1489,13 +1476,11 @@ 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')
+            logger.info(f'尚未设置参数: 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} -> 数据表不存在')
+            logger.info(f'{self.db_name} -> 数据表不存在')
             return
 
         # 日期初始化
@@ -1512,8 +1497,7 @@ 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} 天)...')
+        logger.info(f'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:
@@ -1525,12 +1509,11 @@ class OptimizeDatas:
                     return
                 with self.connection.cursor() as cursor:
                     sql = f"SELECT 1 FROM `{table_name}` LIMIT 1"
-                    # print(sql)
+                    # logger.info(sql)
                     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')
+                        logger.info(f'数据表: {table_name}, 数据长度为 0')
                         continue  # 检查数据表是否为空
 
                     cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")  # 查询数据表的列信息
@@ -1547,7 +1530,7 @@ class OptimizeDatas:
                         max_result = cursor.fetchone()
                         cursor.execute(sql_min)
                         min_result = cursor.fetchone()
-                        # print(min_result['min_date'], max_result['max_date'])
+                        # logger.info(min_result['min_date'], max_result['max_date'])
                         # 匹配修改为合适的起始和结束日期
                         if self.start_date < pd.to_datetime(min_result['min_date']):
                             self.start_date = pd.to_datetime(min_result['min_date'])
@@ -1585,15 +1568,14 @@ class OptimizeDatas:
                             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')
+                            # logger.info(f'重置自增id')
                         else:
-                            print(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
+                            logger.info(f'{table_name} 存在复合主键: {[item['PrimaryKey'] for item in result]}, 无法重置自增id')
                     except Exception as e:
-                        print(f'333 {table_name} {e}')
+                        logger.info(f'333 {table_name} {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} 数据库优化完成!')
+        logger.info(f'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)
@@ -1614,7 +1596,7 @@ class OptimizeDatas:
                     continue
                 all_datas.append(data)  # 数据没有重复
             except Exception as e:
-                print(f'{table_name} 函数: mysql - > OptimizeDatas -> delete_duplicate -> {e}')
+                logger.info(f'{table_name} 函数: mysql - > OptimizeDatas -> delete_duplicate -> {e}')
         del all_datas
 
         if not duplicate_id:  # 如果没有重复数据，则跳过该数据表
@@ -1626,11 +1608,10 @@ 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}")
+                logger.info(f"{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}')
+            logger.info(f'{self.db_name}/{table_name}, {e}')
             self.connection.rollback()  # 异常则回滚
 
     def delete_duplicate2(self, table_name, except_key=['更新时间']):
@@ -1664,12 +1645,11 @@ 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)}, "
+                logger.info(f"{table_name} -> before: {len(datas)}, "
                       f"remove: {cursor.rowcount}")
             self.connection.commit()  # 提交事务
         except Exception as e:
-            print(f'{self.db_name}/{table_name}, {e}')
+            logger.info(f'{self.db_name}/{table_name}, {e}')
             self.connection.rollback()  # 异常则回滚
 
     def database_list(self):
@@ -1695,11 +1675,10 @@ 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}: 数据表不存在!')
+                    logger.info(f'{db_name}: 数据表不存在!')
                     return
         except Exception as e:
-            print(f'002 {e}')
+            logger.info(f'002 {e}')
             return
         finally:
             connection.close()  # 断开连接
@@ -1730,7 +1709,7 @@ class OptimizeDatas:
                 cursor.execute(sql)
                 results = cursor.fetchall()
         except Exception as e:
-            print(f'001 {e}')
+            logger.info(f'001 {e}')
         finally:
             connection.close()
         return results
@@ -1784,7 +1763,7 @@ def year_month_day_bak(start_date, end_date):
     try:
         start_date = f'{pd.to_datetime(start_date).year}-{pd.to_datetime(start_date).month}-01'
     except Exception as e:
-        print(e)
+        logger.info(e)
         return []
     # 使用pandas的date_range创建一个日期范围，频率为'MS'代表每月开始
     date_range = pd.date_range(start=start_date, end=end_date, freq='MS')
@@ -1805,4 +1784,4 @@ if __name__ == '__main__':
     conf = myconfig.main()
     data = conf['Windows']['xigua_lx']['mysql']['local']
     username, password, host, port = data['username'], data['password'], data['host'], data['port']
-    print(username, password, host, port)
+    logger.info(username, password, host, port)