Add validators when using sqlalchemy.and_(). (#796)

Author: Dreamsorcerer

aiohttp_admin/backends/sqlalchemy.py

@@ -367,38 +367,47 @@ def _get_validators(self, table: sa.Table, c: sa.Column[object]) -> list[Functio
         for constr in table.constraints:
             if not isinstance(constr, sa.CheckConstraint):
                 continue
-            if isinstance(constr.sqltext, sa.BinaryExpression):
-                left = constr.sqltext.left
-                right = constr.sqltext.right
-                op = constr.sqltext.operator
-                if left.expression is c:
-                    if not isinstance(right, sa.BindParameter) or right.value is None:
-                        continue
-                    if op is operator.ge:  # type: ignore[comparison-overlap]
-                        validators.append(func("minValue", (right.value,)))
-                    elif op is operator.gt:  # type: ignore[comparison-overlap]
-                        validators.append(func("minValue", (right.value + 1,)))
-                    elif op is operator.le:  # type: ignore[comparison-overlap]
-                        validators.append(func("maxValue", (right.value,)))
-                    elif op is operator.lt:  # type: ignore[comparison-overlap]
-                        validators.append(func("maxValue", (right.value - 1,)))
-                elif isinstance(left, sa.Function):
-                    if left.name == "char_length":
-                        if next(iter(left.clauses)) is not c:
-                            continue
+
+            if isinstance(constr.sqltext, sa.BooleanClauseList):
+                if constr.sqltext.operator is not operator.and_:  # type: ignore[comparison-overlap]
+                    continue
+                exprs = constr.sqltext.clauses
+            else:
+                exprs = (constr.sqltext,)
+
+            for expr in exprs:
+                if isinstance(expr, sa.BinaryExpression):
+                    left = expr.left
+                    right = expr.right
+                    op = expr.operator
+                    if left.expression is c:
                         if not isinstance(right, sa.BindParameter) or right.value is None:
                             continue
                         if op is operator.ge:  # type: ignore[comparison-overlap]
-                            validators.append(func("minLength", (right.value,)))
+                            validators.append(func("minValue", (right.value,)))
                         elif op is operator.gt:  # type: ignore[comparison-overlap]
-                            validators.append(func("minLength", (right.value + 1,)))
-            elif isinstance(constr.sqltext, sa.Function):
-                if constr.sqltext.name in ("regexp", "regexp_like"):
-                    clauses = tuple(constr.sqltext.clauses)
-                    if clauses[0] is not c or not isinstance(clauses[1], sa.BindParameter):
-                        continue
-                    if clauses[1].value is None:
-                        continue
-                    validators.append(func("regex", (regex(clauses[1].value),)))
+                            validators.append(func("minValue", (right.value + 1,)))
+                        elif op is operator.le:  # type: ignore[comparison-overlap]
+                            validators.append(func("maxValue", (right.value,)))
+                        elif op is operator.lt:  # type: ignore[comparison-overlap]
+                            validators.append(func("maxValue", (right.value - 1,)))
+                    elif isinstance(left, sa.Function):
+                        if left.name == "char_length":
+                            if next(iter(left.clauses)) is not c:
+                                continue
+                            if not isinstance(right, sa.BindParameter) or right.value is None:
+                                continue
+                            if op is operator.ge:  # type: ignore[comparison-overlap]
+                                validators.append(func("minLength", (right.value,)))
+                            elif op is operator.gt:  # type: ignore[comparison-overlap]
+                                validators.append(func("minLength", (right.value + 1,)))
+                elif isinstance(expr, sa.Function):
+                    if expr.name in ("regexp", "regexp_like"):
+                        clauses = tuple(expr.clauses)
+                        if clauses[0] is not c or not isinstance(clauses[1], sa.BindParameter):
+                            continue
+                        if clauses[1].value is None:
+                            continue
+                        validators.append(func("regex", (regex(clauses[1].value),)))
 
         return validators

tests/test_backends_sqlalchemy.py

@@ -276,12 +276,16 @@ class TestCC(base):  # type: ignore[misc,valid-type]
         min_length: Mapped[str] = mapped_column()
         min_length_gt: Mapped[str] = mapped_column()
         regex: Mapped[str] = mapped_column()
+        with_and: Mapped[int] = mapped_column()
+        with_or: Mapped[int] = mapped_column()
 
         __table_args__ = (sa.CheckConstraint(gt > 3), sa.CheckConstraint(gte >= 3),
                           sa.CheckConstraint(lt < 3), sa.CheckConstraint(lte <= 3),
                           sa.CheckConstraint(sa.func.char_length(min_length) >= 5),
                           sa.CheckConstraint(sa.func.char_length(min_length_gt) > 5),
-                          sa.CheckConstraint(sa.func.regexp(regex, r"abc.*")))
+                          sa.CheckConstraint(sa.func.regexp(regex, r"abc.*")),
+                          sa.CheckConstraint(sa.and_(with_and > 7, with_and < 12)),
+                          sa.CheckConstraint(sa.or_(with_or > 7, with_or < 12)))
 
     r = SAResource(mock_engine, TestCC)
 
@@ -300,6 +304,9 @@ class TestCC(base):  # type: ignore[misc,valid-type]
     assert f["min_length"]["props"]["validate"] == [required, func("minLength", (5,))]
     assert f["min_length_gt"]["props"]["validate"] == [required, func("minLength", (6,))]
     assert f["regex"]["props"]["validate"] == [required, func("regex", (regex("abc.*"),))]
+    assert f["with_and"]["props"]["validate"] == [
+        required, func("minValue", (8,)), func("maxValue", (11,))]
+    assert f["with_or"]["props"]["validate"] == [required]
 
 
 async def test_nonid_pk(base: type[DeclarativeBase], mock_engine: AsyncEngine) -> None: