mdbq 3.10.7__py3-none-any.whl → 3.10.9__py3-none-any.whl

mdbq/mysql/mysql.py

@@ -55,41 +55,61 @@ def count_decimal_places(num_str):
 
 
 class MysqlUpload:
+    """
+    MySQL 数据上传与表结构自动维护工具类。
+    支持字典/数据框批量插入、自动建表、自动补全字段、类型推断、增量更新等。
+    """
     def __init__(self, username: str, password: str, host: str, port: int, charset: str = 'utf8mb4'):
-        self.username = username
-        self.password = password
-        self.host = host
-        self.port = port
+        """
+        初始化 MysqlUpload 实例。
+        :param username: 数据库用户名
+        :param password: 数据库密码
+        :param host: 数据库主机
+        :param port: 数据库端口
+        :param charset: 字符集，默认 utf8mb4
+        """
+        self.username: str = username
+        self.password: str = password
+        self.host: str = host
+        self.port: int = port
         if username == '' or password == '' or host == '' or port == 0:
-            self.config = None
+            self.config: dict | None = None
         else:
-            self.config = {
+            self.config: dict = {
                 'host': self.host,
                 'port': int(self.port),
                 'user': self.username,
                 'password': self.password,
-                'charset': charset,  # utf8mb4 支持存储四字节的UTF-8字符集
+                'charset': charset,
                 'cursorclass': pymysql.cursors.DictCursor,
             }
-        self.filename = None
+        self.filename: str | None = None
 
     @staticmethod
-    def try_except(func):  # 在类内部定义一个异常处理方法
-
+    def try_except(func):
+        """
+        装饰器：捕获并记录函数异常。
+        """
         @wraps(func)
         def wrapper(*args, **kwargs):
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                logger.error(f'{func.__name__}, {e}')  # 将异常信息返回
-
+                logger.error(f'{func.__name__}, {e}')
         return wrapper
 
-    def keep_connect(self, _db_name, _config, max_try: int=10):
+    def keep_connect(self, _db_name: str, _config: dict, max_try: int = 10) -> pymysql.connections.Connection | None:
+        """
+        保持数据库连接，失败自动重试。
+        :param _db_name: 数据库名
+        :param _config: 连接配置
+        :param max_try: 最大重试次数
+        :return: 数据库连接对象或 None
+        """
         attempts = 1
         while attempts <= max_try:
             try:
-                connection = pymysql.connect(**_config)  # 连接数据库
+                connection = pymysql.connect(**_config)
                 return connection
             except Exception as e:
                 logger.error(f'{_db_name}: 连接失败，正在重试: {self.host}:{self.port}  {attempts}/{max_try} {e}')
@@ -98,13 +118,17 @@ class MysqlUpload:
         logger.error(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
         return None
 
-    def cover_doc_dtypes(self, dict_data):
-        """ 清理字典键值 并转换数据类型  """
+    def cover_doc_dtypes(self, dict_data: dict) -> tuple[dict, dict] | None:
+        """
+        清理字典键值并推断数据类型。
+        :param dict_data: 原始数据字典
+        :return: (字段类型字典, 清理后的数据字典)
+        """
         if not dict_data:
             logger.info(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
-            return
-        __res_dict = {}
-        new_dict_data = {}
+            return None
+        __res_dict: dict = {}
+        new_dict_data: dict = {}
         for k, v in dict_data.items():
             k = str(k).lower()
             k = re.sub(r'[()\-，,$&~^、 （）\"\'“”=·/。》《><！!`]', '_', k, re.IGNORECASE)
@@ -115,21 +139,20 @@ class MysqlUpload:
             result2 = re.findall(r'占比$|投产$|产出$|roi$|率$', k, re.IGNORECASE)
             result3 = re.findall(r'同比$|环比$', k, re.IGNORECASE)
             result4 = re.findall(r'花费$|消耗$|金额$', k, re.IGNORECASE)
-
-            date_type = otk.is_valid_date(v)  # 判断日期时间
-            int_num = otk.is_integer(v)  # 判断整数
-            count_int, count_float = count_decimal_places(v)  # 判断小数，返回小数位数
-            if result1:  # 京东sku/spu商品信息
+            date_type = otk.is_valid_date(v)
+            int_num = otk.is_integer(v)
+            count_int, count_float = count_decimal_places(v)
+            if result1:
                 __res_dict.update({k: 'varchar(100)'})
             elif k == '日期':
                 __res_dict.update({k: 'DATE'})
             elif k == '更新时间':
                 __res_dict.update({k: 'TIMESTAMP'})
-            elif result2:  # 小数
+            elif result2:
                 __res_dict.update({k: 'decimal(10,4)'})
-            elif date_type == 1:  # 纯日期
+            elif date_type == 1:
                 __res_dict.update({k: 'DATE'})
-            elif date_type == 2:  # 日期+时间
+            elif date_type == 2:
                 __res_dict.update({k: 'DATETIME'})
             elif int_num:
                 __res_dict.update({k: 'INT'})
@@ -152,14 +175,17 @@ class MysqlUpload:
         return __res_dict, new_dict_data
 
     @try_except
-    def insert_many_dict(self, db_name, table_name, dict_data_list, icm_update=None, index_length=100, set_typ=None, allow_not_null=False, cut_data=None):
+    def insert_many_dict(self, db_name: str, table_name: str, dict_data_list: list[dict], icm_update: list[str] = None, index_length: int = 100, set_typ: dict = None, allow_not_null: bool = False, cut_data: str = None) -> None:
         """
-        插入字典数据
-        dict_data： 字典
-        index_length: 索引长度
-        icm_update: 增量更正
-        set_typ: {}
-        allow_not_null: 创建允许插入空值的列，正常情况下不允许空值
+        批量插入字典数据，自动建表、补全字段、类型推断。
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :param dict_data_list: 字典数据列表
+        :param icm_update: 增量更新主键列名列表
+        :param index_length: 索引长度
+        :param set_typ: 自定义字段类型
+        :param allow_not_null: 是否允许字段为NULL
+        :param cut_data: 按年或月分表
         """
         if not self.config:
             return
@@ -321,14 +347,17 @@ class MysqlUpload:
         connection.close()
 
     # @try_except
-    def dict_to_mysql(self, db_name, table_name, dict_data, icm_update=None, index_length=100, set_typ=None, allow_not_null=False, cut_data=None):
+    def dict_to_mysql(self, db_name: str, table_name: str, dict_data: dict, icm_update: list[str] = None, index_length: int = 100, set_typ: dict = None, allow_not_null: bool = False, cut_data: str = None) -> None:
         """
-        插入字典数据
-        dict_data： 字典
-        index_length: 索引长度
-        icm_update: 增量更新
-        set_typ: {}
-        allow_not_null: 创建允许插入空值的列，正常情况下不允许空值
+        插入单条字典数据，自动建表、补全字段、类型推断。
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :param dict_data: 单条字典数据
+        :param icm_update: 增量更新主键列名列表
+        :param index_length: 索引长度
+        :param set_typ: 自定义字段类型
+        :param allow_not_null: 是否允许字段为NULL
+        :param cut_data: 按年或月分表
         """
         if not self.config:
             return
@@ -394,6 +423,7 @@ class MysqlUpload:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]};"
                     else:
                         sql = f"ALTER TABLE `{table_name}` ADD COLUMN `{col}` {dtypes[col]} NOT NULL;"
+
                     cursor.execute(sql)
                     logger.info(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
 
@@ -402,80 +432,93 @@ class MysqlUpload:
                         logger.info(f"设置为索引: {col}({dtypes[col]})")
                         cursor.execute(sql)
             connection.commit()  # 提交事务
-            """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-            """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+
             # 处理插入的数据
-            if icm_update:
-                """ 使用增量更新: 需确保 icm_update['主键'] 传进来的列组合是数据表中唯一，值不会发生变化且不会重复，否则可能产生覆盖 """
-                sql = """SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s"""
-                cursor.execute(sql, (db_name, table_name))
-                cols_exist = [col['COLUMN_NAME'] for col in cursor.fetchall()] # 数据表的所有列, 返回 list
-
-                # 保留原始列名，不提前转义
-                raw_update_col = [item for item in cols_exist if item not in icm_update and item != 'id']
-
-                # 构建条件参数（使用原始列名）
-                condition_params = []
-                condition_parts = []
-                for up_col in icm_update:
-                    condition_parts.append(f"`{up_col}` = %s")  # SQL 转义
-                    condition_params.append(dict_data[up_col])  # 原始列名访问数据
-
-                # 动态转义列名生成 SQL 查询字段
-                escaped_update_col = [f'`{col}`' for col in raw_update_col]
-                sql = f"""SELECT {','.join(escaped_update_col)} FROM `{table_name}` WHERE {' AND '.join(condition_parts)}"""
-                cursor.execute(sql, condition_params)
-                results = cursor.fetchall()
+            datas = [dict_data]
+            for dict_data in datas:
+                dtypes, dict_data = self.cover_dict_dtypes(dict_data=dict_data)  # {'店铺名称': 'varchar(100)',...}
+                if icm_update:
+                    """ 使用增量更新: 需确保 icm_update['主键'] 传进来的列组合是数据表中唯一，值不会发生变化且不会重复，否则可能产生覆盖 """
+                    sql = 'SELECT COLUMN_NAME FROM information_schema.columns WHERE table_schema = %s AND table_name = %s'
+                    cursor.execute(sql, (db_name, table_name))
+                    columns = cursor.fetchall()
+                    cols_exist = [col['COLUMN_NAME'] for col in columns]  # 数据表的所有列, 返回 list
+                    # 保留原始列名，不提前转义
+                    raw_update_col = [item for item in cols_exist if item not in icm_update and item != 'id']  # 除了主键外的其他列
 
-                if results:
-                    for result in results:
-                        change_col = []
-                        change_placeholders = []
-                        set_params = []
-                        for raw_col in raw_update_col:
-                            # 使用原始列名访问数据
-                            df_value = str(dict_data[raw_col])
-                            mysql_value = str(result[raw_col])
-
-                            # 清理小数点后多余的零
-                            if '.' in df_value:
-                                df_value = re.sub(r'0+$', '', df_value).rstrip('.')
-                            if '.' in mysql_value:
-                                mysql_value = re.sub(r'0+$', '', mysql_value).rstrip('.')
-
-                            if df_value != mysql_value:
-                                change_placeholders.append(f"`{raw_col}` = %s")  # 动态转义列名
-                                set_params.append(dict_data[raw_col])
-                                change_col.append(raw_col)
-
-                        if change_placeholders:
-                            full_params = set_params + condition_params
-                            sql = f"""UPDATE `{table_name}` 
-                                         SET {','.join(change_placeholders)} 
-                                         WHERE {' AND '.join(condition_parts)}"""
-                            cursor.execute(sql, full_params)
-                else:  # 没有数据返回，则直接插入数据
-                    # 参数化插入语句
-                    keys = [f"`{k}`" for k in dict_data.keys()]
-                    placeholders = ','.join(['%s'] * len(dict_data))
-                    update_clause = ','.join([f"`{k}`=VALUES(`{k}`)" for k in dict_data.keys()])
-                    sql = f"""INSERT INTO `{table_name}` ({','.join(keys)}) VALUES ({placeholders}) ON DUPLICATE KEY UPDATE {update_clause}"""
-                    cursor.execute(sql, tuple(dict_data.values()))
-                connection.commit()  # 提交数据库
-                connection.close()
-                return
+                    # 构建条件参数（使用原始列名）
+                    condition_params = []
+                    condition_parts = []
+                    for up_col in icm_update:
+                        condition_parts.append(f"`{up_col}` = %s")  # SQL 转义
+                        condition_params.append(dict_data[up_col])  # 原始列名用于访问数据
+
+                    # 动态转义列名生成 SQL 查询字段
+                    escaped_update_col = [f'`{col}`' for col in raw_update_col]
+                    sql = f"""SELECT {','.join(escaped_update_col)} FROM `{table_name}` WHERE {' AND '.join(condition_parts)}"""
+                    cursor.execute(sql, condition_params)
+                    results = cursor.fetchall()
+
+                    if results:
+                        for result in results:
+                            change_col = []
+                            change_placeholders = []
+                            set_params = []
+                            for raw_col in raw_update_col:
+                                # 使用原始列名访问数据
+                                df_value = str(dict_data[raw_col])
+                                mysql_value = str(result[raw_col])
+
+                                # 清理小数点后多余的零
+                                if '.' in df_value:
+                                    df_value = re.sub(r'0+$', '', df_value).rstrip('.')
+                                if '.' in mysql_value:
+                                    mysql_value = re.sub(r'0+$', '', mysql_value).rstrip('.')
+
+                                if df_value != mysql_value:
+                                    change_placeholders.append(f"`{raw_col}` = %s")  # 动态转义列名
+                                    set_params.append(dict_data[raw_col])
+                                    change_col.append(raw_col)
 
-            # 常规插入处理（参数化）
-            keys = [f"`{k}`" for k in dict_data.keys()]
-            placeholders = ','.join(['%s'] * len(dict_data))
-            update_clause = ','.join([f"`{k}`=VALUES(`{k}`)" for k in dict_data.keys()])
-            sql = f"""INSERT INTO `{table_name}` ({','.join(keys)}) VALUES ({placeholders}) ON DUPLICATE KEY UPDATE {update_clause}"""
-            cursor.execute(sql, tuple(dict_data.values()))
-            connection.commit()
+                            if change_placeholders:
+                                full_params = set_params + condition_params
+                                sql = f"""UPDATE `{table_name}` 
+                                             SET {','.join(change_placeholders)} 
+                                             WHERE {' AND '.join(condition_parts)}"""
+                                cursor.execute(sql, full_params)
+                    else:  # 没有数据返回，则直接插入数据
+                        # 参数化插入
+                        cols = ', '.join([f'`{k}`' for k in dict_data.keys()])
+                        placeholders = ', '.join(['%s'] * len(dict_data))
+                        sql = f"INSERT INTO `{table_name}` ({cols}) VALUES ({placeholders})"
+                        cursor.execute(sql, tuple(dict_data.values()))
+                    connection.commit()  # 提交数据库
+                    continue
+
+                # 标准插入逻辑（参数化修改）
+                # 构造更新列（排除主键）
+                update_cols = [k for k in dict_data.keys()]
+                # 构建SQL
+                cols = ', '.join([f'`{k}`' for k in dict_data.keys()])
+                placeholders = ', '.join(['%s'] * len(dict_data))
+                update_clause = ', '.join([f'`{k}` = VALUES(`{k}`)' for k in update_cols]) or 'id=id'
+
+                sql = f"""INSERT INTO `{table_name}` ({cols}) VALUES ({placeholders}) ON DUPLICATE KEY UPDATE {update_clause}"""
+                # 执行参数化查询
+                try:
+                    cursor.execute(sql, tuple(dict_data.values()))
+                    connection.commit()
+                except pymysql.Error as e:
+                    logger.error(f"插入失败: {e}\nSQL: {cursor.mogrify(sql, tuple(dict_data.values()))}")
+                    connection.rollback()
         connection.close()
 
-    def cover_dict_dtypes(self, dict_data):
-        """ 清理字典键值 并转换数据类型  """
+    def cover_dict_dtypes(self, dict_data: dict) -> tuple[dict, dict] | None:
+        """
+        清理字典键值并推断数据类型。
+        :param dict_data: 原始数据字典
+        :return: (字段类型字典, 清理后的数据字典)
+        """
         if not dict_data:
             logger.info(f'mysql.py -> MysqlUpload -> cover_dict_dtypes -> 传入的字典不能为空')
             return
@@ -536,8 +579,12 @@ class MysqlUpload:
             new_dict_data.update({k: v})
         return __res_dict, new_dict_data
 
-    def convert_df_dtypes(self, df: pd.DataFrame):
-        """ 清理 df 的值和列名，并转换数据类型 """
+    def convert_df_dtypes(self, df: pd.DataFrame) -> tuple[dict, pd.DataFrame]:
+        """
+        清理 DataFrame 的值和列名，并推断数据类型。
+        :param df: 原始 DataFrame
+        :return: (字段类型字典, 清理后的 DataFrame)
+        """
         df = otk.cover_df(df=df)  # 清理 df 的值和列名
         [pd.to_numeric(df[col], errors='ignore') for col in df.columns.tolist()]
         dtypes = df.dtypes.to_dict()
@@ -573,18 +620,20 @@ class MysqlUpload:
         return __res_dict, df
 
     @try_except
-    def df_to_mysql(self, df, db_name, table_name, set_typ=None, icm_update=[], move_insert=False, df_sql=False,
-                    filename=None, count=None, allow_not_null=False, cut_data=None):
+    def df_to_mysql(self, df: pd.DataFrame, db_name: str, table_name: str, set_typ: dict = None, icm_update: list[str] = [], move_insert: bool = False, df_sql: bool = False, filename: str = None, count: int = None, allow_not_null: bool = False, cut_data: str = None) -> None:
         """
-        db_name: 数据库名
-        table_name: 表名
-        move_insert: 根据df 的日期，先移除数据库数据，再插入, df_sql, icm_update 都要设置为 False
-        原则上只限于聚合数据使用，原始数据插入时不要设置
-        df_sql: 这是一个临时参数, 值为 True 时使用 df.to_sql 函数上传整个表, 不会排重，初创表大量上传数据的时候使用
-        icm_update: 增量更新, 在聚合数据中使用，原始文件不要使用
-                使用增量更新: 必须确保 icm_update 传进来的列必须是数据表中唯一主键，值不会发生变化，不会重复，否则可能产生错乱覆盖情况
-        filename: 用来追踪处理进度，传这个参数是方便定位产生错误的文件
-        allow_not_null: 创建允许插入空值的列，正常情况下不允许空值
+        DataFrame 批量上传到 MySQL，自动建表、补全字段、类型推断。
+        :param df: DataFrame
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :param set_typ: 自定义字段类型
+        :param icm_update: 增量更新主键列名列表
+        :param move_insert: 是否先删除再插入
+        :param df_sql: 是否用 to_sql 批量插入
+        :param filename: 进度追踪文件名
+        :param count: 进度计数
+        :param allow_not_null: 是否允许字段为NULL
+        :param cut_data: 按年或月分表
         """
         if not self.config:
             return
@@ -659,7 +708,7 @@ class MysqlUpload:
                 cursor.execute(create_table_sql)
                 logger.info(f'创建 mysql 表: {table_name}')
 
-            #  有特殊字符不需转义
+            # 有特殊字符不需转义
             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()]
@@ -809,52 +858,67 @@ class MysqlUpload:
 
 class OptimizeDatas:
     """
-    数据维护 删除 mysql 的冗余数据
-    更新过程:
+    数据维护类：用于删除 MySQL 的冗余数据。
+    更新过程：
     1. 读取所有数据表
-    2. 遍历表, 遍历列, 如果存在日期列则按天遍历所有日期, 不存在则全表读取
-    3. 按天删除所有冗余数据(存在日期列时)
-    tips: 查找冗余数据的方式是创建一个临时迭代器, 逐行读取数据并添加到迭代器, 出现重复时将重复数据的 id 添加到临时列表, 按列表 id 执行删除
+    2. 遍历表，遍历列，如果存在日期列则按天遍历所有日期，不存在则全表读取
+    3. 按天删除所有冗余数据（存在日期列时）
+    tips: 查找冗余数据的方式是创建一个临时迭代器，逐行读取数据并添加到迭代器，出现重复时将重复数据的 id 添加到临时列表，按列表 id 执行删除
     """
     def __init__(self, username: str, password: str, host: str, port: int, charset: str = 'utf8mb4'):
-        self.username = username
-        self.password = password
-        self.host = host
-        self.port = port  # 默认端口, 此后可能更新，不作为必传参数
-        self.charset = charset
-        self.config = {
+        """
+        初始化 OptimizeDatas 实例。
+        :param username: 数据库用户名
+        :param password: 数据库密码
+        :param host: 数据库主机
+        :param port: 数据库端口
+        :param charset: 字符集，默认 utf8mb4
+        """
+        self.username: str = username
+        self.password: str = password
+        self.host: str = host
+        self.port: int = port
+        self.charset: str = charset
+        self.config: dict = {
             'host': self.host,
             'port': int(self.port),
             'user': self.username,
             'password': self.password,
-            'charset': self.charset,  # utf8mb4 支持存储四字节的UTF-8字符集
+            'charset': self.charset,
             'cursorclass': pymysql.cursors.DictCursor,
         }
-        self.db_name_lists: list = []  # 更新多个数据库 删除重复数据
-        self.db_name = None
+        self.db_name_lists: list[str] = []  # 需要优化的数据库名列表
+        self.db_name: str | None = None
         self.days: int = 63  # 对近 N 天的数据进行排重
-        self.end_date = None
-        self.start_date = None
-        self.connection = None
+        self.end_date: pd.Timestamp | None = None
+        self.start_date: pd.Timestamp | None = None
+        self.connection: pymysql.connections.Connection | None = None
 
     @staticmethod
-    def try_except(func):  # 在类内部定义一个异常处理方法
-
+    def try_except(func):
+        """
+        装饰器：捕获并记录函数异常。
+        """
         @wraps(func)
         def wrapper(*args, **kwargs):
             try:
                 return func(*args, **kwargs)
             except Exception as e:
-                logger.error(f'{func.__name__}, {e}')  # 将异常信息返回
-
+                logger.error(f'{func.__name__}, {e}')
         return wrapper
 
-    def keep_connect(self, _db_name, _config, max_try: int=10):
+    def keep_connect(self, _db_name: str, _config: dict, max_try: int = 10) -> pymysql.connections.Connection | None:
+        """
+        保持数据库连接，失败自动重试。
+        :param _db_name: 数据库名
+        :param _config: 连接配置
+        :param max_try: 最大重试次数
+        :return: 数据库连接对象或 None
+        """
         attempts = 1
         while attempts <= max_try:
             try:
-                connection = pymysql.connect(**_config)  # 连接数据库
-                return connection
+                return pymysql.connect(**_config)
             except Exception as e:
                 logger.error(f'{_db_name}连接失败，正在重试: {self.host}:{self.port}  {attempts}/{max_try} {e}')
                 attempts += 1
@@ -862,10 +926,10 @@ class OptimizeDatas:
         logger.error(f'{_db_name}: 连接失败，重试次数超限，当前设定次数: {max_try}')
         return None
 
-    def optimize_list(self):
+    def optimize_list(self) -> None:
         """
-        更新多个数据库 移除冗余数据
-        需要设置 self.db_name_lists
+        批量优化多个数据库，移除冗余数据。
+        需要设置 self.db_name_lists。
         """
         if not self.db_name_lists:
             logger.info(f'尚未设置参数: self.db_name_lists')
@@ -874,8 +938,11 @@ class OptimizeDatas:
             self.db_name = db_name
             self.optimize()
 
-    def optimize(self, except_key=['更新时间']):
-        """ 更新一个数据库 移除冗余数据 """
+    def optimize(self, except_key: list[str] = ['更新时间']) -> None:
+        """
+        优化当前数据库，移除冗余数据。
+        :param except_key: 排除的字段名列表，默认['更新时间']
+        """
         if not self.db_name:
             logger.info(f'尚未设置参数: self.db_name')
             return
@@ -883,7 +950,6 @@ class OptimizeDatas:
         if not tables:
             logger.info(f'{self.db_name} -> 数据表不存在')
             return
-
         # 日期初始化
         if not self.end_date:
             self.end_date = pd.to_datetime(datetime.datetime.today())
@@ -897,212 +963,202 @@ class OptimizeDatas:
             self.start_date = pd.to_datetime(self.start_date)
         start_date_before = self.start_date
         end_date_before = self.end_date
-
         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():
-                self.config.update({'database': self.db_name})  # 添加更新 config 字段
-                self.connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=10)
+            for _, table_name in table_dict.items():
+                self.config.update({'database': self.db_name})
+                self.connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=5)
                 if not self.connection:
-                    return
+                    continue
                 with self.connection.cursor() as cursor:
-                    sql = f"SELECT 1 FROM `{table_name}` LIMIT 1"
-                    cursor.execute(sql)
-                    result = cursor.fetchone()
-                    if not result:
+                    cursor.execute(f"SELECT 1 FROM `{table_name}` LIMIT 1")
+                    if not cursor.fetchone():
                         logger.info(f'数据表: {table_name}, 数据长度为 0')
-                        continue  # 检查数据表是否为空
-
-                    cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")  # 查询数据表的列信息
+                        continue
+                    cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")
                     columns = cursor.fetchall()
-                    date_exist = False
-                    for col in columns:  # 遍历列信息，检查是否存在类型为日期的列
-                        if col['Field'] == '日期' and (col['Type'] == 'date' or col['Type'].startswith('datetime')):
-                            date_exist = True
-                            break
-                    if date_exist:  # 存在日期列
-                        sql_max = f"SELECT MAX(日期) AS max_date FROM `{table_name}`"
-                        sql_min = f"SELECT MIN(日期) AS min_date FROM `{table_name}`"
-                        cursor.execute(sql_max)
-                        max_result = cursor.fetchone()
-                        cursor.execute(sql_min)
-                        min_result = cursor.fetchone()
-                        # 匹配修改为合适的起始和结束日期
-                        if self.start_date < pd.to_datetime(min_result['min_date']):
-                            self.start_date = pd.to_datetime(min_result['min_date'])
-                        if self.end_date > pd.to_datetime(max_result['max_date']):
-                            self.end_date = pd.to_datetime(max_result['max_date'])
+                    date_exist = any(col['Field'] == '日期' and (col['Type'] == 'date' or col['Type'].startswith('datetime')) for col in columns)
+                    if date_exist:
+                        cursor.execute(f"SELECT MAX(日期) AS max_date, MIN(日期) AS min_date FROM `{table_name}`")
+                        result = cursor.fetchone()
+                        min_date = result['min_date']
+                        max_date = result['max_date']
+                        if min_date and self.start_date < pd.to_datetime(min_date):
+                            self.start_date = pd.to_datetime(min_date)
+                        if max_date and self.end_date > pd.to_datetime(max_date):
+                            self.end_date = pd.to_datetime(max_date)
                         dates_list = self.day_list(start_date=self.start_date, end_date=self.end_date)
