chore: test ci

Author: Alc-Alc

advanced_alchemy/filters.py

@@ -6,11 +6,14 @@
 from collections import abc  # noqa: TCH003
 from dataclasses import dataclass
 from datetime import datetime  # noqa: TCH003
+from operator import attrgetter
 from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast
 
 from sqlalchemy import BinaryExpression, and_, any_, or_, text
 
 if TYPE_CHECKING:
+    from typing import Callable
+
     from sqlalchemy import Select, StatementLambdaElement
     from sqlalchemy.orm import InstrumentedAttribute
     from typing_extensions import TypeAlias
@@ -295,76 +298,49 @@ def normalized_field_names(self) -> set[str]:
 
 
 @dataclass
-class SearchFilter(TextSearchFilter):
-    """Data required to construct a ``WHERE field_name LIKE '%' || :value || '%'`` clause."""
+class SearchFilter(StatementFilter):
+    field_name: str | set[str]
+    value: str
+    ignore_case: bool | None = False
 
-    def append_to_statement(
-        self,
-        statement: Select[tuple[ModelT]],
-        model: type[ModelT],
-    ) -> Select[tuple[ModelT]]:
-        fields = self.normalized_field_names
-        search_clause: list[BinaryExpression[bool]] = []
-        for field_name in fields:
-            field = self._get_instrumented_attr(model, field_name)
-            search_text = f"%{self.value}%"
-            if self.ignore_case:
-                search_clause.append(field.ilike(search_text))
-            else:
-                search_clause.append(field.like(search_text))
-        return statement.where(or_(*search_clause))
+    _operator: Any = or_
 
-    def append_to_lambda_statement(
-        self,
-        statement: StatementLambdaElement,
-        model: type[ModelT],
-    ) -> StatementLambdaElement:
-        fields = self.normalized_field_names
+    @property
+    def func(self) -> attrgetter[Callable[[str], BinaryExpression[bool]]]:
+        return attrgetter("ilike" if self.ignore_case else "like")
+
+    @property
+    def normalized_field_names(self) -> set[str]:
+        return {self.field_name} if isinstance(self.field_name, str) else self.field_name
+
+    def get_search_clauses(self, model: type[ModelT]) -> list[BinaryExpression[bool]]:
         search_clause: list[BinaryExpression[bool]] = []
-        for field_name in fields:
+        for field_name in self.normalized_field_names:
             field = self._get_instrumented_attr(model, field_name)
             search_text = f"%{self.value}%"
-            if self.ignore_case:
-                search_clause.append(field.ilike(search_text))
-            else:
-                search_clause.append(field.like(search_text))
-        statement += lambda s: s.where(or_(*search_clause))  # pyright: ignore[reportUnknownLambdaType,reportArgumentType,reportUnknownMemberType]
-        return statement
-
-
-@dataclass
-class NotInSearchFilter(TextSearchFilter):
-    """Data required to construct a ``WHERE field_name NOT LIKE '%' || :value || '%'`` clause."""
+            search_clause.append(self.func(field)(search_text))
+        return search_clause
 
     def append_to_statement(
         self,
         statement: Select[tuple[ModelT]],
         model: type[ModelT],
     ) -> Select[tuple[ModelT]]:
-        fields = self.normalized_field_names
-        search_clause: list[BinaryExpression[bool]] = []
-        for field_name in fields:
-            field = self._get_instrumented_attr(model, field_name)
-            search_text = f"%{self.value}%"
-            if self.ignore_case:
-                search_clause.append(field.not_ilike(search_text))
-            else:
-                search_clause.append(field.not_like(search_text))
-        return statement.where(and_(*search_clause))
+        return statement.where(self._operator(*self.get_search_clauses(model)))
 
     def append_to_lambda_statement(
         self,
         statement: StatementLambdaElement,
         model: type[ModelT],
     ) -> StatementLambdaElement:
-        fields = self.normalized_field_names
-        search_clause: list[BinaryExpression[bool]] = []
-        for field_name in fields:
-            field = self._get_instrumented_attr(model, field_name)
-            search_text = f"%{self.value}%"
-            if self.ignore_case:
-                search_clause.append(field.not_ilike(search_text))
-            else:
-                search_clause.append(field.not_like(search_text))
-        statement += lambda s: s.where(and_(*search_clause))  # pyright: ignore[reportUnknownLambdaType,reportArgumentType,reportUnknownMemberType]
+        statement += lambda s: s.where(self._operator(*self.get_search_clauses(model)))
         return statement
+
+
+@dataclass
+class NotInSearchFilter(SearchFilter):
+    _operator: Any = and_
+
+    @property
+    def func(self) -> attrgetter[Callable[[str], BinaryExpression[bool]]]:
+        return attrgetter("not_ilike" if self.ignore_case else "not_like")