update docs and readme

ormar/queryset/actions/filter_action.py

@@ -56,7 +56,7 @@ class FilterAction(QueryAction):
     Extracted in order to easily change table prefixes on complex relations.
     """
 
-    def __init__(self, filter_str: str, value: Any, model_cls: Type["Model"], ) -> None:
+    def __init__(self, filter_str: str, value: Any, model_cls: Type["Model"],) -> None:
         super().__init__(query_str=filter_str, model_cls=model_cls)
         self.filter_value = value
         self._escape_characters_in_clause()
@@ -149,7 +149,7 @@ class FilterAction(QueryAction):
         return clause
 
     def _compile_clause(
-            self, clause: sqlalchemy.sql.expression.BinaryExpression, modifiers: Dict,
+        self, clause: sqlalchemy.sql.expression.BinaryExpression, modifiers: Dict,
     ) -> sqlalchemy.sql.expression.TextClause:
         """
         Compiles the clause to str using appropriate database dialect, replace columns
@@ -177,7 +177,7 @@ class FilterAction(QueryAction):
             f"{self.table.name}.{self.column.name}", aliased_name
         )
         dialect_name = self.target_model.Meta.database._backend._dialect.name
-        if dialect_name != 'sqlite':  # pragma: no cover
+        if dialect_name != "sqlite":  # pragma: no cover
             clause_text = clause_text.replace("%%", "%")  # remove %% in some dialects
         clause = text(clause_text)
         return clause

ormar/queryset/field_accessor.py

@@ -10,11 +10,11 @@ if TYPE_CHECKING:  # pragma: no cover
 
 class FieldAccessor:
     def __init__(
-            self,
-            source_model: Type["Model"],
-            field: "BaseField" = None,
-            model: Type["Model"] = None,
-            access_chain: str = "",
+        self,
+        source_model: Type["Model"],
+        field: "BaseField" = None,
+        model: Type["Model"] = None,
+        access_chain: str = "",
     ) -> None:
         self._source_model = source_model
         self._field = field

ormar/queryset/queryset.py

@@ -7,6 +7,7 @@ from typing import (
     Sequence,
     Set,
     TYPE_CHECKING,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -180,16 +181,19 @@ class QuerySet(Generic[T]):
             return self.model.merge_instances_list(result_rows)  # type: ignore
         return cast(List[Optional["T"]], result_rows)
 
-    def _resolve_filter_groups(self, groups: Any) -> List[FilterGroup]:
+    def _resolve_filter_groups(
+        self, groups: Any
+    ) -> Tuple[List[FilterGroup], List[str]]:
         """
         Resolves filter groups to populate FilterAction params in group tree.
 
         :param groups: tuple of FilterGroups
         :type groups: Any
         :return: list of resolver groups
-        :rtype: List[FilterGroup]
+        :rtype: Tuple[List[FilterGroup], List[str]]
         """
         filter_groups = []
+        select_related = self._select_related
         if groups:
             for group in groups:
                 if not isinstance(group, FilterGroup):
@@ -200,13 +204,13 @@ class QuerySet(Generic[T]):
                         "other values need to be passed by"
                         "keyword arguments"
                     )
-                group.resolve(
+                _, select_related = group.resolve(
                     model_cls=self.model,
                     select_related=self._select_related,
                     filter_clauses=self.filter_clauses,
                 )
                 filter_groups.append(group)
-        return filter_groups
+        return filter_groups, select_related
 
     @staticmethod
     def check_single_result_rows_count(rows: Sequence[Optional["T"]]) -> None:
@@ -304,10 +308,10 @@ class QuerySet(Generic[T]):
         :return: filtered QuerySet
         :rtype: QuerySet
         """
-        filter_groups = self._resolve_filter_groups(groups=args)
+        filter_groups, select_related = self._resolve_filter_groups(groups=args)
         qryclause = QueryClause(
             model_cls=self.model,
-            select_related=self._select_related,
+            select_related=select_related,
             filter_clauses=self.filter_clauses,
         )
         filter_clauses, select_related = qryclause.prepare_filter(**kwargs)