Python django.db.models.aggregates.Count() Examples

def get_tag():
    tag_list = Tag.objects.annotate(post_num=Count('post')).order_by('-post_num')
    return tag_list 

def remove_duplicate_physical_interfaces(apps, schema_editor):
    Interface = apps.get_model("maasserver", "Interface")

    # Find duplicated physical interfaces and remove them, keeping only the
    # interface that has IP addresses or the latest physical interface.
    qs = Interface.objects.values("type", "mac_address")
    qs = qs.filter(type="physical")
    qs = qs.order_by()  # clear default ordering
    qs = qs.annotate(ids=ArrayAgg("id")).annotate(count=Count("id"))
    qs = qs.filter(count__gt=1)
    for entry in qs:
        nic_ids = list(sorted(entry["ids"]))
        has_ips = list(
            sorted(
                nic.id
                for nic in Interface.objects.filter(id__in=nic_ids)
                if nic.ip_addresses.all()
            )
        )
        if len(has_ips) == 0:
            # None of the physical interfaces have an IP address, remove
            # the older interfaces.
            Interface.objects.filter(id__in=nic_ids[:-1]).delete()
        elif len(has_ips) == 1:
            # Keep only the physical interface that has IP addresses.
            nic_ids.remove(has_ips[0])
            Interface.objects.filter(id__in=nic_ids).delete()
        else:
            # Remove those that have no IPs.
            no_ips = set(nic_ids) - set(has_ips)
            if no_ips:
                Interface.objects.filter(id__in=no_ips).delete()
            # Multiple have IP addresses. Remove the IP addresses from the
            # others and only keep the latest with IP addresses.
            for nic in Interface.objects.filter(id__in=has_ips[:-1]):
                nic.ip_addresses.all().delete()
                nic.delete() 

def items(self):
        return Tag.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def items(self):
        return Category.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def get_category_list():
    '''返回分类列表'''
    return Category.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def get_tag_list():
    '''返回标签列表'''
    return Tag.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def get_toolcates():
    '''获取所有工具分类，只显示有工具的分类'''
    return ToolCategory.objects.annotate(total_num=Count('toollink')).filter(total_num__gt=0) 

def _get_points_earned_trials_count(self):
        """Get points earned and trials count from the sequence.

        :return tuple([trials_count, points_earned])
        """
        # Note(idegtiarov) With the first non-problem activity in the sequence and default value of the threshold
        # item_result returns None, 0 which are not appropriate for the grade calculation method, valid default values
        # are provided to fix this issue.
        items_result = self.sequence.items.exclude(is_problem=False).aggregate(
            points_earned=Coalesce(Sum('score'), 0), trials_count=Greatest(Count('score'), 1)
        )
        return items_result['trials_count'], items_result['points_earned'] 

def _get_points_earned_trials_count(self):
        """Get points earned and trials count from the sequence.

        :return tuple([trials_count, points_earned])
        """
        items_result = self.sequence.items.aggregate(
            points_earned=Sum('score'), trials_count=Count('score')
        )
        return items_result['trials_count'], items_result['points_earned'] 

def show_tags(context):
    tag_list = Tag.objects.annotate(num_posts=Count('post')).filter(num_posts__gt=0)
    return {
        'tag_list': tag_list,
    } 

def show_categories(context):
    category_list = Category.objects.annotate(num_posts=Count('post')).filter(num_posts__gt=0)
    return {
        'category_list': category_list,
    } 

def get_comment_rank(num=5):
    app_model = settings.COMMENT_ENTRY_MODEL.split('.')
    Post = apps.get_model(*app_model)
    post_list = Post.objects.annotate(comment_num=Count('comment')).order_by('-comment_num')
    return post_list[:num] 

def get_count(self, using):
        """
        Performs a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def get_category():
    category_list = Category.objects.annotate(post_num=Count('post')).order_by('-post_num')
    Category.objects.values()
    return category_list 

def get_count(self, using):
        """
        Performs a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def items(self):
        return Tag.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def items(self):
        return Category.objects.annotate(total_num=Count('article')).filter(total_num__gt=0) 

def get_tag_list():
    """返回标签列表"""
    return Tag.objects.annotate(total_num=Count('article')).filter(total_num__gt=0)


# 返回活跃的友情链接查询集 

def get_count(self, using):
        """
        Performs a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def get_count(self, using):
        """
        Performs a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def get_count(self, using):
        """
        Perform a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def get_hot_discussions(num=5):
    """
    得到指定数量的热门讨论

    :param num: 想要得到的讨论数量
    :return: Discuss模型的实例列表
    """
    discussions = Discuss.objects.annotate(reply_num=Count('replys')).all()
    discussions = sorted(discussions, key=lambda x: x.reply_num, reverse=True)
    return discussions[:num] 

def all_hot_dicussions(request):
    discussions = Discuss.objects.annotate(reply_num=Count('replys')).all()[:10]
    discussions = sorted(discussions, key=lambda x: x.reply_num, reverse=True)

    context = {
        'discussions': discussions,
    }
    return render(request, 'Discussion/hot_discussions.html', context=context) 

def get_count(self, using):
        """
        Perform a COUNT() query using the current filter constraints.
        """
        obj = self.clone()
        obj.add_annotation(Count('*'), alias='__count', is_summary=True)
        number = obj.get_aggregation(using, ['__count'])['__count']
        if number is None:
            number = 0
        return number 

def clean_bmcs(apps, schema_editor):
    BMC = apps.get_model("maasserver", "BMC")
    Node = apps.get_model("maasserver", "Node")

    # delete BMCs that are not linked to any node
    BMC.objects.exclude(
        id__in=Node.objects.values("bmc_id")
    ).distinct().delete()

    # find duplicated BMCs and remove them, moving nodes to the only one left
    # for each group
    bmc_ids_to_delete = []

    qs = BMC.objects.values("power_type", "power_parameters")
    qs = qs.exclude(power_type="manual")
    qs = qs.annotate(ids=ArrayAgg("id")).annotate(count=Count("id"))
    qs = qs.filter(count__gt=1)
    for entry in qs:
        bmc_ids = entry["ids"]
        bmc_id = bmc_ids.pop()
        Node.objects.filter(bmc_id__in=bmc_ids).update(bmc_id=bmc_id)
        bmc_ids_to_delete.extend(bmc_ids)

    if bmc_ids_to_delete:
        BMC.objects.filter(id__in=bmc_ids_to_delete).delete()

    # find non-chassis BMCs that are linked to multiple nodes.  Such cases are
    # not valid, so we unset the BCM for all nodes except one, so BMC
    # parameters (such as user/password) are not lost. Users will likely have
    # to fix those node manually anyway.
    qs = BMC.objects.values("id")
    qs = qs.filter(power_type__in=NON_CHASSIS_POWER_TYPES)
    qs = qs.annotate(node_ids=ArrayAgg("node"), node_count=Count("node"))
    qs = qs.filter(node_count__gt=1)
    node_ids_to_unset = []
    for entry in qs:
        node_ids = entry["node_ids"]
        node_ids.pop()  # keep one node with the original
        node_ids_to_unset.append(node_ids)

    if node_ids_to_unset:
        Node.objects.filter(id__in=node_ids_to_unset).update(bmc_id=None)