-                        # dates_list 是日期列表
                         for date in dates_list:
                             self.delete_duplicate(table_name=table_name, date=date, except_key=except_key)
-                        self.start_date = start_date_before  # 重置，不然日期错乱
+                        self.start_date = start_date_before
                         self.end_date = end_date_before
-                    else:  # 不存在日期列的情况
+                    else:
                         self.delete_duplicate2(table_name=table_name, except_key=except_key)
                 self.connection.close()
         logger.info(f'mysql({self.host}: {self.port}) {self.db_name} 数据库优化完成!')
 
-    def delete_duplicate(self, table_name, date, except_key=['更新时间']):
+    def delete_duplicate(self, table_name: str, date: pd.Timestamp, except_key: list[str] = ['更新时间']) -> None:
+        """
+        删除指定表指定日期的冗余数据。
+        :param table_name: 表名
+        :param date: 日期
+        :param except_key: 排除的字段名列表
+        """
         datas = self.table_datas(db_name=self.db_name, table_name=str(table_name), date=date)
         if not datas:
             return
-        duplicate_id = []  # 出现重复的 id
-        all_datas = []  # 迭代器
+        duplicate_id: set = set()
+        all_datas: set = set()
         for data in datas:
-            for e_key in except_key:
-                if e_key in data.keys():  # 在检查重复数据时，不包含 更新时间 字段
-                    del data[e_key]
-            try:
-                delete_id = data['id']
-                del data['id']
-                data = re.sub(r'\.0+\', ', '\', ', str(data))  # 统一移除小数点后面的 0
-                if data in all_datas:  # 数据出现重复时
-                    if delete_id:
-                        duplicate_id.append(delete_id)  # 添加 id 到 duplicate_id
-                        continue
-                all_datas.append(data)  # 数据没有重复
-            except Exception as e:
-                logger.debug(f'{table_name} 函数: mysql - > OptimizeDatas -> delete_duplicate -> {e}')
-        del all_datas
-
-        if not duplicate_id:  # 如果没有重复数据，则跳过该数据表
+            data_no_id = {k: v for k, v in data.items() if k not in except_key and k != 'id'}
+            data_tuple = tuple(sorted(data_no_id.items()))
+            delete_id = data.get('id')
+            if data_tuple in all_datas:
+                if delete_id:
+                    duplicate_id.add(delete_id)
+            else:
+                all_datas.add(data_tuple)
+        if not duplicate_id:
             return
