mdbq 4.1.9__tar.gz → 4.1.11__tar.gz

{mdbq-4.1.9 → mdbq-4.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mdbq
-Version: 4.1.9
+Version: 4.1.11
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

mdbq-4.1.11/mdbq/__version__.py

@@ -0,0 +1 @@
+VERSION = '4.1.11'

{mdbq-4.1.9 → mdbq-4.1.11}/mdbq/mysql/uploader.py

@@ -111,6 +111,7 @@ class MySQLUploader:
         :param read_timeout: 读取超时(秒)，默认为30
         :param write_timeout: 写入超时(秒)，默认为30
         :param ssl: SSL配置字典，默认为None
+        :param auto_creat_missing_cols: 自动添加缺失列，默认为False，建议手动维护表结构
         """
         self.username = username
         self.password = password
@@ -134,6 +135,7 @@ class MySQLUploader:
         self._table_metadata_cache = {}
         self.metadata_cache_ttl = 300  # 5分钟缓存时间
         self.pool = self._create_connection_pool()  # 创建连接池
+        self.auto_creat_missing_cols = False  # 自动添加缺失列，正常不要自动添加，建议手动维护表结构
 
     def _create_connection_pool(self) -> PooledDB:
         """
@@ -656,6 +658,58 @@ class MySQLUploader:
             logger.error('无效的日期格式', {'值': value})
         raise ValueError(f"无效的日期格式: `{value}`")
 
+    def _get_fallback_value(self, column_type_lower: str, allow_null: bool, db_name: str = None, table_name: str = None, col_name: str = None, original_value: Any = None) -> Any:
+        """
+        获取空值的兜底填充值
+        """
+        # 兜底填充值映射
+        fallback_map = {
+            'int': 0,
+            'bigint': 0,
+            'tinyint': 0,
+            'smallint': 0,
+            'mediumint': 0,
+            'decimal': 0.0,
+            'float': 0.0,
+            'double': 0.0,
+            'date': '1970-01-01',
+            'datetime': '1970-01-01 00:00:00',
+            'timestamp': '1970-01-01 00:00:00',
+            'json': '{}',
+            'varchar': 'none',
+            'text': 'none',
+            'char': 'none',
+            'mediumtext': 'none',
+            'longtext': 'none',
+            'enum': None,  # enum类型需要特殊处理，使用第一个可选值
+            'set': '',     # set类型默认为空字符串
+        }
+        
+        fallback = 'none'
+        for typ, val in fallback_map.items():
+            if typ in column_type_lower:
+                if typ == 'enum' and val is None:
+                    # 对于enum类型，使用第一个可选值作为默认值
+                    enum_values = re.findall(r"['\"]([^'\"]*)['\"]", column_type_lower)
+                    fallback = enum_values[0] if enum_values else 'none'
+                else:
+                    fallback = val
+                break
+        
+        if not allow_null:
+            # 注释掉，这里可能会产生大量日志
+            # logger.debug("该列不允许为空值", {
+            #     "库": db_name, 
+            #     "表": table_name, 
+            #     "allow_null": allow_null, 
+            #     "列": col_name, 
+            #     "值": original_value, 
+            #     "兜底值": fallback
+            # })
+            return fallback  # 直接返回兜底值
+        
+        return None  # 允许空值时返回None
+
     def _convert_to_int(self, value):
         """
         尝试将value转换为int
@@ -729,7 +783,34 @@ class MySQLUploader:
         """
         column_type_lower = column_type.lower() if column_type else ''
         
-        # JSON类型验证和转换（优先处理，避免pd.isna的问题）
+        # 统一的空值检查（None、空字符串、NaN）
+        is_empty_value = False
+        if value is None:
+            is_empty_value = True
+        elif value == '':
+            # 空字符串对于字符串类型是有效值
+            if any(t in column_type_lower for t in ['varchar', 'text', 'char', 'mediumtext', 'longtext']):
+                return ""
+            is_empty_value = True
+        else:
+            # 检查NaN值（避免对列表和字典使用pd.isna）
+            if not isinstance(value, (list, dict)):
+                try:
+                    is_empty_value = pd.isna(value) or (isinstance(value, (float, Decimal)) and math.isinf(value))
+                except (ValueError, TypeError):
+                    is_empty_value = False
+        
+        # 统一处理空值
+        if is_empty_value:
+            fallback_value = self._get_fallback_value(column_type_lower, allow_null, db_name, table_name, col_name, value)
+            # 如果返回了兜底值（非None），直接返回，不再进行后续验证
+            # 因为兜底值已经是根据列类型设计的合适值
+            if fallback_value is not None:
+                return fallback_value
+            # 如果返回None（允许空值的情况），继续后续处理
+            return None
+        
+        # JSON类型验证和转换
         if 'json' in column_type_lower:
             if isinstance(value, (dict, list)):
                 try:
@@ -748,59 +829,6 @@ class MySQLUploader:
             else:
                 # 其他类型转换为字符串
                 return str(value)
-        
-        # 统一判断None/NaN（排除列表和字典类型）
-        if value == '':
-            if any(t in column_type_lower for t in ['varchar', 'text', 'char', 'mediumtext', 'longtext']):
-                return ""
-        
-        # 安全地检查NaN值，避免对列表和字典使用pd.isna
-        is_nan = False
-        if isinstance(value, (list, dict)):
-            is_nan = False  # 列表和字典不是NaN
-        else:
-            try:
-                is_nan = pd.isna(value) or (isinstance(value, (float, Decimal)) and math.isinf(value))
-            except (ValueError, TypeError):
-                is_nan = False
-        
-        if value == '' or is_nan:
-            # 兜底填充值映射
-            fallback_map = {
-                'int': 0,
-                'bigint': 0,
-                'tinyint': 0,
-                'smallint': 0,
-                'mediumint': 0,
-                'decimal': 0.0,
-                'float': 0.0,
-                'double': 0.0,
-                'date': '1970-01-01',
-                'datetime': '1970-01-01 00:00:00',
-                'timestamp': '1970-01-01 00:00:00',
-                'json': '{}',
-                'varchar': 'none',
-                'text': 'none',
-                'char': 'none',
-                'mediumtext': 'none',
-                'longtext': 'none',
-                'enum': None,  # enum类型需要特殊处理，使用第一个可选值
-                'set': '',     # set类型默认为空字符串
-            }
-            fallback = 'none'
-            for typ, val in fallback_map.items():
-                if typ in column_type_lower:
-                    if typ == 'enum' and val is None:
-                        # 对于enum类型，使用第一个可选值作为默认值
-                        enum_values = re.findall(r"['\"]([^'\"]*)['\"]", column_type)
-                        fallback = enum_values[0] if enum_values else 'none'
-                    else:
-                        fallback = val
-                    break
-            if not allow_null:
-                logger.warning("该列不允许为空值", {"库": db_name, "表": table_name, "allow_null": allow_null, "列": col_name, "值": value, "兜底值": fallback})
-                raise ValueError("该列不允许为空值")
-            return fallback
 
         original_value = value
 
@@ -1053,14 +1081,41 @@ class MySQLUploader:
                 '列': self._shorten_for_log(table_columns),
             })
             raise ValueError(f"获取列失败 `{db_name}`.`{table_name}`")
