crawlo 1.4.3__py3-none-any.whl → 1.4.5__py3-none-any.whl

crawlo/utils/db_helper.py

@@ -1,344 +1,245 @@
 # -*- coding: utf-8 -*-
 import json
 import re
-import pprint
 from typing import Any, Union, List, Dict, Tuple, Optional
 from datetime import date, time, datetime
+from enum import Enum
 
 from crawlo.utils.log import get_logger
 
 logger = get_logger(__name__)
 
-# 正则表达式缓存
-_REGEXPS: Dict[str, "re.Pattern"] = {}
-
-
-def make_insert_sql(
-    table: str,
-    data: Dict[str, Any],
-    auto_update: bool = False,
-    update_columns: Tuple = (),
-    insert_ignore: bool = False,
-) -> str:
-    """
-    生成 MySQL INSERT 或 REPLACE 语句。
-
-    Args:
-        table (str): 表名
-        data (dict): 表数据，JSON 格式字典
-        auto_update (bool): 是否使用 REPLACE INTO（完全覆盖已存在记录）
-        update_columns (tuple or list): 冲突时需更新的列名；指定后 auto_update 失效
-        insert_ignore (bool): 是否使用 INSERT IGNORE，忽略重复数据
-
-    Returns:
-        str: 生成的 SQL 语句
-    """
-    keys = [f"`{key}`" for key in data.keys()]
-    keys_str = list2str(keys).replace("'", "")
-
-    values = [format_sql_value(value) for value in data.values()]
-    values_str = list2str(values)
-
-    if update_columns:
-        if not isinstance(update_columns, (tuple, list)):
-            update_columns = (update_columns,)
-        update_clause = ", ".join(f"`{key}`=VALUES(`{key}`)" for key in update_columns)
-        ignore_flag = " IGNORE" if insert_ignore else ""
-        sql = f"INSERT{ignore_flag} INTO `{table}` {keys_str} VALUES {values_str} ON DUPLICATE KEY UPDATE {update_clause}"
-
-    elif auto_update:
-        sql = f"REPLACE INTO `{table}` {keys_str} VALUES {values_str}"
-
-    else:
-        ignore_flag = " IGNORE" if insert_ignore else ""
-        sql = f"INSERT{ignore_flag} INTO `{table}` {keys_str} VALUES {values_str}"
-
-    return sql.replace("None", "null")
-
-
-def make_update_sql(
-    table: str,
-    data: Dict[str, Any],
-    condition: str,
-) -> str:
-    """
-    生成 MySQL UPDATE 语句。
-
-    Args:
-        table (str): 表名
-        data (dict): 更新字段的键值对，键为列名，值为新值
-        condition (str): WHERE 条件，如 "id = 1"
-
-    Returns:
-        str: 生成的 SQL 语句
-    """
-    key_values: List[str] = []
-    for key, value in data.items():
-        formatted_value = format_sql_value(value)
-        if isinstance(formatted_value, str):
-            key_values.append(f"`{key}`={repr(formatted_value)}")
-        elif formatted_value is None:
-            key_values.append(f"`{key}`=null")
-        else:
-            key_values.append(f"`{key}`={formatted_value}")
-
-    key_values_str = ", ".join(key_values)
-    sql = f"UPDATE `{table}` SET {key_values_str} WHERE {condition}"
-    return sql
-
-
-def make_batch_sql(
-    table: str,
-    datas: List[Dict[str, Any]],
-    auto_update: bool = False,
-    update_columns: Tuple = (),
-    update_columns_value: Tuple = (),
-) -> Optional[Tuple[str, List[List[Any]]]]:
-    """
-    生成批量插入 SQL 及对应值列表。
-
-    支持 INSERT IGNORE、REPLACE INTO 和 ON DUPLICATE KEY UPDATE。
-
-    Args:
-        table (str): 表名
-        datas (list of dict): 数据列表，如 [{'col1': val1}, ...]
-        auto_update (bool): 使用 REPLACE INTO 替代 INSERT
-        update_columns (tuple or list): 主键冲突时要更新的列名
-        update_columns_value (tuple): 更新列对应的固定值，如 ('%s',) 或 ('default',)
-
-    Returns:
-        tuple[str, list[list]] | None: (SQL语句, 值列表)；若数据为空则返回 None
-    """
-    if not datas:
-        return None
-
-    # 提取所有唯一字段名
-    keys = list({key for data in datas for key in data})
-    values_list = []
-
-    for data in datas:
-        if not isinstance(data, dict):
-            continue  # 跳过非字典数据
-
-        row = []
-        for key in keys:
-            raw_value = data.get(key)
-            try:
-                formatted_value = format_sql_value(raw_value)
-                row.append(formatted_value)
-            except Exception as e:
-                logger.error(f"{key}: {raw_value} (类型: {type(raw_value)}) -> {e}")
-        values_list.append(row)
-
-    keys_str = ", ".join(f"`{key}`" for key in keys)
-    placeholders_str = ", ".join(["%s"] * len(keys))
-
-    if update_columns:
-        if not isinstance(update_columns, (tuple, list)):
-            update_columns = (update_columns,)
-
-        if update_columns_value:
-            update_pairs = [
-                f"`{key}`={value}"
-                for key, value in zip(update_columns, update_columns_value)
-            ]
-        else:
-            update_pairs = [
-                f"`{key}`=VALUES(`{key}`)" for key in update_columns
-            ]
-        update_clause = ", ".join(update_pairs)
-        sql = f"INSERT INTO `{table}` ({keys_str}) VALUES ({placeholders_str}) ON DUPLICATE KEY UPDATE {update_clause}"
-
-    elif auto_update:
-        sql = f"REPLACE INTO `{table}` ({keys_str}) VALUES ({placeholders_str})"
-
-    else:
-        sql = f"INSERT IGNORE INTO `{table}` ({keys_str}) VALUES ({placeholders_str})"
-
-    return sql, values_list
-
-
-def format_sql_value(value: Any) -> Union[str, int, float, None]:
-    """
-    格式化 SQL 字段值，防止注入并兼容类型。
-
-    处理字符串、数字、布尔、日期、列表/元组、字典等类型，不可序列化类型抛出异常。
-
-    Args:
-        value (Any): 待处理的值
-
-    Returns:
-        str | int | float | None: 格式化后的值，None 表示 SQL 的 NULL
-    """
-    if value is None:
-        return None
-
-    if isinstance(value, str):
-        return value.strip()
 