-
         try:
             with self.connection.cursor() as cursor:
                 placeholders = ', '.join(['%s'] * len(duplicate_id))
-                # 移除冗余数据
                 sql = f"DELETE FROM `{table_name}` WHERE id IN ({placeholders})"
-                cursor.execute(sql, duplicate_id)
+                cursor.execute(sql, list(duplicate_id))
                 logger.debug(f"{table_name} -> {date.strftime('%Y-%m-%d')} before: {len(datas)}, remove: {cursor.rowcount}")
-            self.connection.commit()  # 提交事务
+            self.connection.commit()
         except Exception as e:
             logger.error(f'{self.db_name}/{table_name}, {e}')
-            self.connection.rollback()  # 异常则回滚
+            self.connection.rollback()
 
-    def delete_duplicate2(self, table_name, except_key=['更新时间']):
+    def delete_duplicate2(self, table_name: str, except_key: list[str] = ['更新时间']) -> None:
+        """
+        删除指定表（无日期列）的冗余数据。
+        :param table_name: 表名
+        :param except_key: 排除的字段名列表
+        """
         with self.connection.cursor() as cursor:
-            sql = f"SELECT * FROM `{table_name}`"  # 如果不包含日期列，则获取全部数据
-            cursor.execute(sql)
+            cursor.execute(f"SELECT * FROM `{table_name}`")
             datas = cursor.fetchall()
         if not datas:
             return
