mdbq 4.0.58__tar.gz → 4.0.60__tar.gz

{mdbq-4.0.58 → mdbq-4.0.60}/PKG-INFO

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

mdbq-4.0.60/mdbq/__version__.py

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

{mdbq-4.0.58 → mdbq-4.0.60}/mdbq/mysql/uploader.py

@@ -348,6 +348,10 @@ class MySQLUploader:
             import hashlib
             hash_suffix = hashlib.md5(identifier.encode('utf-8')).hexdigest()[:8]
             cleaned = f'unknown_col_{hash_suffix}'
+        
+        # 确保标识符不以数字开头（MySQL要求）
+        if cleaned and cleaned[0].isdigit():
+            cleaned = f'col_{cleaned}'
         mysql_keywords = {
             'select', 'insert', 'update', 'delete', 'from', 'where', 'and', 'or',
             'not', 'like', 'in', 'is', 'null', 'true', 'false', 'between'
@@ -452,9 +456,33 @@ class MySQLUploader:
             
         # 处理主键
         if primary_keys and len(primary_keys) > 0:
-            # 如果指定了主键，直接使用指定的主键
-            safe_primary_keys = [_index_col_sql(pk) for pk in primary_keys]
-            primary_key_sql = f"PRIMARY KEY ({','.join(safe_primary_keys)})"
+            # 验证主键列是否存在于set_typ中
+            valid_primary_keys = []
+            for pk in primary_keys:
+                normalized_pk = self._normalize_col(pk)
+                if normalized_pk in set_typ:
+                    valid_primary_keys.append(pk)
+                else:
+                    logger.warning('主键列不存在于表结构中，跳过', {
+                        '库': db_name,
+                        '表': table_name,
+                        '列': pk,
+                        '规范化后': normalized_pk,
+                        '可用列': list(set_typ.keys())
+                    })
+            
+            if valid_primary_keys:
+                # 如果指定了主键，直接使用指定的主键
+                safe_primary_keys = [_index_col_sql(pk) for pk in valid_primary_keys]
+                primary_key_sql = f"PRIMARY KEY ({','.join(safe_primary_keys)})"
+            else:
+                # 如果没有有效的主键，使用id作为主键
+                logger.warning('所有主键列都不存在于表结构中，使用默认id主键', {
+                    '库': db_name,
+                    '表': table_name,
+                    '原始主键': primary_keys
+                })
+                primary_key_sql = f"PRIMARY KEY (`id`)"
         else:
             # 如果没有指定主键，使用id作为主键
             primary_key_sql = f"PRIMARY KEY (`id`)"
@@ -464,11 +492,40 @@ class MySQLUploader:
         if date_column and date_column in set_typ:
             safe_date_col = _index_col_sql(date_column)
             index_defs.append(f"INDEX `idx_{self._normalize_col(date_column)}` ({safe_date_col})")
+        
+        # 收集所有唯一约束中涉及的列，避免重复创建普通索引
+        unique_columns = set()
+        if unique_keys:
+            for unique_cols in unique_keys:
+                if unique_cols:
+                    for col in unique_cols:
+                        normalized_col = self._normalize_col(col)
+                        if normalized_col in set_typ:
+                            unique_columns.add(normalized_col)
+        
         if indexes:
             for idx_col in indexes:
-                if idx_col in set_typ:
+                normalized_idx_col = self._normalize_col(idx_col)
+                if normalized_idx_col in set_typ:
+                    # 检查是否与唯一约束冲突
+                    if normalized_idx_col in unique_columns:
+                        logger.warning('索引列已在唯一约束中定义，跳过普通索引', {
+                            '库': db_name,
+                            '表': table_name,
+                            '列': idx_col,
+                            '原因': '列已在唯一约束中定义'
+                        })
+                        continue
                     safe_idx_col = _index_col_sql(idx_col)
-                    index_defs.append(f"INDEX `idx_{self._normalize_col(idx_col)}` ({safe_idx_col})")
+                    index_defs.append(f"INDEX `idx_{normalized_idx_col}` ({safe_idx_col})")
+                else:
+                    logger.warning('索引列不存在于表结构中，跳过', {
+                        '库': db_name,
+                        '表': table_name,
+                        '列': idx_col,
+                        '规范化后': normalized_idx_col,
+                        '可用列': list(set_typ.keys())
+                    })
                     
         # UNIQUE KEY定义
         unique_defs = []
@@ -487,12 +544,48 @@ class MySQLUploader:
                             '主键': primary_keys
                         })
                         continue
