add fields method limiting the models columns fetched from db

ormar/queryset/join.py

@@ -24,11 +24,13 @@ class SqlJoin:
         select_from: sqlalchemy.sql.select,
         order_bys: List[sqlalchemy.sql.elements.TextClause],
         columns: List[sqlalchemy.Column],
+        fields: List,
     ) -> None:
         self.used_aliases = used_aliases
         self.select_from = select_from
         self.order_bys = order_bys
         self.columns = columns
+        self.fields = fields
 
     @staticmethod
     def relation_manager(model_cls: Type["Model"]) -> AliasManager:
@@ -105,9 +107,12 @@ class SqlJoin:
             self.select_from, target_table, on_clause
         )
         self.order_bys.append(text(f"{alias}_{to_table}.{model_cls.Meta.pkname}"))
+        self_related_fields = model_cls.own_table_columns(
+            model_cls, self.fields, nested=True
+        )
         self.columns.extend(
             self.relation_manager(model_cls).prefixed_columns(
-                alias, model_cls.Meta.table
+                alias, model_cls.Meta.table, self_related_fields
             )
         )
         self.used_aliases.append(alias)

ormar/queryset/query.py

@@ -20,12 +20,14 @@ class Query:
         select_related: List,
         limit_count: Optional[int],
         offset: Optional[int],
+        fields: Optional[List],
     ) -> None:
         self.query_offset = offset
         self.limit_count = limit_count
         self._select_related = select_related[:]
         self.filter_clauses = filter_clauses[:]
         self.exclude_clauses = exclude_clauses[:]
+        self.fields = fields[:] if fields else []
 
         self.model_cls = model_cls
         self.table = self.model_cls.Meta.table
@@ -41,7 +43,12 @@ class Query:
         return f"{self.table.name}.{self.model_cls.Meta.pkname}"
 
     def build_select_expression(self) -> Tuple[sqlalchemy.sql.select, List[str]]:
-        self.columns = list(self.table.columns)
+        self_related_fields = self.model_cls.own_table_columns(
+            self.model_cls, self.fields
+        )
+        self.columns = self.model_cls.Meta.alias_manager.prefixed_columns(
+            "", self.table, self_related_fields
+        )
         self.order_bys = [text(self.prefixed_pk_name)]
         self.select_from = self.table
 
@@ -57,6 +64,7 @@ class Query:
                 select_from=self.select_from,
                 columns=self.columns,
                 order_bys=self.order_bys,
+                fields=self.fields,
             )
 
             (
@@ -93,3 +101,4 @@ class Query:
         self.columns = []
         self.order_bys = []
         self.used_aliases = []
+        self.fields = []

ormar/queryset/queryset.py

@@ -26,6 +26,7 @@ class QuerySet:
         select_related: List = None,
         limit_count: int = None,
         offset: int = None,
+        columns: List = None,
     ) -> None:
         self.model_cls = model_cls
         self.filter_clauses = [] if filter_clauses is None else filter_clauses
@@ -33,6 +34,7 @@ class QuerySet:
         self._select_related = [] if select_related is None else select_related
         self.limit_count = limit_count
         self.query_offset = offset
+        self._columns = columns or []
         self.order_bys = None
 
     def __get__(
@@ -59,7 +61,9 @@ class QuerySet:
 
     def _process_query_result_rows(self, rows: List) -> List[Optional["Model"]]:
         result_rows = [
-            self.model.from_row(row, select_related=self._select_related)
+            self.model.from_row(
+                row, select_related=self._select_related, fields=self._columns
+            )
             for row in rows
         ]
         if result_rows:
@@ -104,6 +108,7 @@ class QuerySet:
             exclude_clauses=self.exclude_clauses,
             offset=self.query_offset,
             limit_count=self.limit_count,
+            fields=self._columns,
         )
         exp = qry.build_select_expression()
         # print(exp.compile(compile_kwargs={"literal_binds": True}))
@@ -130,6 +135,7 @@ class QuerySet:
             select_related=select_related,
             limit_count=self.limit_count,
             offset=self.query_offset,
+            columns=self._columns,
         )
 
     def exclude(self, **kwargs: Any) -> "QuerySet":  # noqa: A003
@@ -147,6 +153,22 @@ class QuerySet:
             select_related=related,
             limit_count=self.limit_count,
             offset=self.query_offset,
+            columns=self._columns,
+        )
+
+    def fields(self, columns: Union[List, str]) -> "QuerySet":
+        if not isinstance(columns, list):
+            columns = [columns]
+
+        columns = list(set(list(self._columns) + columns))
+        return self.__class__(
+            model_cls=self.model,
+            filter_clauses=self.filter_clauses,
+            exclude_clauses=self.exclude_clauses,
+            select_related=self._select_related,
+            limit_count=self.limit_count,
+            offset=self.query_offset,
+            columns=columns,
         )
 
     async def exists(self) -> bool:
@@ -193,6 +215,7 @@ class QuerySet:
             select_related=self._select_related,
             limit_count=limit_count,
             offset=self.query_offset,
+            columns=self._columns,
         )
 
     def offset(self, offset: int) -> "QuerySet":
@@ -203,6 +226,7 @@ class QuerySet:
             select_related=self._select_related,
             limit_count=self.limit_count,
             offset=offset,
+            columns=self._columns,
         )
 
     async def first(self, **kwargs: Any) -> "Model":