mdbq 4.1.11__tar.gz → 4.1.13__tar.gz

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

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

mdbq-4.1.13/mdbq/__version__.py

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

{mdbq-4.1.11 → mdbq-4.1.13}/mdbq/mysql/deduplicator.py

@@ -1364,12 +1364,12 @@ def main():
         skip_system_dbs=True,
         max_retries=3,
         retry_waiting_time=5,
-        pool_size=20,
-        mincached=5,
-        maxcached=10,
+        pool_size=10,
+        mincached=2,
+        maxcached=5,
         # recent_month=1,
         # date_range=['2025-06-09', '2025-06-10'],
-        exclude_columns=['更新时间'],
+        exclude_columns=['创建时间', '更新时间'],
         exclude_databases=['cookie文件', '日志', '视频数据', '云电影'],
         # exclude_tables={
         #     '推广数据2': [
@@ -1391,9 +1391,9 @@ def main():
 
     # # 指定表去重(使用特定列)
     deduplicator.deduplicate_table(
-        '生意参谋3', 
-        '新品追踪_旧接口_2025', 
-        columns=['商品id', '累计商品浏览量', '累计商品访客数'], 
+        '推广数据_奥莱店', 
+        '主体报表_2025', 
+        columns=['日期', '店铺名称', '场景id', '计划id', '主体id'], 
         dry_run=False, 
         reorder_id=True,
         )

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

@@ -435,15 +435,36 @@ class MySQLUploader:
         if not primary_keys:
             column_defs.append("`id` INT NOT NULL AUTO_INCREMENT")
         
-        # 添加其他列
+        # 添加其他列，确保时间戳字段按正确顺序添加
+        timestamp_cols = ['创建时间', '更新时间']
+        regular_cols = []
+        timestamp_defs = []
+        
+        # 先处理非时间戳字段
         for col_name, col_type in set_typ.items():
             if col_name == 'id':
                 continue
+            if col_name in timestamp_cols:
+                continue  # 时间戳字段稍后按顺序处理
+            
             safe_col_name = self._normalize_col(col_name)
             col_def = f"`{safe_col_name}` {col_type}"
-            if not allow_null and not col_type.lower().startswith('json'):
+            if not allow_null and not col_type.lower().startswith('json') and not col_type.lower().startswith('timestamp'):
                 col_def += " NOT NULL"
-            column_defs.append(col_def)
+            regular_cols.append(col_def)
+        
+        # 按固定顺序添加时间戳字段
+        for timestamp_col in timestamp_cols:
+            if timestamp_col in set_typ:
+                safe_col_name = self._normalize_col(timestamp_col)
+                col_type = set_typ[timestamp_col]
+                col_def = f"`{safe_col_name}` {col_type}"
+                # TIMESTAMP字段不需要额外的NOT NULL，因为已经包含在类型定义中
+                timestamp_defs.append(col_def)
+        
+        # 合并所有列定义：常规字段 + 时间戳字段
+        column_defs.extend(regular_cols)
+        column_defs.extend(timestamp_defs)
             
         # 主键处理逻辑调整
         def _index_col_sql(col):
@@ -672,9 +693,9 @@ class MySQLUploader:
             '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',
+            'date': '2000-01-01',
+            'datetime': '2000-01-01 00:00:00',
+            'timestamp': '2000-01-01 00:00:00',
             'json': '{}',
             'varchar': 'none',
             'text': 'none',