-                safe_unique_cols = [_index_col_sql(col) for col in unique_cols]
-                unique_name = f"uniq_{'_'.join([self._normalize_col(c) for c in unique_cols])}"
+                
+                # 验证唯一约束的列是否存在于set_typ中
+                valid_unique_cols = []
+                for col in unique_cols:
+                    normalized_col = self._normalize_col(col)
+                    if normalized_col in set_typ:
+                        valid_unique_cols.append(col)
+                    else:
+                        logger.warning('唯一约束列不存在于表结构中，跳过', {
+                            '库': db_name,
+                            '表': table_name,
+                            '列': col,
+                            '规范化后': normalized_col,
+                            '可用列': list(set_typ.keys())
+                        })
+                
+                if not valid_unique_cols:
+                    logger.warning('唯一约束的所有列都不存在于表结构中，跳过整个约束', {
+                        '库': db_name,
+                        '表': table_name,
+                        '原始约束': unique_cols
+                    })
+                    continue
+                
+                safe_unique_cols = [_index_col_sql(col) for col in valid_unique_cols]
+                unique_name = f"uniq_{'_'.join([self._normalize_col(c) for c in valid_unique_cols])}"
                 unique_defs.append(f"UNIQUE KEY `{unique_name}` ({','.join(safe_unique_cols)})")
                 
         index_defs = list(set(index_defs))
         all_defs = column_defs + [primary_key_sql] + index_defs + unique_defs
