小编Mar*_*ark的帖子

我有模型：

class Post(models.Model):
    content = models.CharField()
    user = models.ForeignKey('users.User')
    active = models.BooleanField(default=True)

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name='post_comments')

还有一个由查询参数过滤的查询集：

user = request.QUERY_PARAMS.get('user_id', None)
active = request.QUERY_PARAMS.get('active', None)
has_comments = request.QUERY_PARAMS.get('has_comments', None)

qs = Post.objects.all()

if user:
    qs = qs.filter(user=user)
if active:
    qs = qs.filter(active=active)
if has_comments:
    ???

我不知道如何在维护所有以前的过滤器的同时过滤此查询。是否可以？

我有两个 Django 模型：

class Person(models.Model):
    unique_id = models.CharField()

class PersonData(models.Model):
    person = models.ForeignKey('Person')
    phone = models.CharField()
    email = models.CharField()
    date = models.DateTimeField()

PersonData当信息发生变化时，会添加新对象，但会保留旧对象。然后我想要一个过滤器，它将根据与PersonData他们相关的最新对象中的数据来过滤人员。

我有以下查询集：

filter_email = "email@example.com"
filter_phone = "964477425"

qs = Person.objects.all()

if filter_email:
    qs = qs.filter(persondata__email__icontains=filter_email)
if filter_phone:
    qs = qs.filter(persondata__phone__icontains=filter_phone)

但该过滤器会搜索与PersonData关联的每个对象Person。是否可以将此过滤器限制为仅最新PersonData对象？

在SQLAlchemy中是否可以将现有数据库表自动化为类,但是覆盖某些表的某些字段？

我正在腌制MetaData对象,因为它需要一些时间,它包含所有表,但是当我试图覆盖某些对象时,它引发了一个异常,即MetaData对象未绑定到Engine或Connection.

from sqlalchemy.ext.automap import automap_base
from sqlalchemy import create_engine, MetaData, Column, String, Integer
import os, pickle

class MetadataCache(object):
    def __init__(self, engine, schema):
        self.engine = engine
        self.schema = schema
        self.metadata = None

    @property
    def cache_name(self):
        final_name = '{0}.{1}.cache'.format(self.engine.url.database,
                                            self.schema)
        return final_name

    def get_or_create_metadata(self):

        if os.path.exists(self.cache_name):
            with open(self.cache_name, 'r') as cachefile:
                self.metadata = pickle.load(cachefile)
        else:
            self.metadata = MetaData()
            self.metadata.reflect(bind=self.engine, schema=self.schema)
            with open(self.cache_name, 'w') as cachefile:
                pickle.dump(self.metadata, cachefile)

        return self.metadata

engine = create_engine('...')
metadata = MetadataCache(engine, 'schemaname').get_or_create_metadata()
Base = automap_base(metadata=metadata)


class User(Base): …

我有对象报告和报告订阅者，我想计算报告的订阅者数量。

一种解决方案是注释。我有很多报告，所以注释所有报告需要大约 6 秒，所以我认为在分页后注释可能更好：

filter_search = ReportFilter(request.GET, queryset=Report.objects.filter(
        created_at__gt=start_date,
        created_at__lte=end_date,
        is_confirmed__exact=True,
    ).annotate(sub_count=Count("reportsubscriber")).order_by('-sub_count'))

paginator = Paginator(filter_search, 20)

result = paginator.page(1).object_list.annotate(
                sub_count=Count("reportsubscriber"))

它起作用了，但花费了相同的时间，当我检查查询时，它实际上仍然遍历了 report_subscriber 表中的所有行。所以我尝试使用 .extra()

filter_search = ReportFilter(request.GET, queryset=Report.objects.filter(
            created_at__gt=start_date,
            created_at__lte=end_date,
            is_confirmed__exact=True,
        ))

paginator = Paginator(filter_search, 20)
paged_reports = paginator.page(1)

result = filter_search.qs.extra(
            select={
                'sub_count': 'SELECT COUNT(*) FROM reports LEFT OUTER JOIN report_subscribers  \
                             ON (reports.id = report_subscribers.id) \
                             WHERE reports.id = report_subscribers.id \
                             AND report_subscribers.report_id IN %s \
                            ' % "(%s)" % ",".join([str(r.id) for r in paged_reports.object_list])
            },
            order_by=['sub_count']
        ) …