-    elif isinstance(value, (list, tuple, dict)):
-        try:
-            return json.dumps(value, ensure_ascii=False, default=str)
-        except Exception as e:
-            raise ValueError(f"Failed to serialize container to JSON: {value}, error: {e}")
+class SQLStatementType(Enum):
+    """SQL语句类型枚举"""
+    INSERT = "INSERT"
+    REPLACE = "REPLACE"
+    UPDATE = "UPDATE"
+    BATCH_INSERT = "BATCH_INSERT"
+    BATCH_REPLACE = "BATCH_REPLACE"
 
-    elif isinstance(value, bool):
-        return int(value)
 
-    elif isinstance(value, (int, float)):
-        return value
+class SQLBuilder:
+    """SQL语句构建器"""
+    
+    @staticmethod
+    def format_value(value: Any) -> Union[str, int, float, None]:
+        """
+        格式化 SQL 字段值，防止注入并兼容类型。
 
-    elif isinstance(value, (date, time, datetime)):
-        return str(value)
+        Args:
+            value (Any): 待处理的值
 
-    else:
-        raise TypeError(f"Unsupported value type: {type(value)}, value: {value}")
+        Returns:
+            str | int | float | None: 格式化后的值，None 表示 SQL 的 NULL
+        """
+        if value is None:
+            return None
 
+        if isinstance(value, str):
+            return value.strip()
 
