Python Django-复杂查询

假设我有两个模型：

class Profile(models.Model):
    #some fields here

class Ratings(models.Model):
    profile = models.ForeignKey(profile)
    category = models.IntegerField()
    points = models.IntegerField()

假设MySQL表“评级”的示例如下：

我的帖子数据和其他字段值中有以下值：

category_1_avg_val = 7
category_2_avg_val = 5
category_3_avg_val = 5
category_4_avg_val = 7
category_5_avg_val = 9

我想过滤的配置文件的平均评分计算类别更高或等于所需的值

一些过滤器最初应用为：

q1 = [('associated_with', search_for),
      ('profile_type__slug__exact', profile_type),
      ('gender__in', gender),
      ('rank__in', rank),
      ('styles__style__in', styles),
      ('age__gte', age_from),
      ('age__lte', age_to)]
q1_list = [Q(x) for x in q1 if x[1]]

q2 = [('user__first_name__icontains', search_term),
      ('user__last_name__icontains', search_term),
      ('profile_type__name__icontains', search_term),
      ('styles__style__icontains', search_term),
      ('rank__icontains', search_term)]
q2_list = [Q(x) for x in q2 if x[1]]

if q1_list:
    objects = Profile.objects.filter(
        reduce(operator.and_, q1_list))

if q2_list:
    if objects:
        objects = objects.filter(
            reduce(operator.or_, q2_list))
    else:
        objects = Profile.objects.filter(
            reduce(operator.or_, q2_list))

if order_by_ranking_level == 'desc':
    objects = objects.order_by('-ranking_level').distinct()
else:
    objects = objects.order_by('ranking_level').distinct()

现在我想过滤其（平均分数）（按类别分组）>=（文章中类别的平均值）的配置文件

我试着一个接一个地做

objects = objects.filter(
    ratings__category=1) \
    .annotate(avg_points=Avg('ratings__points'))\
    .filter(avg_points__gte=category_1_avg_val)


objects = objects.filter(
    ratings__category=2) \
    .annotate(avg_points=Avg('ratings__points'))\
    .filter(avg_points__gte=category_2_avg_val)

但我认为这是错误的。请帮帮我。如果return是一个查询集，那就太好了

已编辑 使用hynekcer发布的答案我想出了稍微不同的解决方案，因为我已经查询了一组需要根据评级进行更多筛选的个人资料

def check_ratings_avg(pr, rtd):
    ok = True
    qr = Ratings.objects.filter(profile__id=pr.id) \
        .values('category')\
        .annotate(points_avg=Avg('points'))
    qr = {i['category']:i['points_avg'] for i in qr}

    for cat in rtd:
        val = rtd[cat]
        if qr[cat] >= val:
            pass
        else:
            ok = False
            break
    return ok


rtd = {1: category_1_avg_val, 2: category_2_avg_val, 3: category_3_avg_val,
       4: category_4_avg_val, 5: category_5_avg_val}
objects = [i for i in objects if check_ratings_avg(i, rtd)]

---

您可以向管理器添加方法

# Untested code
class ProfileManager(models.Manager):
    def with_category_average(self, cat, avg):
        # Give each filter a unique annotation key
        key = 'avg_pts_' + str(cat)
        return self.filter(ratings__category=cat) \
                   .annotate(**{key: Avg('ratings__points')}) \
                   .filter(**{key + '__gte': avg})

    # Expects a dict of `cat: avg` pairs
    def filter_by_averages(self, avg_dict):
        qs = self.get_query_set()
        for key, val in avg_dict.items():
            qs &= self.with_category_average(key, val)
        return qs

---

复杂查询需要原则上的子查询。可能的解决办法是：

• 由或查询编写的子查询。它不是干的，一些数据库后端（例如MySQL的一些版本）不支持它，但是自Django 1.1以来，子查询的使用方式很有限
• 将中间结果保存到数据库中的临时表中。在Django不太好
• Python中外部循环查询的仿真。最好的通用解决方案。Python中通过第一个查询聚合数据库数据的循环可以足够快地聚合和过滤数据

A）Python模拟的子查询

from django.db.models import Q, Avg
from itertools import groupby
from myapp.models import Profile, Ratings

def iterator_filtered_by_average(dictionary):
    qr = Ratings.objects.values('profile', 'category', 'points').order_by(
            'profile', 'category').annotate(points_avg=Avg('points'))
    f = Q()
    for k, v in dictionary.iteritems():
        f |= Q(category=k, points_avg__gte=v)
    for profile, grp in groupby(qr.filter(f).values('profile')):
        if len(list(grp)) == len(dictionary):
            yield profile

#example
FILTER_DATA = {1:category_1_avg_val, 2:category_2_avg_val, 3:category_3_avg_val,
               4:category_4_avg_val, 5:category_5_avg_val}
for row in iterator_filtered_by_average(FILTER_DATA):
    print row

这是原始问题的一个简单解决方案，以后无需额外要求

B）带有子查询的解决方案：
这对于问题的更详细版本是必要的，因为如果初始筛选器基于类型为

ManyToManyField

的某个字段，并且还因为它包含

distinct

子句：