-        for col in set_typ:
-            if col not in table_columns:
-                logger.error('列不存在', {
+        # 检查并自动添加缺失的列
+        missing_columns = [col for col in set_typ if col not in table_columns]
+        if missing_columns:
+            if not self.auto_creat_missing_cols:
+                logger.error('列不存在且不支持自动添加，请手动维护表结构，并补齐缺失列', {
                     '库': db_name,
                     '表': table_name,
-                    '列': col,
+                    '缺失列数': len(missing_columns),
+                    '缺失列': missing_columns,
                 })
-                raise ValueError(f"列不存在: `{col}` -> `{db_name}`.`{table_name}`")
+                raise ValueError(f"列不存在: `{missing_columns}` -> `{db_name}`.`{table_name}`")
+            else:
+                # 表有缺失列时报错，建议不允许自动添加，手动检查数据一致性，以免产生不必要的表错误
+                # 自动添加缺失的列
+                for col in missing_columns:
+                    try:
+                        self._add_column_to_table(db_name, table_name, col, set_typ[col], allow_null)
+                        logger.info('自动添加缺失列', {
+                            '库': db_name,
+                            '表': table_name,
+                            '列': col,
+                            '类型': set_typ[col]
+                        })
+                    except Exception as e:
+                        logger.error('添加列失败', {
+                            '库': db_name,
+                            '表': table_name,
+                            '列': col,
+                            '类型': set_typ[col],
+                            '错误': str(e)
+                        })
+                        raise ValueError(f"添加列失败: `{col}` -> `{db_name}`.`{table_name}`: {str(e)}")
+                
+                # 重新获取表列信息
+                table_columns = self._get_table_columns(db_name, table_name)
         if date_column and date_column in table_columns:
             try:
                 self._ensure_index(db_name, table_name, date_column)
@@ -1281,21 +1336,67 @@ class MySQLUploader:
                         prepared_row[col_name] = self._validate_value(None, filtered_set_typ[col_name], allow_null, db_name, table_name, col_name)
                     except ValueError as e:
                         if not allow_null:
-                            error_msg = f"行号:{row_idx} -> 缺失列: `{col_name}`, 且不允许空值"
-                            logger.error(error_msg, {'row': self._shorten_for_log(row)})
-                            raise ValueError(error_msg)
-                        prepared_row[col_name] = None
+                            # 如果不允许空值但验证失败，尝试使用兜底值
+                            try:
+                                fallback_value = self._get_fallback_value(filtered_set_typ[col_name].lower(), allow_null, db_name, table_name, col_name, None)
+                                if fallback_value is not None:
+                                    prepared_row[col_name] = fallback_value
+                                    logger.warning(f"行号:{row_idx} -> 缺失列: `{col_name}`, 使用兜底值: {fallback_value}", {'row': self._shorten_for_log(row)})
+                                else:
+                                    error_msg = f"行号:{row_idx} -> 缺失列: `{col_name}`, 且不允许空值"
+                                    logger.error(error_msg, {'row': self._shorten_for_log(row)})
+                                    raise ValueError(error_msg)
+                            except Exception:
+                                error_msg = f"行号:{row_idx} -> 缺失列: `{col_name}`, 且不允许空值"
+                                logger.error(error_msg, {'row': self._shorten_for_log(row)})
+                                raise ValueError(error_msg)
+                        else:
+                            prepared_row[col_name] = None
                 else:
                     try:
                         prepared_row[col_name] = self._validate_value(row[col_name], filtered_set_typ[col_name], allow_null, db_name, table_name, col_name)
                     except ValueError as e:
-                        logger.error('数据验证失败', {
-                            '列': col_name,
-                            '行': row_idx,
-                            '报错': str(e),
-                            'row': self._shorten_for_log(row),
-                        })
-                        raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
+                        # 如果数据验证失败，检查是否为空值且不允许空值，尝试使用兜底值
+                        original_value = row[col_name]
+                        is_empty_original = (original_value is None or 
+                                           original_value == '' or 
+                                           (not isinstance(original_value, (list, dict)) and 
+                                            pd.isna(original_value) if hasattr(pd, 'isna') else False))
+                        
+                        if is_empty_original and not allow_null:
+                            try:
+                                fallback_value = self._get_fallback_value(filtered_set_typ[col_name].lower(), allow_null, db_name, table_name, col_name, original_value)
+                                if fallback_value is not None:
+                                    prepared_row[col_name] = fallback_value
+                                    logger.warning(f"行:{row_idx}, 列:`{col_name}` -> 原值验证失败，使用兜底值: {fallback_value}", {
+                                        '原值': original_value,
+                                        '兜底值': fallback_value,
+                                        'row': self._shorten_for_log(row)
+                                    })
+                                else:
+                                    logger.error('数据验证失败', {
+                                        '列': col_name,
+                                        '行': row_idx,
+                                        '报错': str(e),
+                                        'row': self._shorten_for_log(row),
+                                    })
+                                    raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
+                            except Exception:
+                                logger.error('数据验证失败', {
+                                    '列': col_name,
+                                    '行': row_idx,
+                                    '报错': str(e),
+                                    'row': self._shorten_for_log(row),
+                                })
+                                raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
+                        else:
+                            logger.error('数据验证失败', {
+                                '列': col_name,
+                                '行': row_idx,
+                                '报错': str(e),
+                                'row': self._shorten_for_log(row),
+                            })
+                            raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
             prepared_data.append(prepared_row)
         return prepared_data, filtered_set_typ
 
@@ -2061,6 +2162,70 @@ class MySQLUploader:
         except Exception as e:
             logger.error('创建索引失败', {'库': db_name, '表': table_name, '列': column, '错误': str(e)})
             raise
+
+    @_execute_with_retry
+    def _add_column_to_table(self, db_name: str, table_name: str, column: str, column_type: str, allow_null: bool = False):
+        """
+        添加列到指定表。
+
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :param column: 需要添加的列名
+        :param column_type: 列的数据类型
+        :param allow_null: 是否允许空值，默认为False
+        """
+        db_name = self._validate_identifier(db_name, is_database=True)
+        table_name = self._validate_identifier(table_name)
+        column = self._validate_identifier(column)
+        
+        # 构建ALTER TABLE语句
+        null_constraint = "NULL" if allow_null else "NOT NULL"
+        
+        # 为新添加的列设置默认值
+        default_value = ""
+        if not allow_null:
+            column_type_lower = column_type.lower()
+            if any(t in column_type_lower for t in ['int', 'bigint', 'tinyint', 'smallint', 'mediumint']):
+                default_value = " DEFAULT 0"
+            elif any(t in column_type_lower for t in ['decimal', 'float', 'double']):
+                default_value = " DEFAULT 0.0"
+            elif any(t in column_type_lower for t in ['varchar', 'text', 'char', 'mediumtext', 'longtext']):
+                default_value = " DEFAULT 'none'"
+            elif 'date' in column_type_lower:
+                if 'datetime' in column_type_lower or 'timestamp' in column_type_lower:
+                    default_value = " DEFAULT '1970-01-01 00:00:00'"
+                else:
+                    default_value = " DEFAULT '1970-01-01'"
+            elif 'json' in column_type_lower:
+                default_value = " DEFAULT '{}'"
+        
+        sql = f'ALTER TABLE `{db_name}`.`{table_name}` ADD COLUMN `{column}` {column_type} {null_constraint}{default_value}'
+        
+        conn = None
+        try:
+            with self._get_connection() as conn:
+                with conn.cursor() as cursor:
+                    cursor.execute(sql)
+                conn.commit()
+                logger.debug('已为表添加列', {
+                    '库': db_name, 
+                    '表': table_name, 
+                    '列': column, 
+                    '类型': column_type,
+                    '允许空值': allow_null
+                })
+        except Exception as e:
+            logger.error('添加列失败', {
+                '库': db_name, 
+                '表': table_name, 
+                '列': column, 
+                '类型': column_type,
+                '错误': str(e),
+                'SQL': sql
+            })
+            if conn is not None:
+                conn.rollback()
+            raise
     
     def __enter__(self):
         return self

{mdbq-4.1.9 → mdbq-4.1.11}/mdbq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mdbq
-Version: 4.1.9
+Version: 4.1.11
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

mdbq-4.1.9/mdbq/__version__.py

@@ -1 +0,0 @@
-VERSION = '4.1.9'