'Return the dictionary with the values of the existing aggregations.'

def get_aggregation(self, using, added_aggregate_names):

    if (not self.annotation_select):
        return {}
    has_limit = ((self.low_mark != 0) or (self.high_mark is not None))
    has_existing_annotations = any((annotation for (alias, annotation) in self.annotations.items() if (alias not in added_aggregate_names)))
    if (isinstance(self.group_by, tuple) or has_limit or has_existing_annotations or self.distinct or self.combinator):
        from django.db.models.sql.subqueries import AggregateQuery
        outer_query = AggregateQuery(self.model)
        inner_query = self.clone()
        inner_query.select_for_update = False
        inner_query.select_related = False
        if ((not has_limit) and (not self.distinct_fields)):
            inner_query.clear_ordering(True)
        if (not inner_query.distinct):
            if (inner_query.default_cols and has_existing_annotations):
                inner_query.group_by = (self.model._meta.pk.get_col(inner_query.get_initial_alias()),)
            inner_query.default_cols = False
        relabels = {t: 'subquery' for t in inner_query.alias_map}
        relabels[None] = 'subquery'
        col_cnt = 0
        for (alias, expression) in list(inner_query.annotation_select.items()):
            if expression.is_summary:
                (expression, col_cnt) = inner_query.rewrite_cols(expression, col_cnt)
                outer_query.annotations[alias] = expression.relabeled_clone(relabels)
                del inner_query.annotations[alias]
            inner_query.set_annotation_mask(inner_query.annotation_select_mask)
        if ((inner_query.select == ()) and (not inner_query.default_cols) and (not inner_query.annotation_select_mask)):
            inner_query.select = (self.model._meta.pk.get_col(inner_query.get_initial_alias()),)
        try:
            outer_query.add_subquery(inner_query, using)
        except EmptyResultSet:
            return {alias: None for alias in outer_query.annotation_select}
    else:
        outer_query = self
        self.select = ()
        self.default_cols = False
        self._extra = {}
    outer_query.clear_ordering(True)
    outer_query.clear_limits()
    outer_query.select_for_update = False
    outer_query.select_related = False
    compiler = outer_query.get_compiler(using)
    result = compiler.execute_sql(SINGLE)
    if (result is None):
        result = [None for q in outer_query.annotation_select.items()]
    converters = compiler.get_converters(outer_query.annotation_select.values())
    result = next(compiler.apply_converters((result,), converters))
    return {alias: val for ((alias, annotation), val) in zip(outer_query.annotation_select.items(), result)}
