precis-cli 0.1.3__py3-none-any.whl

app/shared/domain/constraints/conditional.py

@@ -0,0 +1,629 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 条件约束模块
+
+功能概述:
+- 实现 ConditionalConstraint 类
+- 实现条件逻辑: 当 A 条件满足时，B 列必须满足 C 条件
+- 支持简单条件和复合条件 (AND/OR)
+
+架构设计:
+- 继承基类: 继承自 Constraint 抽象类
+- 条件解析: 支持 DSL 字典和注册的条件函数
+- 条件类型: not_null, greater_than, in, eq, neq 等
+
+输入示例:
+    # 约束配置 - 简单条件: 当 status="VIP" 时, credit_limit 必须 > 1000
+    constraint1 = ConditionalConstraint(
+        table="customers",
+        if_column="status",
+        if_value="VIP",
+        then_column="credit_limit",
+        then_condition={"operator": "greater_than", "value": 1000}
+    )
+
+    # 约束配置 - 复合条件: 当 (age >= 18 AND country="CN") 时, id_card 必须 not_null
+    constraint2 = ConditionalConstraint(
+        table="users",
+        if_conditions=[
+            {"column": "age", "operator": "greater_than", "value": 18},
+            {"column": "country", "operator": "eq", "value": "CN"}
+        ],
+        if_logic="and",
+        then_column="id_card",
+        then_condition={"operator": "not_null"}
+    )
+
+    # 数据集输入
+    datasets = {
+        "customers": DataFrame({
+            "id": [1, 2, 3],
+            "status": ["VIP", "Normal", "VIP"],
+            "credit_limit": [500, 2000, 800]  # 第1行和第3行不满足条件
+        })
+    }
+
+输出示例:
+    # 验证失败 (第1行 VIP 但 credit_limit=500, 第3行 VIP 但 credit_limit=800)
+    {
+        "errors": [
+            {
+                "error_type": "ConditionalViolation",
+                "table": "customers",
+                "row_index": 0,
+                "value": {"status": "VIP", "credit_limit": 500},
+                "message": "条件约束冲突: 当满足条件时, 'credit_limit' 的值 '500' 不满足要求 (满足DSL {'operator': 'greater_than', 'value': 1000})."
+            }
+        ],
+        "info": {...}
+    }
+
+DSL 操作符说明:
+    - not_null: 值不能为空
+    - greater_than: 值必须大于 threshold
+    - less_than: 值必须小于 threshold
+    - in: 值必须在列表中
+    - eq: 值必须等于指定值
+    - neq: 值必须不等于指定值
+"""
+
+from __future__ import annotations
+
+# 1. 标准库导入
+import logging
+import time
+from collections.abc import Callable
+from typing import Any
+
+# 2. 第三方库导入
+import pandas as pd
+
+# 3. 项目内部导入
+from app.shared.domain.constraints.base import Constraint
+from app.shared.domain.constraints.condition_registry import CONDITION_REGISTRY
+
+logger = logging.getLogger(__name__)
+
+
+# if 条件(composite/if_conditions)支持的操作符白名单:未知操作符 fail-fast(见 _apply_if_condition),
+# 防止拼写错误(如 not_equal)被默认分支静默按 eq 执行导致语义反转。
+_KNOWN_IF_OPERATORS = frozenset({"eq", "neq", "in", "not_null", "greater_than", "less_than"})
+
+
+class ConditionalConstraint(Constraint):
+    """
+    @classdesc 条件约束
+
+    实现"当满足某条件时，另一列必须满足某规则"的业务逻辑。
+    支持两种触发条件模式:
+        1. 简单条件: 当 if_column == if_value 时触发
+        2. 复合条件: 当多个条件组合满足时触发（支持 AND/OR 逻辑）
+    """
+
+    def __init__(
+        self,
+        table: str,
+        if_column: str = "",
+        if_value: Any = None,
+        then_column: str = "",
+        then_condition: dict | str | None = None,
+        if_conditions: list[dict] | None = None,
+        if_logic: str = "and",
+    ):
+        """
+        @methoddesc 初始化条件约束
+
+        参数:
+            table: 目标表名
+            if_column: 简单条件模式下的触发列名（与 if_conditions 互斥）
+            if_value: 简单条件模式下的触发值（与 if_conditions 互斥）
+            then_column: 需要被验证的列名
+            then_condition: 对 then_column 的验证要求，可以是:
+                - 字典（DSL）: 如 {"operator": "greater_than", "value": 1000}
+                - 字符串: 已注册的条件函数名，如 "is_not_empty"
+            if_conditions: 复合条件列表，每个元素是条件字典，如:
+                [{"column": "age", "operator": "greater_than", "value": 18}]
+            if_logic: 复合条件的逻辑组合方式，"and" 或 "or"，默认为 "and"
+
+        属性:
+            _condition_func: 解析后的条件验证函数（Callable），在初始化时通过 _parse_condition() 生成
+            _condition_str: 条件的可读描述字符串
+        """
+        self.table = table
+        self.if_column = if_column
+        self.if_value = if_value
+        self.if_conditions = if_conditions or []
+        self.if_logic = if_logic or "and"
+        self.then_column = then_column
+        self.then_condition_config = then_condition
+        # 解析 then_condition，生成可执行的验证函数
+        self._condition_func = self._parse_condition()
+        # 生成条件的可读描述字符串
+        self._condition_str = self._condition_to_string()
+
+    def _parse_condition(self) -> Callable[[Any, dict[str, Any] | None], bool | None]:
+        """
+        @methoddesc 解析 then_condition，生成验证函数
+
+        根据 then_condition 的类型（字典 DSL 或字符串函数名），
+        生成并返回一个接收单个值、返回布尔结果的验证函数。
+
+        返回:
+            验证函数: Callable[[Any], bool]
+
+        抛出:
+            ValueError: 当 DSL 操作符不支持，或字符串函数名未注册时抛出
+            TypeError: 当 then_condition 类型既不是字典也不是字符串时抛出
+        """
+        then_config = self.then_condition_config
+        if isinstance(then_config, dict):
+            operator = then_config.get("operator")
+            ref_column = then_config.get("ref_column")
+
+            # 辅助函数：获取比较值（固定值或引用列）
+            def _get_compared_value(x: Any, row: dict[str, Any] | None) -> Any:
+                if ref_column and row is not None:
+                    return row.get(ref_column)
+                return then_config.get("value")
+
+            if operator == "not_null":
+
+                def _not_null(x: Any, row: dict[str, Any] | None = None) -> bool:
+                    return bool(pd.notna(x)) and x != ""
+
+                return _not_null
+            if operator == "greater_than":
+                threshold = then_config.get("value")
+
+                # THEN 序比较操作数域=仅数值。固定阈值的构建期校验在 validate() 内
+                # 以 ConstraintConfigError 条目呈现（见 validate 前置检查），构造器
+                # 不抛异常；此处仅做行级三态跳过。日期比较引导 DateLogic——旧实现的
+                # 字符串字典序仅对 ISO 格式碰巧正确（'6/1/2024' vs '10/1/2024' 文本
+                # 序即错），不属承诺行为。
+
+                def _safe_greater_than(x: Any, row: dict[str, Any] | None = None) -> bool | None:
+                    compared = _get_compared_value(x, row) if ref_column else threshold
+                    if pd.isna(x) or x == "":
+                        return False
+                    if compared is None or compared == "":
+                        return False
+                    # a14ef85c 修复字典序误判；NaN 改返回 None（无法判定→跳过该行）而非
+                    # False（判违规）：日期字符串等不可数值化的值不该被报"不满足条件"，
+                    # 脏数据由列类型约束负责报告。与 IF 侧 NaN 不触发的 UNKNOWN 语义对称。
+                    try:
+                        x_num = pd.to_numeric(x, errors="coerce")
+                        compared_num = pd.to_numeric(compared, errors="coerce")
+                        if pd.isna(x_num) or pd.isna(compared_num):
+                            return None
+                        return bool(x_num > compared_num)
+                    except Exception:
+                        logger.debug(
+                            f"greater_than 比较失败: x={x!r}, compared={compared!r}, "
+                            f"table={self.table}, then_column={self.then_column}"
+                        )
+                        return None
+
+                return _safe_greater_than
+            if operator == "in":
+                # 回归: 容器键兼容 + fail-closed。原实现只认 "values" 键，用户按习惯写
+                # "value"（列表）时取到空列表 → 所有触发行误报违规。现同时接受两种键
+                # （values 优先）；容器非 list 时按配置错误 fail-fast（与本函数对不支持
+                # 操作符抛 ValueError 的守卫先例一致），不再静默按空列表处理。
+                values = then_config.get("values")
+                if values is None:
+                    values = then_config.get("value")
+                if not isinstance(values, list):
+                    raise ValueError(
+                        f"'in' 操作符要求 'values'（或 'value'）为列表，实际为 {type(values).__name__}: {values!r}"
+                    )
+
+                def _safe_in(x: Any, row: dict[str, Any] | None = None) -> bool:
+                    if pd.isna(x) or x == "":
+                        return False
+                    try:
+                        return x in values
+                    except Exception:
+                        logger.debug(
+                            f"in 操作失败: x={x!r}, values={values!r}, "
+                            f"table={self.table}, then_column={self.then_column}"
+                        )
+                        return False
+
+                return _safe_in
+            if operator == "less_than":
+                threshold = then_config.get("value")
+
+                # 同 greater_than：阈值校验在 validate() 前置检查，此处仅行级三态
+
+                def _safe_less_than(x: Any, row: dict[str, Any] | None = None) -> bool | None:
+                    compared = _get_compared_value(x, row) if ref_column else threshold
+                    if pd.isna(x) or x == "":
+                        return False
+                    if compared is None or compared == "":
+                        return False
+                    # A4 修复：与 greater_than 同理，先双侧数值转换再比较，避免 str
+                    # 字典序比较（9 < "10" → False 误判）；不可数值化改返回 None
+                    # （无法判定→跳过该行）而非 False（判违规），脏数据由列类型约束报告。
+                    try:
+                        x_num = pd.to_numeric(x, errors="coerce")
+                        compared_num = pd.to_numeric(compared, errors="coerce")
+                        if pd.isna(x_num) or pd.isna(compared_num):
+                            return None
+                        return bool(x_num < compared_num)
+                    except Exception:
+                        logger.debug(
+                            f"less_than 比较失败: x={x!r}, compared={compared!r}, "
+                            f"table={self.table}, then_column={self.then_column}"
+                        )
+                        return None
+
+                return _safe_less_than
+            if operator == "eq":
+                expected = then_config.get("value")
+
+                def _safe_eq(x: Any, row: dict[str, Any] | None = None) -> bool:
+                    compared = _get_compared_value(x, row) if ref_column else expected
+                    # §1.23: 双侧皆 NaN/None 视为满足（SQL NULL=NULL 是 UNKNOWN 不判违规）——
+                    # 原实现 compared 为 NaN(float) 时落到 x == compared → False → 误报
+                    if pd.isna(x) and (compared is None or (isinstance(compared, float) and pd.isna(compared))):
+                        return True
+                    return bool(x == compared)
+
+                return _safe_eq
+            if operator == "neq":
+                expected = then_config.get("value")
+
+                def _safe_neq(x: Any, row: dict[str, Any] | None = None) -> bool:
+                    compared = _get_compared_value(x, row) if ref_column else expected
+                    # §1.23: 与 _safe_eq 对称——双侧皆 NaN/None 时"不等于"不成立（不违规）
+                    if pd.isna(x) and (compared is None or (isinstance(compared, float) and pd.isna(compared))):
+                        return False
+                    return bool(x != compared)
+
+                return _safe_neq
+            raise ValueError(f"不支持的DSL操作符: '{operator}'")
+
+        if isinstance(self.then_condition_config, str):
+            # 从全局注册表中查找已注册的条件函数
+            if self.then_condition_config in CONDITION_REGISTRY:
+                original = CONDITION_REGISTRY[self.then_condition_config]
+
+                # 包装为兼容新签名 (value, row=None) 的函数
+                def _wrapped_condition(x: Any, row: dict[str, Any] | None = None) -> bool:
+                    return bool(original(x))
+
+                return _wrapped_condition
+            raise ValueError(
+                f"未注册的条件函数名: '{self.then_condition_config}'. 可用: {list(CONDITION_REGISTRY.keys())}"
+            )
+
+        raise TypeError(f"then_condition配置类型不支持: {type(self.then_condition_config)}")
+
+    def _condition_to_string(self) -> str:
+        """将 then_condition 转换为可读描述字符串"""
+        if isinstance(self.then_condition_config, dict):
+            return f"满足DSL {self.then_condition_config}"
+        if isinstance(self.then_condition_config, str):
+            return f"满足已注册的规则 '{self.then_condition_config}'"
+        return "满足未知规则"
+
+    def _get_description(self) -> str:
+        """生成约束描述"""
+        if self.if_conditions:
+            return f"条件约束: {self.table} 当满足条件时 {self.then_column} 必须 {self._condition_str}"
+        return f"条件约束: {self.table} 当 {self.if_column}={self.if_value} 时 {self.then_column} 必须 {self._condition_str}"
+
+    def validate(self, datasets: dict[str, pd.DataFrame], **kwargs: Any) -> dict[str, Any]:
+        """
+        @methoddesc 执行条件约束验证
+
+        参数:
+            datasets: 数据集字典，键为表名，值为 pandas DataFrame
+            **kwargs: 额外的关键字参数（本方法不使用）
+
+        返回:
+            验证结果字典，包含 errors（错误列表）和 info（约束信息）
+
+        逻辑说明:
+            1. 检查目标表是否存在
+            2. 检查 then_column 是否存在
+            3. 根据条件模式（简单/复合）筛选触发行
+            4. 对每个触发行检查 then_column 是否满足条件
+            5. 为不满足条件的行生成错误记录
+        """
+        errors: list[dict[str, Any]] = []
+
+        # 检查目标表是否存在
+        if self.table not in datasets:
+            errors.append(
+                {
+                    "error_type": "ConstraintConfigError",
+                    "table": self.table,
+                    "column": self.then_column,
+                    "message": f"条件约束失败: 表 '{self.table}' 不在数据集中。",
+                }
+            )
+            return {"errors": errors, "info": self.get_constraint_info()}
+
+        df = datasets[self.table]
+
+        # 检查目标列是否存在
+        if self.then_column not in df.columns:
+            errors.append(
+                {
+                    "error_type": "ConstraintConfigError",
+                    "table": self.table,
+                    "column": self.then_column,
+                    "message": f"条件约束失败: 列 '{self.then_column}' 不在表 '{self.table}' 中。",
+                }
+            )
+            return {"errors": errors, "info": self.get_constraint_info()}
+
+        # 回归 D1: THEN 侧用 ref_column 做列间比较时,ref_column 必须存在。原实现 IF 侧有
+        # 列校验、THEN 侧没有(不对称),ref_column 缺失时 row.get(缺失列)=None → 比较全 False
+        # → 每个触发行误报 ConditionalViolation,且无配置错误提示。这里补上对称校验。
+        if isinstance(self.then_condition_config, dict):
+            ref_col = self.then_condition_config.get("ref_column")
+            if ref_col and ref_col not in df.columns:
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "column": ref_col,
+                        "message": f"条件约束失败: 引用列 '{ref_col}' 不在表 '{self.table}' 中。",
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+
+        # THEN 序比较（greater_than/less_than）固定阈值前置校验：操作数域=仅数值
+        # （用户拍板）。阈值不可转数值（如 'abc'、日期字符串）报配置错误并引导
+        # DateLogic，而非逐行误报 ConditionalViolation；字符串数值（"1000"）兼容。
+        # ref_column 列间比较的参照值来自行数据，无法前置校验，由行级三态跳过兜底。
+        if isinstance(self.then_condition_config, dict):
+            _then_op = self.then_condition_config.get("operator")
+            if _then_op in ("greater_than", "less_than") and not self.then_condition_config.get("ref_column"):
+                _then_threshold = self.then_condition_config.get("value")
+                if _then_threshold is not None and _then_threshold != "":
+                    try:
+                        _threshold_num = pd.to_numeric(_then_threshold)
+                    except (ValueError, TypeError):
+                        _threshold_num = None
+                    if _threshold_num is None or pd.isna(_threshold_num):
+                        errors.append(
+                            {
+                                "error_type": "ConstraintConfigError",
+                                "table": self.table,
+                                "column": self.then_column,
+                                "message": (
+                                    f"条件约束失败: '{_then_op}' 的 THEN 阈值必须为数值，"
+                                    f"实际: {_then_threshold!r}；日期比较请使用 DateLogic 约束。"
+                                ),
+                            }
+                        )
+                        return {"errors": errors, "info": self.get_constraint_info()}
+
+        def _apply_if_condition(cond: dict) -> pd.Series:
+            """
+            将单个条件应用到 DataFrame，返回布尔 Series
+
+            参数:
+                cond: 条件字典，包含 column/operator/value/values 等字段
+
+            返回:
+                pandas Series，表示每行是否满足该条件
+
+            抛出:
+                KeyError: 当条件引用的列不存在时抛出
+            """
+            # 支持两种字段名: if_column（旧）和 column（新）
+            col = cond.get("if_column") or cond.get("column") or ""
+            op = cond.get("operator") or "eq"
+            value = cond.get("value")
+            values = cond.get("values", [])
+            if col not in df.columns:
+                raise KeyError(col)
+            # 未知操作符不再静默落入默认 eq 分支(语义反转且无告警),与 then 侧
+            # "不支持的DSL操作符" 守卫(见 _parse_condition)保持一致的 fail-fast 语义。
+            if op not in _KNOWN_IF_OPERATORS:
+                raise ValueError(f"不支持的 if 条件操作符: '{op}'(支持: {sorted(_KNOWN_IF_OPERATORS)})")
+            s = df[col]
+            if op == "not_null":
+                # 非空: 既不是 NaN 也不是空字符串
+                return pd.notna(s) & (s != "")
+            if op == "in":
+                # 回归: 容器非 list 时必须按配置错误处理。原实现静默按空列表处理 →
+                # 条件永不触发 → 违规被静默吞掉（fail-open）。抛 ValueError 后由
+                # validate() 的 except ValueError 统一转成 ConstraintConfigError 条目。
+                if not isinstance(values, list):
+                    raise ValueError(f"'in' 条件要求 'values' 为列表，实际为 {type(values).__name__}: {values!r}")
+                # 值在指定列表中
+                return s.isin(values)
+            if op == "greater_than":
+                # 大于: 先转为数值再比较
+                # §1.5: 阈值缺省不再静默按 0.0，转换失败不再静默全 False——都报配置错误
+                if value is None:
+                    raise ValueError("'greater_than' 条件缺少阈值 value")
+                try:
+                    threshold = float(value)
+                except Exception as e:
+                    raise ValueError(f"'greater_than' 条件阈值 '{value}' 无法转换为数值") from e
+                return pd.to_numeric(s, errors="coerce") > threshold
+            if op == "neq":
+                # 不等于: 空值不触发(对标 SQL 语义 NULL != X 为 UNKNOWN,与 Unique 的
+                # NULL 豁免口径一致;原 `s != value` 会把 NaN != X 判为 True 导致空值行误报)
+                return s.ne(value) & s.notna()
+            if op == "less_than":
+                # 小于: 先转为数值再比较
+                # §1.5: 阈值缺省不再静默按 0.0，转换失败不再静默全 False——都报配置错误
+                if value is None:
+                    raise ValueError("'less_than' 条件缺少阈值 value")
+                try:
+                    threshold = float(value)
+                except Exception as e:
+                    raise ValueError(f"'less_than' 条件阈值 '{value}' 无法转换为数值") from e
+                return pd.to_numeric(s, errors="coerce") < threshold
+            # 默认: 等于（op == "eq"）
+            # §1.2: eq 条件 value 留空 → 配置错误（原实现整列和 None 比较恒 False，零触发静默失效）
+            if value is None:
+                raise ValueError("'eq' 条件缺少 value（if_value 留空），请检查约束配置")
+            return s == value
+
+        # ============================================================================
+        # 筛选触发条件的行
+        # ============================================================================
+        if self.if_conditions:
+            # 复合条件模式: 使用多个条件组合筛选
+            # if_logic 归一大小写不敏感（"OR"/"And" 均合法），未知值 fail-fast 报配置错误，
+            # 不再静默按 AND 组合缩小触发行集——与未知 if 操作符的守卫同一语义
+            logic = (self.if_logic or "and").lower()
+            if logic not in ("and", "or"):
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "message": f"条件约束失败: 未知的 if_logic '{self.if_logic}'，支持的值为: and, or。",
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+            try:
+                masks = [_apply_if_condition(c) for c in self.if_conditions]
+            except KeyError as e:
+                missing = str(e).strip("'")
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "column": missing,
+                        "message": f"条件约束失败: 列 '{missing}' 不在表 '{self.table}' 中。",
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+            except ValueError as e:
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "message": f"条件约束失败: {e}",
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+
+            # 根据逻辑运算符组合多个条件的布尔掩码（使用已归一化的 logic）
+            if logic == "or":
+                # OR 逻辑: 任一条件满足即触发
+                mask = masks[0].copy()
+                for m in masks[1:]:
+                    mask = mask | m
+            else:
+                # AND 逻辑: 所有条件都满足才触发
+                mask = masks[0].copy()
+                for m in masks[1:]:
+                    mask = mask & m
+            triggered_rows = df[mask]
+        elif self.if_column:
+            # 简单条件模式: 当 if_column == if_value 时触发
+            if self.if_column not in df.columns:
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "column": self.if_column,
+                        "message": f"条件约束失败: 列 '{self.if_column}' 不在表 '{self.table}' 中。",
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+            # §1.2: if_value 留空（None）视为配置错误——原实现拿整列和 None 比较恒 False，
+            # 零触发行让约束形同虚设且无提示。想"无条件触发"的正确写法是不配 if_column。
+            if self.if_value is None:
+                errors.append(
+                    {
+                        "error_type": "ConstraintConfigError",
+                        "table": self.table,
+                        "column": self.if_column,
+                        "message": (
+                            "条件约束失败: if_value 未配置（留空），简单条件模式必须指定触发值 if_value；"
+                            "如需对所有行触发 THEN 检查，请移除 if_column 配置。"
+                        ),
+                    }
+                )
+                return {"errors": errors, "info": self.get_constraint_info()}
+            triggered_rows = df[df[self.if_column] == self.if_value]
+        else:
+            # 无条件模式: if_conditions 为空且 if_column 未设置，对所有行触发 THEN 检查
+            triggered_rows = df
+
+        # ============================================================================
+        # 检查触发的行是否满足 then 条件
+        # ============================================================================
+        # D6: deadline 检查点。逐行约束内部必须有中断点,否则百万行表跑很久,
+        # timeout_seconds 形同虚设(原 engine 只在约束之间检查)。每 200 行查一次,
+        # 超时则中断循环并返回 Timeout 标记。
+        deadline = kwargs.get("deadline")
+        check_interval = 200
+        triggered_dict = triggered_rows.to_dict("index")
+        for i, (index, row) in enumerate(triggered_dict.items()):
+            if deadline is not None and i % check_interval == 0 and time.monotonic() > deadline:
+                errors.append(
+                    {
+                        "error_type": "Timeout",
+                        "stage": "constraint",
+                        "table": self.table,
+                        "message": (
+                            f"条件约束执行超时,已在第 {i} 行(共 {len(triggered_dict)} 触发行)中断,剩余触发行未校验。"
+                        ),
+                    }
+                )
+                logger.warning(f"条件约束超时中断: 已处理 {i}/{len(triggered_dict)} 触发行")
+                return {"errors": errors, "info": self.get_constraint_info()}
+            value_to_check = row[self.then_column]
+            # 使用解析出的验证函数检查值
+            # 如果配置了 ref_column，传入整行数据以支持列间比较
+            ref_column = (
+                self.then_condition_config.get("ref_column") if isinstance(self.then_condition_config, dict) else None
+            )
+            if ref_column:
+                check_result = self._condition_func(value_to_check, row)
+            else:
+                check_result = self._condition_func(value_to_check, None)
+            # 序比较（greater_than/less_than）的行级三态：值或参照不可数值化时
+            # predicate 返回 None——无法判定不等于违反，跳过该行（脏数据由列
+            # 类型约束负责报告），不再误报 ConditionalViolation。
+            if check_result is None:
+                continue
+            if not check_result:
+                # 构建触发条件的信息，用于错误消息
+                if_value_payload: dict[str, Any] = {}
+                if self.if_conditions:
+                    for c in self.if_conditions:
+                        col = c.get("if_column") or c.get("column")
+                        if col and col in row:
+                            if_value_payload[col] = row[col]
+                else:
+                    if_value_payload[self.if_column] = self.if_value
+
+                row_index = int(index) if index is not None else 0
+                errors.append(
+                    {
+                        "error_type": "ConditionalViolation",
+                        "table": self.table,
+                        "row_index": row_index,
+                        "value": {**if_value_payload, self.then_column: value_to_check},
+                        "message": f"条件约束冲突: 当满足条件时, '{self.then_column}' 的值 '{value_to_check}' 不满足要求 ({self._condition_str}).",
+                    }
+                )
+
+        return {"errors": errors, "info": self.get_constraint_info()}