-def list2str(datas: List[Any]) -> str:
-    """
-    将列表转为 SQL 元组字符串格式。
-
-    例如：[1, 2] → "(1, 2)"，单元素不带逗号：[1] → "(1)"
-
-    Args:
-        datas (list): 输入列表
-
-    Returns:
-        str: 对应的元组字符串表示
-    """
-    data_str = str(tuple(datas))
-    return re.sub(r",\)$", ")", data_str)
-
-
-def get_info(
-    html: Union[str, Any],
-    regexps: Union[str, List[str]],
-    allow_repeat: bool = True,
-    fetch_one: bool = False,
-    split: Optional[str] = None,
-) -> Union[str, List[str], Tuple]:
-    """
-    从 HTML 文本中提取信息，支持正则匹配和多模式 fallback。
-
-    Args:
-        html (str): HTML 内容或可转为字符串的类型
-        regexps (str or list of str): 正则表达式，按顺序尝试匹配
-        allow_repeat (bool): 是否允许重复结果
-        fetch_one (bool): 是否只提取第一个匹配项（返回元组）
-        split (str, optional): 若提供，则将结果用该字符连接成字符串
+        elif isinstance(value, (list, tuple, dict)):
+            try:
+                return json.dumps(value, ensure_ascii=False, default=str)
+            except Exception as e:
+                raise ValueError(f"Failed to serialize container to JSON: {value}, error: {e}")
 
-    Returns:
-        str | list | tuple: 匹配结果，根据参数返回字符串、列表或元组
-    """
-    if isinstance(regexps, str):
-        regexps = [regexps]
+        elif isinstance(value, bool):
+            return int(value)
 
-    infos = []
-    for regex in regexps:
-        if not regex:
-            continue
+        elif isinstance(value, (int, float)):
+            return value
 
-        if regex not in _REGEXPS:
-            _REGEXPS[regex] = re.compile(regex, re.S)
+        elif isinstance(value, (date, time, datetime)):
+            return str(value)
 
-        if fetch_one:
-            match = _REGEXPS[regex].search(str(html))
-            infos = match.groups() if match else ("",)
-            break
         else:
-            found = _REGEXPS[regex].findall(str(html))
-            if found:
-                infos = found
-                break
-
-    if fetch_one:
-        return infos[0] if len(infos) == 1 else infos
-
-    if not allow_repeat:
-        infos = sorted(set(infos), key=infos.index)
-
-    return split.join(infos) if split else infos
-
-
-def get_json(json_str: Union[str, Any]) -> Dict:
-    """
-    安全解析 JSON 字符串，兼容非标准格式（如单引号、缺少引号键）。
-
-    尝试修复常见格式错误后再解析。
+            raise TypeError(f"Unsupported value type: {type(value)}, value: {value}")
+
+    @staticmethod
+    def list_to_tuple_str(datas: List[Any]) -> str:
+        """
+        将列表转为 SQL 元组字符串格式。
+
+        Args:
+            datas (list): 输入列表
+
+        Returns:
+            str: 对应的元组字符串表示
+        """
+        if not datas:
+            return "()"
+        if len(datas) == 1:
+            # 处理单元素元组，确保末尾有逗号
+            return f"({datas[0]},)"
+        return str(tuple(datas))
+
+    @staticmethod
+    def _build_key_value_pairs(data: Dict[str, Any]) -> Tuple[List[str], List[Any]]:
+        """
+        构建键值对列表
+
+        Args:
+            data (dict): 数据字典
+
+        Returns:
+            tuple: (键列表, 值列表)
+        """
+        keys = [f"`{key}`" for key in data.keys()]
+        values = [SQLBuilder.format_value(value) for value in data.values()]
+        return keys, values
+
+    @staticmethod
+    def _build_update_clause(update_columns: Union[Tuple, List]) -> str:
+        """
+        构建更新子句
+
+        Args:
+            update_columns (tuple or list): 更新列名
+
+        Returns:
+            str: 更新子句
+        """
+        if not isinstance(update_columns, (tuple, list)):
+            update_columns = (update_columns,)
+        return ", ".join(f"`{key}`=VALUES(`{key}`)" for key in update_columns)
+
+    @staticmethod
+    def make_insert(
+        table: str,
+        data: Dict[str, Any],
+        auto_update: bool = False,
+        update_columns: Tuple = (),
+        insert_ignore: bool = False,
+    ) -> str:
+        """
+        生成 MySQL INSERT 或 REPLACE 语句。
+
+        Args:
+            table (str): 表名
+            data (dict): 表数据，JSON 格式字典
+            auto_update (bool): 是否使用 REPLACE INTO（完全覆盖已存在记录）
+            update_columns (tuple or list): 冲突时需更新的列名；指定后 auto_update 失效
+            insert_ignore (bool): 是否使用 INSERT IGNORE，忽略重复数据
+
+        Returns:
+            str: 生成的 SQL 语句
+        """
+        keys, values = SQLBuilder._build_key_value_pairs(data)
+        keys_str = SQLBuilder.list_to_tuple_str(keys).replace("'", "")
+        values_str = SQLBuilder.list_to_tuple_str(values)
+
+        if update_columns:
+            update_clause = SQLBuilder._build_update_clause(update_columns)
+            ignore_flag = " IGNORE" if insert_ignore else ""
+            sql = f"INSERT{ignore_flag} INTO `{table}` {keys_str} VALUES {values_str} ON DUPLICATE KEY UPDATE {update_clause}"
+
+        elif auto_update:
+            sql = f"REPLACE INTO `{table}` {keys_str} VALUES {values_str}"
 
-    Args:
-        json_str (str): JSON 字符串
+        else:
+            ignore_flag = " IGNORE" if insert_ignore else ""
+            sql = f"INSERT{ignore_flag} INTO `{table}` {keys_str} VALUES {values_str}"
+
+        return sql.replace("None", "null")
+
+    @staticmethod
+    def make_update(
+        table: str,
+        data: Dict[str, Any],
+        condition: str,
+    ) -> str:
+        """
+        生成 MySQL UPDATE 语句。
+
+        Args:
+            table (str): 表名
+            data (dict): 更新字段的键值对，键为列名，值为新值
+            condition (str): WHERE 条件，如 "id = 1"
+
+        Returns:
+            str: 生成的 SQL 语句
+        """
+        key_values: List[str] = []
+        for key, value in data.items():
+            formatted_value = SQLBuilder.format_value(value)
+            if isinstance(formatted_value, str):
+                key_values.append(f"`{key}`={repr(formatted_value)}")
+            elif formatted_value is None:
+                key_values.append(f"`{key}`=null")
+            else:
+                key_values.append(f"`{key}`={formatted_value}")
+
+        key_values_str = ", ".join(key_values)
+        sql = f"UPDATE `{table}` SET {key_values_str} WHERE {condition}"
+        return sql
+
+    @staticmethod
+    def make_batch(
+        table: str,
+        datas: List[Dict[str, Any]],
+        auto_update: bool = False,
+        update_columns: Tuple = (),
+        update_columns_value: Tuple = (),
+    ) -> Optional[Tuple[str, List[List[Any]]]]:
+        """
+        生成批量插入 SQL 及对应值列表。
+
+        Args:
+            table (str): 表名
+            datas (list of dict): 数据列表
+            auto_update (bool): 使用 REPLACE INTO 替代 INSERT
+            update_columns (tuple or list): 主键冲突时要更新的列名
+            update_columns_value (tuple): 更新列对应的固定值
+
+        Returns:
+            tuple[str, list[list]] | None: (SQL语句, 值列表)；若数据为空则返回 None
+        """
+        if not datas:
+            return None
+
+        # 提取所有唯一字段名
+        keys = list({key for data in datas for key in data})
+        values_list = []
+
+        for data in datas:
+            if not isinstance(data, dict):
+                continue  # 跳过非字典数据
+
+            row = []
+            for key in keys:
+                raw_value = data.get(key)
+                try:
+                    formatted_value = SQLBuilder.format_value(raw_value)
+                    row.append(formatted_value)
+                except Exception as e:
+                    logger.error(f"{key}: {raw_value} (类型: {type(raw_value)}) -> {e}")
+            values_list.append(row)
+
+        keys_str = ", ".join(f"`{key}`" for key in keys)
+        placeholders_str = ", ".join(["%s"] * len(keys))
+
+        if update_columns:
+            if not isinstance(update_columns, (tuple, list)):
+                update_columns = (update_columns,)
+
+            if update_columns_value:
+                update_pairs = [
+                    f"`{key}`={value}"
+                    for key, value in zip(update_columns, update_columns_value)
+                ]
+            else:
+                update_pairs = [
+                    f"`{key}`=VALUES(`{key}`)" for key in update_columns
+                ]
+            update_clause = ", ".join(update_pairs)
+            sql = f"INSERT INTO `{table}` ({keys_str}) VALUES ({placeholders_str}) ON DUPLICATE KEY UPDATE {update_clause}"
+
+        elif auto_update:
+            sql = f"REPLACE INTO `{table}` ({keys_str}) VALUES ({placeholders_str})"
 
-    Returns:
-        dict: 解析后的字典，失败返回空字典
-    """
-    if not json_str:
-        return {}
+        else:
+            sql = f"INSERT IGNORE INTO `{table}` ({keys_str}) VALUES ({placeholders_str})"
 
-    try:
-        return json.loads(json_str)
-    except Exception as e1:
-        try:
-            cleaned = json_str.strip().replace("'", '"')
-            keys = get_info(cleaned, r'(\w+):')
-            for key in keys:
-                cleaned = cleaned.replace(f"{key}:", f'"{key}":')
-            return json.loads(cleaned) if cleaned else {}
-        except Exception as e2:
-            logger.error(
-                f"JSON 解析失败\n"
-                f"原始内容: {json_str}\n"
-                f"错误1: {e1}\n"
-                f"修复后: {cleaned}\n"
-                f"错误2: {e2}"
-            )
-        return {}
-
-
-def dumps_json(
-    data: Union[str, dict, list, Any],
-    indent: int = 4,
-    sort_keys: bool = False,
-    ensure_ascii: bool = False,
-    skip_keys: bool = True,
-    default_repr: bool = False,
-) -> str:
-    """
-    格式化任意对象为可读字符串，优先使用 JSON，失败时降级为 pprint 或 repr。
-
-    支持自动处理 datetime、ObjectId 等不可序列化类型。
-
-    Args:
-        data (Any): 输入数据，支持字符串、字典、列表等
-        indent (int): JSON 缩进空格数
-        sort_keys (bool): 是否对字典键排序
-        ensure_ascii (bool): 是否转义非 ASCII 字符（False 可保留中文）
-        skip_keys (bool): 遇到非法键时是否跳过（而非报错）
-        default_repr (bool): 是否在最终失败时使用 repr() 降级
-
-    Returns:
-        str: 格式化后的字符串，适合日志输出或打印
-    """
-    try:
-        if isinstance(data, str):
-            if not data.strip():
-                return '""'
-            data = get_json(data)
-
-        return json.dumps(
-            data,
-            ensure_ascii=ensure_ascii,
-            indent=indent,
-            skipkeys=skip_keys,
-            sort_keys=sort_keys,
-            default=str,
-        )
-
-    except (UnicodeDecodeError, ValueError, TypeError, OverflowError) as e:
-        try:
-            return pprint.pformat(data, indent=indent, width=80, compact=True)
-        except Exception:
-            if default_repr:
-                return repr(data)
-            return f"<无法序列化的对象: {type(data).__name__}>"
+        return sql, values_list