-        duplicate_id = []  # 出现重复的 id
-        all_datas = []  # 迭代器
+        duplicate_id: set = set()
+        all_datas: set = set()
         for data in datas:
-            for e_key in except_key:
-                if e_key in data.keys():  # 在检查重复数据时，不包含 更新时间 字段
-                    del data[e_key]
-            delete_id = data['id']
-            del data['id']
-            data = re.sub(r'\.0+\', ', '\', ', str(data))  # 统一移除小数点后面的 0
-            if data in all_datas:  # 数据出现重复时
-                duplicate_id.append(delete_id)  # 添加 id 到 duplicate_id
-                continue
-            all_datas.append(data)  # 数据没有重复
-        del all_datas
-
-        if not duplicate_id:  # 如果没有重复数据，则跳过该数据表
+            data_no_id = {k: v for k, v in data.items() if k not in except_key and k != 'id'}
+            data_tuple = tuple(sorted(data_no_id.items()))
+            delete_id = data.get('id')
+            if data_tuple in all_datas:
+                if delete_id:
+                    duplicate_id.add(delete_id)
+            else:
+                all_datas.add(data_tuple)
+        if not duplicate_id:
             return
-
         try:
             with self.connection.cursor() as cursor:
                 placeholders = ', '.join(['%s'] * len(duplicate_id))