+        
+        # 添加调试日志
+        logger.debug('建表SQL生成', {
+            '库': db_name,
+            '表': table_name,
+            '列定义': column_defs,
+            '主键': primary_key_sql,
+            '索引': index_defs,
+            '唯一约束': unique_defs,
+            'set_typ键': list(set_typ.keys())
+        })
+        
         sql = f"""
         CREATE TABLE IF NOT EXISTS `{db_name}`.`{table_name}` (
             {','.join(all_defs)}
@@ -1159,22 +1252,48 @@ class MySQLUploader:
         :param table_name: 表名
         :param data: 要上传的数据，支持字典、字典列表或DataFrame格式
         :param set_typ: 列名和数据类型字典 {列名: 数据类型}
-        :param primary_keys: 主键列列表，可选
+        :param primary_keys: 主键列列表，可选。格式：['col1', 'col2'] 或 None
         :param check_duplicate: 是否检查重复数据，默认为False
-        :param duplicate_columns: 用于检查重复的列，可选
+        :param duplicate_columns: 用于检查重复的列，可选。格式：['col1', 'col2'] 或 None
         :param allow_null: 是否允许空值，默认为False
         :param partition_by: 分表方式('year'、'month'、'None')，可选
         :param partition_date_column: 用于分表的日期列名，默认为'日期', 默认会添加为索引
         :param auto_create: 表不存在时是否自动创建，默认为True
-        :param indexes: 需要创建索引的列列表，可选
+        :param indexes: 需要创建索引的列列表，可选。格式：['col1', 'col2'] 或 None
         :param update_on_duplicate: 遇到重复数据时是否更新旧数据，默认为False
         :param transaction_mode: 事务模式，可选值：
             - 'row'     : 逐行提交事务（错误隔离性好）
             - 'batch'   : 整批提交事务（性能最优）
             - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
-        :param unique_keys: 唯一约束列表，每个元素为列名列表，支持多列组合唯一约束
+        :param unique_keys: 唯一约束列表，每个元素为列名列表，支持多列组合唯一约束。格式：[['col1', 'col2'], ['col3']] 或 None
         :raises: 可能抛出各种验证和数据库相关异常
 
+        ---
+        参数格式验证：
+
+        - primary_keys: 必须是字符串列表或None，如 ['col1', 'col2']
+        - indexes: 必须是字符串列表或None，如 ['col1', 'col2']
+        - unique_keys: 必须是嵌套列表或None，如 [['col1', 'col2'], ['col3']]
+        - 错误示例：unique_keys=['col1', 'col2'] (应该是 [['col1', 'col2']])
+        - 所有列名不能为空字符串，会自动去除首尾空格
+        - 重复的列名会被自动去重
+
+        空值处理规则：
+        - None: 直接返回None，忽略此参数
+        - []: 空列表，返回None，忽略此参数
+        - [[]]: 包含空列表，跳过空列表，如果最终为空则返回None
+        - ['']: 包含空字符串，抛出异常（不允许空字符串）
+        - ['   ']: 包含纯空白字符，抛出异常（不允许纯空白字符）
+        - ['', 'col1']: 混合空字符串和有效字符串，跳过空字符串，保留有效字符串
+
+        ---
+        关于 indexes 和 unique_keys 参数：
+
+        - indexes 创建普通索引，unique_keys 创建唯一约束
+        - 如果同一列同时出现在 indexes 和 unique_keys 中，系统会优先创建唯一约束，跳过普通索引
+        - 唯一约束本身就具有索引功能，因此不会重复创建普通索引
+        - 建议：如果某列需要唯一性约束，直接使用 unique_keys 参数，无需在 indexes 中重复指定
+
         ---
         unique_keys、check_duplicate、update_on_duplicate 三者组合下的行为总结：
 
@@ -1211,23 +1330,28 @@ class MySQLUploader:
             '批次': batch_id,
             '传入': len(data) if hasattr(data, '__len__') else 1,
             '参数': {
-                '主键': primary_keys,
+                '主键': validated_primary_keys,
                 '去重': check_duplicate,
                 '去重列': duplicate_columns,
                 '允许空值': allow_null,
                 '分表方式': partition_by,
                 '分表列': partition_date_column,
                 # '自动建表': auto_create,
-                '索引': indexes,
+                '索引': validated_indexes,
                 '更新旧数据': update_on_duplicate,
                 '事务模式': transaction_mode,
-                '唯一约束': unique_keys
+                '唯一约束': validated_unique_keys
             },
             # '数据样例': self._shorten_for_log(data, 2)
         })
 
         try:
-            # 验证参数
+            # 验证参数格式
+            validated_primary_keys = self._validate_primary_keys_format(primary_keys, db_name, table_name)
+            validated_indexes = self._validate_indexes_format(indexes, db_name, table_name)
+            validated_unique_keys = self._validate_unique_keys_format(unique_keys, db_name, table_name)
+            
+            # 验证分表参数
             if partition_by:
                 partition_by = str(partition_by).lower()
                 if partition_by not in ['year', 'month']:
@@ -1297,10 +1421,10 @@ class MySQLUploader:
                     try:
                         inserted, skipped, failed = self._upload_to_table(
                             db_name, part_table, part_data, filtered_set_typ,
-                            primary_keys, check_duplicate, duplicate_columns,
+                            validated_primary_keys, check_duplicate, duplicate_columns,
                             allow_null, auto_create, partition_date_column,
-                            indexes, batch_id, update_on_duplicate, transaction_mode,
-                            unique_keys
+                            validated_indexes, batch_id, update_on_duplicate, transaction_mode,
+                            validated_unique_keys
                         )
                         total_inserted += inserted
                         total_skipped += skipped
@@ -1324,10 +1448,10 @@ class MySQLUploader:
                 # 不分表，直接上传
                 inserted, skipped, failed = self._upload_to_table(
                     db_name, table_name, prepared_data, filtered_set_typ,
-                    primary_keys, check_duplicate, duplicate_columns,
+                    validated_primary_keys, check_duplicate, duplicate_columns,
                     allow_null, auto_create, partition_date_column,
-                    indexes, batch_id, update_on_duplicate, transaction_mode,
-                    unique_keys
+                    validated_indexes, batch_id, update_on_duplicate, transaction_mode,
+                    validated_unique_keys
                 )
                 total_inserted = inserted
                 total_skipped = skipped
@@ -1363,7 +1487,7 @@ class MySQLUploader:
             })
 
         # 更新索引
-        self._update_indexes(db_name, table_name, indexes)
+        self._update_indexes(db_name, table_name, validated_indexes)
         return True
 
     @_execute_with_retry
@@ -1762,6 +1886,7 @@ class MySQLUploader:
     def _update_indexes(self, db_name: str, table_name: str, indexes: Optional[List[str]]):
         """
         更新索引，避免重复添加或更新，同时注意大小写一致性。
+        注意：如果列已经在unique_keys中定义，则不会重复创建普通索引。
 
         :param db_name: 数据库名
         :param table_name: 表名
@@ -1773,7 +1898,7 @@ class MySQLUploader:
         # 规范化索引列名
         normalized_indexes = [self._normalize_col(idx) for idx in indexes]
 
-        # 获取现有索引
+        # 获取现有索引（包括普通索引和唯一约束）
         try:
             existing_indexes = self._get_existing_indexes(db_name, table_name)
         except Exception as e:
@@ -1782,13 +1907,20 @@ class MySQLUploader:
 
         # 获取表中现有的列名
         try:
-            existing_columns = self._get_existing_indexes(db_name, table_name)
+            existing_columns = self._get_table_columns(db_name, table_name)
         except Exception as e:
             logger.error('获取现有列时发生错误', {'库': db_name, '表': table_name, '错误': str(e)})
             raise
 
-        # 找出需要添加的索引
-        indexes_to_add = [idx for idx in normalized_indexes if idx not in existing_indexes and idx in existing_columns]
+        # 找出需要添加的索引（排除已存在的索引和不在表中的列）
+        indexes_to_add = []
+        for idx in normalized_indexes:
+            if idx not in existing_indexes and idx in existing_columns:
+                indexes_to_add.append(idx)
+            elif idx in existing_indexes:
+                logger.debug('索引已存在，跳过', {'库': db_name, '表': table_name, '列': idx})
+            elif idx not in existing_columns:
+                logger.warning('索引列不存在于表中，跳过', {'库': db_name, '表': table_name, '列': idx})
 
         # 添加新索引
         for idx in indexes_to_add:
@@ -1800,7 +1932,7 @@ class MySQLUploader:
 
     def _get_existing_indexes(self, db_name: str, table_name: str) -> Set[str]:
         """
-        获取表中现有的索引列名。
+        获取表中现有的索引列名（包括普通索引和唯一约束）。
 
         :param db_name: 数据库名
         :param table_name: 表名
@@ -1934,6 +2066,222 @@ class MySQLUploader:
                 conn.rollback()
             raise
 
+    def _validate_unique_keys_format(self, unique_keys: Optional[List[List[str]]], db_name: str = None, table_name: str = None) -> Optional[List[List[str]]]:
+        """
+        验证unique_keys参数的格式是否正确
+        
+        :param unique_keys: 唯一约束列表
+        :param db_name: 数据库名，用于日志记录
+        :param table_name: 表名，用于日志记录
+        :return: 验证后的unique_keys，如果验证失败则抛出异常
+        :raises ValueError: 当参数格式不正确时抛出
+        """
+        if unique_keys is None:
+            return None
+            
+        if not isinstance(unique_keys, list):
+            error_msg = f"unique_keys参数必须是列表类型，当前类型: {type(unique_keys).__name__}"
+            logger.error(error_msg, {'库': db_name, '表': table_name, 'unique_keys': unique_keys})
+            raise ValueError(error_msg)
+        
+        # 检查是否为空列表
+        if len(unique_keys) == 0:
+            logger.warning('unique_keys为空列表，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        validated_keys = []
+        empty_groups_count = 0
+        
+        for i, key_group in enumerate(unique_keys):
+            # 检查每个元素是否为列表
+            if not isinstance(key_group, list):
+                error_msg = f"unique_keys[{i}]必须是列表类型，当前类型: {type(key_group).__name__}，值: {key_group}"
+                logger.error(error_msg, {'库': db_name, '表': table_name, 'unique_keys': unique_keys})
+                raise ValueError(error_msg)
+            
+            # 检查是否为空列表
+            if len(key_group) == 0:
+                empty_groups_count += 1
+                logger.warning(f'unique_keys[{i}]为空列表，跳过', {'库': db_name, '表': table_name})
+                continue
+            
+            # 检查每个列名是否为字符串
+            validated_group = []
+            for j, col_name in enumerate(key_group):
+                if not isinstance(col_name, str):
+                    error_msg = f"unique_keys[{i}][{j}]必须是字符串类型，当前类型: {type(col_name).__name__}，值: {col_name}"
+                    logger.error(error_msg, {'库': db_name, '表': table_name, 'unique_keys': unique_keys})
+                    raise ValueError(error_msg)
+                
+                # 检查是否为空字符串或纯空白字符
+                stripped_name = col_name.strip()
+                if not stripped_name:
+                    error_msg = f"unique_keys[{i}][{j}]不能为空字符串或纯空白字符，原始值: '{col_name}'"
+                    logger.error(error_msg, {'库': db_name, '表': table_name, 'unique_keys': unique_keys})
+                    raise ValueError(error_msg)
+                
+                validated_group.append(stripped_name)
+            
+            # 去重并检查是否有重复列名
+            if len(validated_group) != len(set(validated_group)):
+                error_msg = f"unique_keys[{i}]中存在重复列名: {validated_group}"
+                logger.error(error_msg, {'库': db_name, '表': table_name, 'unique_keys': unique_keys})
+                raise ValueError(error_msg)
+            
+            validated_keys.append(validated_group)
+        
+        # 检查验证后的结果
+        if not validated_keys:
+            if empty_groups_count > 0:
+                logger.warning(f'unique_keys包含{empty_groups_count}个空列表，验证后为空，将忽略此参数', {
+                    '库': db_name, '表': table_name, '空列表数量': empty_groups_count
+                })
+            else:
+                logger.warning('unique_keys验证后为空，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        logger.debug('unique_keys格式验证通过', {
+            '库': db_name, 
+            '表': table_name, 
+            '原始': unique_keys, 
+            '验证后': validated_keys,
+            '跳过的空列表': empty_groups_count
+        })
+        return validated_keys
+
+    def _validate_indexes_format(self, indexes: Optional[List[str]], db_name: str = None, table_name: str = None) -> Optional[List[str]]:
+        """
+        验证indexes参数的格式是否正确
+        
+        :param indexes: 索引列列表
+        :param db_name: 数据库名，用于日志记录
+        :param table_name: 表名，用于日志记录
+        :return: 验证后的indexes，如果验证失败则抛出异常
+        :raises ValueError: 当参数格式不正确时抛出
+        """
+        if indexes is None:
+            return None
+            
+        if not isinstance(indexes, list):
+            error_msg = f"indexes参数必须是列表类型，当前类型: {type(indexes).__name__}"
+            logger.error(error_msg, {'库': db_name, '表': table_name, 'indexes': indexes})
+            raise ValueError(error_msg)
+        
+        # 检查是否为空列表
+        if len(indexes) == 0:
+            logger.warning('indexes为空列表，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        validated_indexes = []
+        empty_strings_count = 0
+        
+        for i, col_name in enumerate(indexes):
+            if not isinstance(col_name, str):
+                error_msg = f"indexes[{i}]必须是字符串类型，当前类型: {type(col_name).__name__}，值: {col_name}"
+                logger.error(error_msg, {'库': db_name, '表': table_name, 'indexes': indexes})
+                raise ValueError(error_msg)
+            
+            # 检查是否为空字符串或纯空白字符
+            stripped_name = col_name.strip()
+            if not stripped_name:
+                empty_strings_count += 1
+                logger.warning(f'indexes[{i}]为空字符串或纯空白字符，跳过，原始值: "{col_name}"', {
+                    '库': db_name, '表': table_name, 'indexes': indexes
+                })
+                continue
+            
+            validated_indexes.append(stripped_name)
+        
+        # 去重
+        validated_indexes = list(dict.fromkeys(validated_indexes))
+        
+        # 检查验证后的结果
+        if not validated_indexes:
+            if empty_strings_count > 0:
+                logger.warning(f'indexes包含{empty_strings_count}个空字符串，验证后为空，将忽略此参数', {
+                    '库': db_name, '表': table_name, '空字符串数量': empty_strings_count
+                })
+            else:
+                logger.warning('indexes验证后为空，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        logger.debug('indexes格式验证通过', {
+            '库': db_name, 
+            '表': table_name, 
+            '原始': indexes, 
+            '验证后': validated_indexes,
+            '跳过的空字符串': empty_strings_count
+        })
+        return validated_indexes
+
+    def _validate_primary_keys_format(self, primary_keys: Optional[List[str]], db_name: str = None, table_name: str = None) -> Optional[List[str]]:
+        """
+        验证primary_keys参数的格式是否正确
+        
+        :param primary_keys: 主键列列表
+        :param db_name: 数据库名，用于日志记录
+        :param table_name: 表名，用于日志记录
+        :return: 验证后的primary_keys，如果验证失败则抛出异常
+        :raises ValueError: 当参数格式不正确时抛出
+        """
+        if primary_keys is None:
+            return None
+            
+        if not isinstance(primary_keys, list):
+            error_msg = f"primary_keys参数必须是列表类型，当前类型: {type(primary_keys).__name__}"
+            logger.error(error_msg, {'库': db_name, '表': table_name, 'primary_keys': primary_keys})
+            raise ValueError(error_msg)
+        
+        # 检查是否为空列表
+        if len(primary_keys) == 0:
+            logger.warning('primary_keys为空列表，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        validated_keys = []
+        empty_strings_count = 0
+        
+        for i, col_name in enumerate(primary_keys):
+            if not isinstance(col_name, str):
+                error_msg = f"primary_keys[{i}]必须是字符串类型，当前类型: {type(col_name).__name__}，值: {col_name}"
+                logger.error(error_msg, {'库': db_name, '表': table_name, 'primary_keys': primary_keys})
+                raise ValueError(error_msg)
+            
+            # 检查是否为空字符串或纯空白字符
+            stripped_name = col_name.strip()
+            if not stripped_name:
+                empty_strings_count += 1
+                logger.warning(f'primary_keys[{i}]为空字符串或纯空白字符，跳过，原始值: "{col_name}"', {
+                    '库': db_name, '表': table_name, 'primary_keys': primary_keys
+                })
+                continue
+            
+            validated_keys.append(stripped_name)
+        
+        # 去重并检查是否有重复列名
+        if len(validated_keys) != len(set(validated_keys)):
+            error_msg = f"primary_keys中存在重复列名: {validated_keys}"
+            logger.error(error_msg, {'库': db_name, '表': table_name, 'primary_keys': primary_keys})
+            raise ValueError(error_msg)
+        
+        # 检查验证后的结果
+        if not validated_keys:
+            if empty_strings_count > 0:
+                logger.warning(f'primary_keys包含{empty_strings_count}个空字符串，验证后为空，将忽略此参数', {
+                    '库': db_name, '表': table_name, '空字符串数量': empty_strings_count
+                })
+            else:
+                logger.warning('primary_keys验证后为空，将忽略此参数', {'库': db_name, '表': table_name})
+            return None
+        
+        logger.debug('primary_keys格式验证通过', {
+            '库': db_name, 
+            '表': table_name, 
+            '原始': primary_keys, 
+            '验证后': validated_keys,
+            '跳过的空字符串': empty_strings_count
+        })
+        return validated_keys
+
 
 def main():
     dir_path = os.path.expanduser("~")
@@ -1969,7 +2317,120 @@ def main():
         {'日期': '2023-02-20', 'name': 'Bob', 'AGE': 25, 'salary': 45000.75},
     ]
 
-    # 上传数据
+    # 测试参数验证功能
+    print("=== 测试参数验证功能 ===")
+    
+    # 正确的格式
+    print("1. 测试正确的unique_keys格式:")
+    try:
+        valid_unique_keys = [['日期', 'name'], ['age']]
+        result = uploader._validate_unique_keys_format(valid_unique_keys, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+    
+    # 错误的格式 - 缺少一层嵌套
+    print("2. 测试错误的unique_keys格式 (缺少嵌套):")
+    try:
+        invalid_unique_keys = ['日期', 'name']  # 错误：应该是 [['日期', 'name']]
+        result = uploader._validate_unique_keys_format(invalid_unique_keys, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 错误的格式 - 包含非字符串元素
+    print("3. 测试错误的unique_keys格式 (非字符串元素):")
+    try:
+        invalid_unique_keys = [['日期', 123]]  # 错误：123不是字符串
+        result = uploader._validate_unique_keys_format(invalid_unique_keys, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 错误的格式 - 空字符串
+    print("4. 测试错误的unique_keys格式 (空字符串):")
+    try:
+        invalid_unique_keys = [['日期', '']]  # 错误：空字符串
+        result = uploader._validate_unique_keys_format(invalid_unique_keys, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 错误的格式 - 重复列名
+    print("5. 测试错误的unique_keys格式 (重复列名):")
+    try:
+        invalid_unique_keys = [['日期', '日期']]  # 错误：重复列名
+        result = uploader._validate_unique_keys_format(invalid_unique_keys, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 空值测试 - 空列表
+    print("6. 测试空值情况 - 空列表:")
+    try:
+        empty_list = []
+        result = uploader._validate_unique_keys_format(empty_list, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+    
+    # 空值测试 - 包含空列表
+    print("7. 测试空值情况 - 包含空列表 [[]]:")
+    try:
+        empty_nested = [[]]
+        result = uploader._validate_unique_keys_format(empty_nested, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+    
+    # 空值测试 - 混合空列表和有效列表
+    print("8. 测试空值情况 - 混合空列表和有效列表 [[], ['col1']]:")
+    try:
+        mixed_empty = [[], ['col1']]
+        result = uploader._validate_unique_keys_format(mixed_empty, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+    
+    # 空值测试 - 包含空字符串的列表
+    print("9. 测试空值情况 - 包含空字符串的列表 [[''], ['col1']]:")
+    try:
+        empty_string_list = [[''], ['col1']]
+        result = uploader._validate_unique_keys_format(empty_string_list, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 空值测试 - 包含纯空白字符的列表
+    print("10. 测试空值情况 - 包含纯空白字符的列表 [['   '], ['col1']]:")
+    try:
+        whitespace_list = [['   '], ['col1']]
+        result = uploader._validate_unique_keys_format(whitespace_list, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   正确捕获错误: {e}")
+    
+    # 测试indexes的空值处理
+    print("\n=== 测试indexes空值处理 ===")
+    print("11. 测试indexes包含空字符串 ['', 'col1']:")
+    try:
+        indexes_with_empty = ['', 'col1']
+        result = uploader._validate_indexes_format(indexes_with_empty, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+    
+    # 测试primary_keys的空值处理
+    print("12. 测试primary_keys包含空字符串 ['', 'col1']:")
+    try:
+        primary_keys_with_empty = ['', 'col1']
+        result = uploader._validate_primary_keys_format(primary_keys_with_empty, 'test_db', 'test_table')
+        print(f"   通过: {result}")
+    except Exception as e:
+        print(f"   失败: {e}")
+
+    # 上传数据（使用正确的格式）
+    print("\n=== 开始上传数据 ===")
     uploader.upload_data(
         db_name='测试库',
         table_name='测试表',
@@ -1984,7 +2445,7 @@ def main():
         partition_date_column='日期',  # 用于分表的日期列名，默认为'日期'
         indexes=[],  # 普通索引列
         transaction_mode='row',  # 事务模式
-        unique_keys=[['日期', 'name', 'age']],  # 唯一约束列表
+        unique_keys=[['日期', 'name', 'age']],  # 唯一约束列表 - 正确的格式
     )
 
     uploader.close()

{mdbq-4.0.58 → mdbq-4.0.60}/mdbq.egg-info/PKG-INFO

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

mdbq-4.0.58/mdbq/__version__.py

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