@@ -783,6 +804,12 @@ class MySQLUploader:
         """
         column_type_lower = column_type.lower() if column_type else ''
         
+        # 对于包含CURRENT_TIMESTAMP的TIMESTAMP字段，跳过验证，让MySQL自动处理
+        if ('timestamp' in column_type_lower and 'current_timestamp' in column_type_lower and 
+            col_name in ['创建时间', '更新时间']):
+            # 这些字段由MySQL自动处理，不需要传入值
+            return None
+        
         # 统一的空值检查（None、空字符串、NaN）
         is_empty_value = False
         if value is None:
@@ -1219,12 +1246,17 @@ class MySQLUploader:
             set_typ: Dict[str, str],
             allow_null: bool = False,
             db_name: str = None, 
-            table_name: str = None, 
+            table_name: str = None,
+            auto_timestamps: bool = False
     ) -> Tuple[List[Dict], Dict[str, str]]:
         """
         准备要上传的数据，验证并转换数据类型
         根据set_typ自动处理所有数据类型的列：补齐缺失的列并丢弃多余的列
         """
+        # 处理自动时间戳功能
+        if auto_timestamps:
+            data, set_typ = self._process_auto_timestamps(data, set_typ, db_name, table_name)
+        
         # set_typ的键清洗
         if not set_typ:
             set_typ = {}
@@ -1330,50 +1362,79 @@ class MySQLUploader:
                 # 跳过id列，不允许外部传入id
                 if (self.case_sensitive and col_name == 'id') or (not self.case_sensitive and col_name.lower() == 'id'):
                     continue
+                # 对于自动时间戳字段，使用特殊标记让MySQL使用DEFAULT值
+                col_type_lower = filtered_set_typ[col_name].lower()
+                is_auto_timestamp = ('timestamp' in col_type_lower and 'current_timestamp' in col_type_lower and 
+                                   col_name in ['创建时间', '更新时间'])
+                
                 if col_name not in row:
                     # 对于缺失的列，使用None作为默认值，在_validate_value中会根据allow_null和列类型进行进一步处理
-                    try:
-                        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:
-                            # 如果不允许空值但验证失败，尝试使用兜底值
-                            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:
+                    if is_auto_timestamp:
+                        # 自动时间戳字段使用特殊标记
+                        prepared_row[col_name] = 'DEFAULT'
+                    else:
+                        try:
+                            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:
+                                # 如果不允许空值但验证失败，尝试使用兜底值
+                                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)
-                            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:
+                                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:
-                        # 如果数据验证失败，检查是否为空值且不允许空值，尝试使用兜底值
-                        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:
+                    if is_auto_timestamp:
+                        # 自动时间戳字段忽略用户传入的值，使用DEFAULT
+                        prepared_row[col_name] = 'DEFAULT'
+                        if row[col_name] is not None:  # 如果用户传入了值，给出警告
+                            logger.warning('忽略自动时间戳字段的用户传入值', {
+                                '库': db_name,
+                                '表': table_name,
+                                '列': col_name,
+                                '用户值': row[col_name],
+                                '原因': '将使用MySQL CURRENT_TIMESTAMP'
+                            })
+                    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:
+                            # 如果数据验证失败，检查是否为空值且不允许空值，尝试使用兜底值
+                            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,
@@ -1381,7 +1442,7 @@ class MySQLUploader:
                                         'row': self._shorten_for_log(row),
                                     })
                                     raise ValueError(f"行:{row_idx}, 列:`{col_name}`-> 报错: {str(e)}")
-                            except Exception:
+                            else:
                                 logger.error('数据验证失败', {
                                     '列': col_name,
                                     '行': row_idx,
@@ -1389,15 +1450,7 @@ class MySQLUploader:
                                     '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)
+                prepared_data.append(prepared_row)
         return prepared_data, filtered_set_typ
 
     def upload_data(
@@ -1416,7 +1469,8 @@ class MySQLUploader:
             indexes: Optional[List[str]] = None,
             update_on_duplicate: bool = False,
             transaction_mode: str = "batch",
-            unique_keys: Optional[List[List[str]]] = None
+            unique_keys: Optional[List[List[str]]] = None,
+            auto_timestamps: bool = False
     ):
         """
         上传数据到数据库的主入口方法
@@ -1439,6 +1493,7 @@ class MySQLUploader:
             - 'batch'   : 整批提交事务（性能最优）
             - 'hybrid'  : 混合模式（每N行提交，平衡性能与安全性）
         :param unique_keys: 唯一约束列表，每个元素为列名列表，支持多列组合唯一约束。格式：[['col1', 'col2'], ['col3']] 或 None
+        :param auto_timestamps: 是否自动添加创建时间和更新时间列，默认为False。启用后会自动添加'创建时间'和'更新时间'两列
         :raises: 可能抛出各种验证和数据库相关异常
 
         ---
@@ -1483,6 +1538,17 @@ class MySQLUploader:
         - 只要 update_on_duplicate=True 且表存在唯一约束（如 unique_keys），无论 check_duplicate 是否为 True，都会更新旧数据（即 ON DUPLICATE KEY UPDATE 生效）。
         - 如需"覆盖"行为，务必设置 update_on_duplicate=True，不管 check_duplicate 是否为 True。
         - 如需"跳过"行为，设置 update_on_duplicate=False 即可。
+
+        ---
+        auto_timestamps 参数：
+
+        - 当 auto_timestamps=True 时，系统会自动添加'创建时间'和'更新时间'两列
+        - 如果原始数据中已存在这两列，系统会先移除原始数据中的这些列，然后添加新的时间戳
+        - '创建时间'：记录数据首次插入的时间，使用当前时间戳
+        - '更新时间'：记录数据最后更新的时间，插入时与创建时间相同，更新时会自动更新为当前时间
+        - 时间戳列的数据类型为 DATETIME，格式为 'YYYY-MM-DD HH:MM:SS'
+        - 这两列会自动添加到 set_typ 中，无需手动指定
+        - 建议在需要审计数据变更历史的表中启用此功能
         """
         # upload_start = time.time()
         # 检查data参数是否为None
@@ -1492,7 +1558,7 @@ class MySQLUploader:
                 '表': table_name,
             })
             raise ValueError("data参数不能为None，请传入有效的数据")
-            
+        
         if isinstance(data, list) or (hasattr(data, 'shape') and hasattr(data, '__len__')):
             initial_row_count = len(data)
         else:
@@ -1553,7 +1619,7 @@ class MySQLUploader:
                     raise ValueError("分表方式必须是 'year' 或 'month' 或 'None'")
 
             # 准备数据
-            prepared_data, filtered_set_typ = self._prepare_data(data, set_typ, allow_null, db_name, table_name)
+            prepared_data, filtered_set_typ = self._prepare_data(data, set_typ, allow_null, db_name, table_name, auto_timestamps)
 
             # 检查数据库是否存在
             if not self._check_database_exists(db_name):
@@ -1890,6 +1956,49 @@ class MySQLUploader:
                     return str(value)
             return value
         
+        def execute_single_row_with_defaults(row):
+            """处理单行插入，支持DEFAULT字段"""
+            has_defaults = any(row.get(col) == 'DEFAULT' for col in all_columns)
+            
+            if has_defaults:
+                # 分离普通字段和DEFAULT字段
+                regular_columns = []
+                regular_values = []
+                default_columns = []
+                
+                for col in all_columns:
+                    val = row.get(col)
+                    if val == 'DEFAULT':
+                        default_columns.append(col)
+                    else:
+                        regular_columns.append(col)
+                        regular_values.append(ensure_basic_type(val))
+                
+                # 构建INSERT ... SET语句
+                set_clauses = []
+                for col in regular_columns:
+                    set_clauses.append(f"`{self._validate_identifier(col)}` = %s")
+                for col in default_columns:
+                    set_clauses.append(f"`{self._validate_identifier(col)}` = DEFAULT")
+                
+                if set_clauses:
+                    dynamic_sql = f"INSERT INTO `{db_name}`.`{table_name}` SET {', '.join(set_clauses)}"
+                    if update_on_duplicate and regular_columns:
+                        update_clauses = [f"`{self._validate_identifier(col)}` = VALUES(`{self._validate_identifier(col)}`)" for col in regular_columns]
+                        if update_clauses:
+                            dynamic_sql += f" ON DUPLICATE KEY UPDATE {', '.join(update_clauses)}"
+                    
+                    cursor.execute(dynamic_sql, regular_values)
+                    return cursor.rowcount if cursor.rowcount is not None else 0
+            else:
+                # 没有DEFAULT字段，使用原有逻辑
+                values = [ensure_basic_type(row.get(col)) for col in all_columns]
+                if check_duplicate and not update_on_duplicate:
+                    dup_cols = duplicate_columns if duplicate_columns else [col for col in all_columns if col.lower() not in self.base_excute_col]
+                    values += [ensure_basic_type(row.get(col)) for col in dup_cols]
+                cursor.execute(sql, values)
+                return cursor.rowcount if cursor.rowcount is not None else 0
+        
         batch_size = get_optimal_batch_size(len(data))
         all_columns = [col for col in set_typ.keys() if col.lower() != 'id']
         total_inserted = 0
@@ -1900,50 +2009,72 @@ class MySQLUploader:
                 if transaction_mode == 'batch':
                     for i in range(0, len(data), batch_size):
                         batch = data[i:i + batch_size]
-                        values_list = []
-                        for row in batch:
-                            values = [ensure_basic_type(row.get(col)) for col in all_columns]
-                            if check_duplicate and not update_on_duplicate:
-                                dup_cols = duplicate_columns if duplicate_columns else [col for col in all_columns if col.lower() not in self.base_excute_col]
-                                values += [ensure_basic_type(row.get(col)) for col in dup_cols]
-                            values_list.append(values)
-                        try:
-                            cursor.executemany(sql, values_list)
+                        # 检查是否有DEFAULT字段，如果有则需要特殊处理
+                        has_default_fields = any(row.get(col) == 'DEFAULT' for row in batch for col in all_columns)
+                        
+                        if has_default_fields:
+                            # 对于包含DEFAULT字段的情况，逐行处理
+                            for row in batch:
+                                try:
+                                    affected = execute_single_row_with_defaults(row)
+                                    if update_on_duplicate:
+                                        total_inserted += 1
+                                    else:
+                                        if affected > 0:
+                                            total_inserted += 1
+                                        else:
+                                            total_skipped += 1
+                                except pymysql.err.IntegrityError:
+                                    total_skipped += 1
+                                except Exception as e:
+                                    total_failed += 1
+                                    logger.error('单行插入失败', {
+                                        '库': db_name, 
+                                        '表': table_name, 
+                                        '错误': str(e)
+                                    })
                             conn.commit()
-                            # 在batch模式下，affected_rows表示实际影响的行数
-                            # 如果update_on_duplicate为True，则affected_rows包含更新的行数
-                            # 如果update_on_duplicate为False，则affected_rows只包含插入的行数
-                            affected = cursor.rowcount if cursor.rowcount is not None else 0
-                            if update_on_duplicate:
-                                # 当启用更新时，affected_rows包含插入和更新的行数
-                                # 我们需要区分插入和更新的行数
-                                # 由于无法准确区分，我们假设所有行都是插入的
-                                total_inserted += len(batch)
-                            else:
-                                # 当不启用更新时，affected_rows只包含插入的行数
-                                total_inserted += affected
-                                total_skipped += len(batch) - affected
-                        except pymysql.err.IntegrityError as e:
-                            conn.rollback()
-                            # 在唯一约束冲突时，所有行都被跳过
-                            total_skipped += len(batch)
-                            logger.debug('批量插入唯一约束冲突，全部跳过', {'库': db_name, '表': table_name, '错误': str(e)})
-                        except Exception as e:
-                            conn.rollback()
-                            total_failed += len(batch)
-                            logger.error('批量插入失败', {'库': db_name, '表': table_name, '错误': str(e)})
+                        else:
+                            # 没有DEFAULT字段，使用原有逻辑
+                            values_list = []
+                            for row in batch:
+                                values = [ensure_basic_type(row.get(col)) for col in all_columns]
+                                if check_duplicate and not update_on_duplicate:
+                                    dup_cols = duplicate_columns if duplicate_columns else [col for col in all_columns if col.lower() not in self.base_excute_col]
+                                    values += [ensure_basic_type(row.get(col)) for col in dup_cols]
+                                values_list.append(values)
+                            try:
+                                cursor.executemany(sql, values_list)
+                                conn.commit()
+                                # 在batch模式下，affected_rows表示实际影响的行数
+                                # 如果update_on_duplicate为True，则affected_rows包含更新的行数
+                                # 如果update_on_duplicate为False，则affected_rows只包含插入的行数
+                                affected = cursor.rowcount if cursor.rowcount is not None else 0
+                                if update_on_duplicate:
+                                    # 当启用更新时，affected_rows包含插入和更新的行数
+                                    # 我们需要区分插入和更新的行数
+                                    # 由于无法准确区分，我们假设所有行都是插入的
+                                    total_inserted += len(batch)
+                                else:
+                                    # 当不启用更新时，affected_rows只包含插入的行数
+                                    total_inserted += affected
+                                    total_skipped += len(batch) - affected
+                            except pymysql.err.IntegrityError as e:
+                                conn.rollback()
+                                # 在唯一约束冲突时，所有行都被跳过
+                                total_skipped += len(batch)
+                                logger.debug('批量插入唯一约束冲突，全部跳过', {'库': db_name, '表': table_name, '错误': str(e)})
+                            except Exception as e:
+                                conn.rollback()
+                                total_failed += len(batch)
+                                logger.error('批量插入失败', {'库': db_name, '表': table_name, '错误': str(e)})
                 elif transaction_mode == 'hybrid':
                     hybrid_n = 100  # 可配置
                     for i in range(0, len(data), hybrid_n):
                         batch = data[i:i + hybrid_n]
                         for row in batch:
                             try:
-                                values = [ensure_basic_type(row.get(col)) for col in all_columns]
-                                if check_duplicate and not update_on_duplicate:
-                                    dup_cols = duplicate_columns if duplicate_columns else [col for col in all_columns if col.lower() not in self.base_excute_col]
-                                    values += [ensure_basic_type(row.get(col)) for col in dup_cols]
-                                cursor.execute(sql, values)
-                                affected = cursor.rowcount if cursor.rowcount is not None else 0
+                                affected = execute_single_row_with_defaults(row)
                                 if update_on_duplicate:
                                     # 当启用更新时，affected_rows包含插入和更新的行数
                                     # 假设所有行都是插入的，因为无法区分插入和更新
@@ -1966,12 +2097,7 @@ class MySQLUploader:
                 else:  # row模式
                     for row in data:
                         try:
-                            values = [ensure_basic_type(row.get(col)) for col in all_columns]
-                            if check_duplicate and not update_on_duplicate:
-                                dup_cols = duplicate_columns if duplicate_columns else [col for col in all_columns if col.lower() not in self.base_excute_col]
-                                values += [ensure_basic_type(row.get(col)) for col in dup_cols]
-                            cursor.execute(sql, values)
-                            affected = cursor.rowcount if cursor.rowcount is not None else 0
+                            affected = execute_single_row_with_defaults(row)
                             if update_on_duplicate:
                                 # 当启用更新时，affected_rows包含插入和更新的行数
                                 # 假设所有行都是插入的，因为无法区分插入和更新
@@ -2191,14 +2317,22 @@ class MySQLUploader:
                 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 'timestamp' in column_type_lower:
+                # TIMESTAMP类型已经包含DEFAULT定义，不需要额外添加
+                default_value = ""
             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'"
+                if 'datetime' in column_type_lower:
+                    default_value = " DEFAULT '2000-01-01 00:00:00'"
                 else:
-                    default_value = " DEFAULT '1970-01-01'"
+                    default_value = " DEFAULT '2000-01-01'"
             elif 'json' in column_type_lower:
                 default_value = " DEFAULT '{}'"
         
+        # 对于TIMESTAMP类型，不添加额外的NULL约束，因为已经包含在类型定义中
+        if 'timestamp' in column_type.lower() and ('default' in column_type.lower() or 'current_timestamp' in column_type.lower()):
+            null_constraint = ""  # TIMESTAMP类型已经包含完整定义
+            default_value = ""
+        
         sql = f'ALTER TABLE `{db_name}`.`{table_name}` ADD COLUMN `{column}` {column_type} {null_constraint}{default_value}'
         
         conn = None
@@ -2577,6 +2711,82 @@ class MySQLUploader:
         
         return result_df
 
+    def _process_auto_timestamps(
+            self, 
+            data: Union[Dict, List[Dict], pd.DataFrame], 
+            set_typ: Dict[str, str], 
+            db_name: str, 
+            table_name: str
+    ) -> Tuple[Union[Dict, List[Dict], pd.DataFrame], Dict[str, str]]:
+        """
+        处理自动时间戳功能
+        
+        :param data: 原始数据
+        :param set_typ: 列类型定义
+        :param db_name: 数据库名
+        :param table_name: 表名
+        :return: 处理后的数据和更新后的set_typ
+        """
+        
+        # 定义时间戳列名
+        created_col = '创建时间'
+        updated_col = '更新时间'
+        
+        # 复制set_typ以避免修改原始对象
+        updated_set_typ = set_typ.copy()
+        
+        # 使用MySQL的CURRENT_TIMESTAMP功能，按固定顺序添加时间戳列
+        # 创建时间：插入时自动设置，更新时不变
+        updated_set_typ[created_col] = 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP'
+        # 更新时间：插入和更新时都自动设置为当前时间
+        updated_set_typ[updated_col] = 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'
+        
+        # 处理DataFrame格式的数据
+        if hasattr(data, 'shape') and hasattr(data, 'columns'):
+            import pandas as pd
+            df = data.copy()
+            
+            # 移除原始数据中可能存在的时间戳列，让MySQL自动处理
+            columns_to_remove = []
+            for col in df.columns:
+                if col in [created_col, updated_col]:
+                    columns_to_remove.append(col)
+            
+            if columns_to_remove:
+                df = df.drop(columns=columns_to_remove)
+            
+            # 不再手动添加时间戳列，让MySQL的CURRENT_TIMESTAMP自动处理
+            return df, updated_set_typ
+        
+        # 处理字典或字典列表格式的数据
+        else:
+            # 确保data是列表格式
+            if isinstance(data, dict):
+                data_list = [data]
+                is_single_dict = True
+            else:
+                data_list = data
+                is_single_dict = False
+            
+            # 处理每一行数据
+            processed_data = []
+            for row in data_list:
+                new_row = {}
+                
+                # 复制原始数据，但跳过可能存在的时间戳列
+                for key, value in row.items():
+                    if key not in [created_col, updated_col]:
+                        new_row[key] = value
+                
+                # 不再手动添加时间戳，让MySQL的CURRENT_TIMESTAMP自动处理
+                processed_data.append(new_row)
+            
+            # 如果原始数据是单个字典，返回单个字典
+            if is_single_dict:
+                return processed_data[0], updated_set_typ
+            else:
+                return processed_data, updated_set_typ
+
 
 def main():
     dir_path = os.path.expanduser("~")

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

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

mdbq-4.1.11/mdbq/__version__.py

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