Method _resolve_only

tortoise/queryset.py:1108–1191

(self, only_lookup_expressions: tuple[str, ...])

        return model, table

    def _resolve_only(self, only_lookup_expressions: tuple[str, ...]) -> None:
        # Group fields by fetch fields, e.g. ["a__b", "a__c"] -> {"a": ["b", "c"]}.
        # The direct fields of the model are the ones that would have the key "".
        fetch_to_fields = defaultdict(list)
        # the order is important here, we need to process the shallowest fields first
        # because we want to populate _select_related_idx with actual items that need to be
        # selected, not "filler" items tha just tell the executor that an empty instance has
        # to be created
        for expression in sorted(only_lookup_expressions, key=lambda x: x.count("__")):
            fetch_fields_lookup, __, field_name = expression.rpartition("__")
            fetch_to_fields[fetch_fields_lookup].append(field_name)

        # select direct model fields which would have the key "": {"": ["a", "b"]}
        data_fields = fetch_to_fields.pop("", None)
        if data_fields:
            table = self.model._meta.basetable
            self._select_related_idx.append(
                (
                    self.model,
                    len(data_fields),
                    table,
                    self.model,
                    (None,),
                )
            )
            try:
                self.query = self.query.select(
                    *[
                        table[self.model._meta.fields_db_projection[field]].as_(field)
                        for field in data_fields
                        if field not in self._annotations
                    ]
                )
            except KeyError as e:
                raise FieldError(
                    f'Unknown field "{e.args[0]}" for model "{self.model.__name__}"'
                ) from e

        else:
            # even though no data fields are selected, we need to let the executor know
            # that an empty instance of the model has to be created
            self._select_related_idx.append(
                (
                    self.model,
                    0,
                    self.model._meta.basetable,
                    self.model,
                    (None,),
                )
            )

        # Select fields of related models, e.g. {"a": ["b", "c"]}
        added_paths = set()
        for fetch_fields_lookup, data_fields in fetch_to_fields.items():
            fetch_fields = expand_lookup_expression(self.model, fetch_fields_lookup)
            referring_model = model = self.model
            table = self.model._meta.basetable
            path: tuple[str | None, ...] = (None,)