# objects:  QuerySet that you get from your initial filters. Not yet executed.
if rtd:
    # Method `as_nested_sql` removes the `order_by` clase, unlike `as_sql`
    subquery3 = objects.values('id').query \
            .get_compiler(connection=connection).as_nested_sql()
    subquery2 = ("""SELECT profile_id, category, avg(points) AS points_avg
          FROM myapp_ratings
          WHERE profile_id in
          ( %s
          ) GROUP BY profile_id, category
            """ % subquery3[0], subquery3[1]
    )
    where_sql = ' OR '.join(
            'category = %d AND points_avg >= %%s' % cat for cat in rtd.keys()
    )
    subquery = (
        """SELECT profile_id
        FROM
        ( %s
        ) subquery2
        WHERE %s
        GROUP BY profile_id
        HAVING count(*) = %s
        """ % (subquery2[0], where_sql, len(rtd)),
        subquery2[1] + tuple(rtd.values())
    )
    assert order_by_ranking_level in ('asc', 'desc')
    mainquery = ("""SELECT myapp_profile.* FROM myapp_profile
      INNER JOIN
      ( %s
      ) subquery ON subquery.profile_id=myapp_profile.id
      ORDER BY ranking_level %s"""
        % (subquery[0], order_by_ranking_level), subquery[1]
    )
    objects = Profile.objects.raw(mainquery[0], params=mainquery[1])
return objects

请将所有字符串

myapp

替换为应用程序的

name\u

此代码生成的SQL示例

SELECT myapp_profile.* FROM myapp_profile
  INNER JOIN
  ( SELECT profile_id
    FROM
    ( SELECT profile_id, category, avg(points) AS points_avg
      FROM myapp_ratings
      WHERE profile_id IN
      ( SELECT U0.`id` FROM `myapp_profile` U0 WHERE U0.`ranking_level` >= 4
      ) GROUP BY profile_id, category
    ) subquery2
    WHERE category = 1 AND points_avg >= 7 OR category = 2 AND points_avg >= 5
       OR category = 3 AND points_avg >= 5 OR category = 4 AND points_avg >= 7
       OR category = 5 AND points_avg >= 9
    GROUP BY profile_id
    HAVING count(*) = 5
  ) subquery ON subquery.profile_id=myapp_profile.id
  ORDER BY ranking_level asc

（为了更好的可读性，手动解析此SQL时，字符串

%s

被参数替换，但出于安全原因，数据库引擎接收未解析的参数。）

---

您的问题是由于很少支持Django生成的子查询。只有来自更复杂查询文档的示例才能创建子查询。（例如

注释后的
聚合
或
注释后的
计数
或
聚合
在
不同
后，但在
不同
后或
注释
后没有
注释
）复杂的嵌套聚合被简化为一个意外的查询

对于第一个查询筛选出的每个对象执行新的单独SQL查询的所有其他解决方案，都不鼓励用于生产，尽管它们对于测试任何更好的解决方案的结果非常有用。
虽然您的代码有一些错误，但我对其进行了测试，这与我在问题中提到的逐个进行注释相同。问题是，以这种方式，查询集将针对每个类别分别进行评估，我需要将所有类别合并在一起。这一行
qs.with_category\u average（key，val）
应该是
self.with_category\u average（key，val）
好吧，这应该是您所说的，但我发现我太习惯我的经理了。使用
&=
的这个版本怎么样？谢谢您的帮助，但是它仍然会产生错误的结果，不应该在queryset中的对象仍然会出现：（当一个配置文件满足条件>=对于所有5个等级类别，它应该出现在queryset中，如果任何类别平均值不满足条件>=它应该被排除，这在当时没有发生，我认为类别名称（模型配置文件和等级）应该像在Django中一样大写。否则，字段名
profile
很容易被相同的模型名混淆。是的，没错，实际上类名在我的models.py文件中是大写的。Jst忘了在这里这样做。关于acuall问题有什么想法吗？如果第一个“黑盒”过滤器将选择数百万个配置文件。运行数百万个SQL查询是一场噩梦。尽可能多的查询应该由一个查询集完成。请问，关于第一个“黑盒”过滤器，您能说些什么？它仅基于一个表（配置文件）或者更多？只能通过更多的
过滤器
和
排除
类型条件编写，最终也可以使用Q和F对象条件，但没有任何聚合函数？请在您的问题中描述这些附加限制的类型。@hynekcer我已经更新了我的问题，请检查
中的黑盒过滤器me过滤器最初应用为：
问题部分。如您所见，如果用户只进行
免费文本搜索
，
q1\u列表
将为空，并且将有许多配置文件。如果使用
q2\u列表
，则配置文件将减少。但仍不确定将有多少个配置文件。因此，最佳解决方案是：需要注意。
条件批注
我想你了：（在python中通过循环模拟外部查询的效率方面有多好？
考虑到
Profile
表中的500万条记录和
Rating
表中的500万行？速度取决于参数值
category.*\u avg.\u val
，这在很大程度上影响了单个条件的选择性。）（例如，您主要选择90%或10%的配置文件？）以及一个配置文件的典型评级数（略多于一个或数百个）。最好在预期数据上比较模拟查询解决方案和原始查询解决方案。（对我来说，这并不比您现在简单。我几小时前删除了测试应用程序。）实际上，这个查询将出现在搜索引擎中
SELECT myapp_profile.* FROM myapp_profile
  INNER JOIN
  ( SELECT profile_id
    FROM
    ( SELECT profile_id, category, avg(points) AS points_avg
      FROM myapp_ratings
      WHERE profile_id IN
      ( SELECT U0.`id` FROM `myapp_profile` U0 WHERE U0.`ranking_level` >= 4
      ) GROUP BY profile_id, category
    ) subquery2
    WHERE category = 1 AND points_avg >= 7 OR category = 2 AND points_avg >= 5
       OR category = 3 AND points_avg >= 5 OR category = 4 AND points_avg >= 7
       OR category = 5 AND points_avg >= 9
    GROUP BY profile_id
    HAVING count(*) = 5
  ) subquery ON subquery.profile_id=myapp_profile.id
  ORDER BY ranking_level asc