Method aggregate

mongoengine/queryset/base.py:1336–1384

Perform an aggregate function based on your queryset params :param pipeline: list of aggregation commands, see: https://www.mongodb.com/docs/manual/core/aggregation-pipeline/ :param suppl_pipeline: unpacked list of pipeline (added to support deprecation of the old interf

(self, pipeline, *suppl_pipeline, **kwargs)

        return [self._document._from_son(data) for data in son_data]

    def aggregate(self, pipeline, *suppl_pipeline, **kwargs):
        """Perform an aggregate function based on your queryset params

        :param pipeline: list of aggregation commands,
            see: https://www.mongodb.com/docs/manual/core/aggregation-pipeline/
        :param suppl_pipeline: unpacked list of pipeline (added to support deprecation of the old interface)
            parameter will be removed shortly
        :param kwargs: (optional) kwargs dictionary to be passed to pymongo's aggregate call
            See https://pymongo.readthedocs.io/en/stable/api/pymongo/collection.html#pymongo.collection.Collection.aggregate
        """
        using_deprecated_interface = isinstance(pipeline, dict) or bool(suppl_pipeline)
        user_pipeline = [pipeline] if isinstance(pipeline, dict) else list(pipeline)

        if using_deprecated_interface:
            msg = "Calling .aggregate() with un unpacked list (*pipeline) is deprecated, it will soon change and will expect a list (similar to pymongo.Collection.aggregate interface), see documentation"
            warnings.warn(msg, DeprecationWarning)

        user_pipeline += suppl_pipeline

        initial_pipeline = []
        if self._none or self._empty:
            initial_pipeline.append({"$limit": 1})
            initial_pipeline.append({"$match": {"$expr": False}})

        if self._query:
            initial_pipeline.append({"$match": self._query})

        if self._ordering:
            initial_pipeline.append({"$sort": dict(self._ordering)})

        if self._limit is not None:
            # As per MongoDB Documentation (https://www.mongodb.com/docs/manual/reference/operator/aggregation/limit/),
            # keeping limit stage right after sort stage is more efficient. But this leads to wrong set of documents
            # for a skip stage that might succeed these. So we need to maintain more documents in memory in such a
            # case (https://stackoverflow.com/a/24161461).
            initial_pipeline.append({"$limit": self._limit + (self._skip or 0)})

        if self._skip is not None:
            initial_pipeline.append({"$skip": self._skip})

        final_pipeline = initial_pipeline + user_pipeline

        collection = self._collection
        if self._read_preference is not None or self._read_concern is not None:
            collection = self._collection.with_options(
                read_preference=self._read_preference, read_concern=self._read_concern
            )

        return collection.aggregate(final_pipeline, cursor={}, **kwargs)

    # JS functionality
    def map_reduce(