def aggregate(self, q=None, scroll_size=SEARCH_LIMIT, reset_query=True, **kwargs):
        """Perform an advanced query, and return *all* matching results.
        Will automatically perform multiple queries in order to retrieve all results.

        Note:
            All ``aggregate`` queries run in advanced mode, and ``info`` is not available.

        Arguments:
            q (str): The query to execute. **Default:** The current helper-formed query, if any.
                    There must be some query to execute.
            scroll_size (int): Maximum number of records returned per query. Must be
                    between one and the ``SEARCH_LIMIT`` (inclusive).
                    **Default:** ``SEARCH_LIMIT``.
            reset_query (bool): If ``True``, will destroy the current query after execution
                    and start a fresh one.
                    If ``False``, will keep the current query set.
                    **Default:** ``True``.

        Keyword Arguments:
            scroll_field (str): The field on which to scroll. This should be a field
                    that counts/indexes the entries.
                    This should be set in ``self.scroll_field``, but if your application
                    requires separate scroll fields for a single client,
                    it can be set in this way as well.
                    **Default**: ``self.scroll_field``.

        Returns:
            list of dict: All matching records.
        """
        scroll_field = kwargs.get("scroll_field", self.scroll_field)

        # If q not specified, use internal, helper-built query
        if q is None:
            res = self._aggregate(scroll_field=scroll_field, scroll_size=scroll_size)
            if reset_query:
                self.reset_query()
            return res
        # Otherwise, run an independent query as SearchHelper.search() does.
        else:
            return self.__class__(index=self.index, q=q, advanced=True,
                                  search_client=self._SearchHelper__search_client
                                  ).aggregate(scroll_size=scroll_size, reset_query=reset_query)