-                # 移除冗余数据
                 sql = f"DELETE FROM `{table_name}` WHERE id IN ({placeholders})"
-                cursor.execute(sql, duplicate_id)
-                logger.info(f"{table_name} -> before: {len(datas)}, "
-                      f"remove: {cursor.rowcount}")
-            self.connection.commit()  # 提交事务
+                cursor.execute(sql, list(duplicate_id))
+                logger.info(f"{table_name} -> before: {len(datas)}, remove: {cursor.rowcount}")
+            self.connection.commit()
         except Exception as e:
             logger.error(f'{self.db_name}/{table_name}, {e}')
-            self.connection.rollback()  # 异常则回滚
+            self.connection.rollback()
 
-    def database_list(self):
-        """ 获取所有数据库 """
-        connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=10)
+    def database_list(self) -> list[dict] | None:
+        """
+        获取所有数据库名。
+        :return: 数据库名列表
+        """
+        connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=5)
         if not connection:
-            return
+            return None
         with connection.cursor() as cursor:
             cursor.execute("SHOW DATABASES")
-            databases = cursor.fetchall()  # 获取所有数据库的结果
+            databases = cursor.fetchall()
         connection.close()
         return databases
 
-    def table_list(self, db_name):
-        """ 获取指定数据库的所有数据表 """
-        connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=10)
+    def table_list(self, db_name: str) -> list[dict] | None:
+        """
+        获取指定数据库的所有数据表。
+        :param db_name: 数据库名
+        :return: 数据表名列表
+        """
+        connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=5)
         if not connection:
-            return
+            return None
         try:
             with connection.cursor() as cursor:
-                cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
+                cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")
                 database_exists = cursor.fetchone()
                 if not database_exists:
                     logger.info(f'{db_name}: 数据表不存在!')
-                    return
+                    return None
         except Exception as e:
             logger.error(f'002 {e}')
-            return
+            return None
         finally:
-            connection.close()  # 断开连接
-
-        self.config.update({'database': db_name})  # 添加更新 config 字段
-        connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=10)
+            connection.close()
+        self.config.update({'database': db_name})
+        connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=5)
         if not connection:
-            return
+            return None
         with connection.cursor() as cursor:
             cursor.execute("SHOW TABLES")
-            tables = cursor.fetchall()  # 获取所有数据表
+            tables = cursor.fetchall()
         connection.close()
         return tables
 
-    def table_datas(self, db_name, table_name, date):
+    def table_datas(self, db_name: str, table_name: str, date: pd.Timestamp) -> list[dict]:
         """
-        获取指定数据表的数据, 按天获取
+        获取指定表指定日期的数据。
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :param date: 日期
+        :return: 数据列表
         """
-        self.config.update({'database': db_name})  # 添加更新 config 字段
-        connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=10)
+        self.config.update({'database': db_name})
+        connection = self.keep_connect(_db_name=db_name, _config=self.config, max_try=5)
         if not connection:
-            return
+            return []
         try:
             with connection.cursor() as cursor:
-                sql = f"SELECT * FROM `{table_name}` WHERE {'日期'} BETWEEN '%s' AND '%s'" % (date, date)
-                cursor.execute(sql)
+                sql = f"SELECT * FROM `{table_name}` WHERE 日期 = %s"
+                cursor.execute(sql, (date,))
                 results = cursor.fetchall()
         except Exception as e:
             logger.error(f'001 {e}')
+            results = []
         finally:
             connection.close()
         return results
 
-    def day_list(self, start_date, end_date):
+    def day_list(self, start_date: pd.Timestamp, end_date: pd.Timestamp) -> list[pd.Timestamp]:
+        """
+        生成日期范围内的所有日期列表。
+        :param start_date: 起始日期
+        :param end_date: 结束日期
+        :return: 日期列表
+        """
         start_date = pd.to_datetime(start_date)
         end_date = pd.to_datetime(end_date)
-        date_list = []
-        while start_date <= end_date:
-            date_list.append(pd.to_datetime(start_date.date()))
-            start_date += datetime.timedelta(days=1)
-        return date_list
-
-    def rename_column(self):
-        """ 批量修改数据库的列名 """
+        return [start_date + datetime.timedelta(days=i) for i in range((end_date - start_date).days + 1)]
+
+    def rename_column(self) -> None:
         """
-        # for db_name in ['京东数据2', '推广数据2', '市场数据2', '生意参谋2', '生意经2', '属性设置2',]:
-        #     s = OptimizeDatas(username=username, password=password, host=host, port=port)
-        #     s.db_name = db_name
-        #     s.rename_column()
+        批量修改数据库的列名，去除结尾的下划线。
         """
         tables = self.table_list(db_name=self.db_name)
-        for table_dict in tables:
-            for key, table_name in table_dict.items():
-                self.config.update({'database': self.db_name})  # 添加更新 config 字段
-                self.connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=10)
+        for table_dict in tables or []:
+            for _, table_name in table_dict.items():
+                self.config.update({'database': self.db_name})
+                self.connection = self.keep_connect(_db_name=self.db_name, _config=self.config, max_try=5)
                 if not self.connection:
-                    return
+                    continue
                 with self.connection.cursor() as cursor:
-                    cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")  # 查询数据表的列信息
+                    cursor.execute(f"SHOW FULL COLUMNS FROM `{table_name}`")
                     columns = cursor.fetchall()
                     columns = [{column['Field']: column['Type']} for column in columns]
                     for column in columns: