标签: django-select-related

我有一个简单的音乐模式:艺术家,发行,曲目和歌曲.前3个是所有逻辑结构,而第四个(Song)是(Artist,Release,Track)的特定实例,如mp3,wav,ogg等等.

我在数据库中生成有序的歌曲列表时遇到问题.美中不足的是,双方Track并Release有一个Artist.虽然Song.Track.Artist总是表演者的名字,但Song.Track.Release.Artist可能是表演者的名字,也可能是"各种艺术家"的编辑.我希望能够按其中一种排序,我无法弄清楚这项工作的正确方法.

这是我的架构:

class Artist(models.Model):
    name = models.CharField(max_length=512)

class Release(models.Model):
    name = models.CharField(max_length=512)
    artist = models.ForeignKey(Artist)

class Track(models.Model):
    name = models.CharField(max_length=512)
    track_number = models.IntegerField('Position of the track on its release')
    length = models.IntegerField('Length of the song in seconds')
    artist = models.ForeignKey(Artist)
    release = models.ForeignKey(Release)

class Song(models.Model):
    bitrate = models.IntegerField('Bitrate of the song in kbps')
    location = models.CharField('Permanent storage location of the file', max_length=1024)
    owner = models.ForeignKey(User)
    track = models.ForeignKey(Track)

我的查询应该相当简单; …

我想将模型属性预取到 Django 中的查询集。有没有办法做到这一点？

以下是三个模型：

class Place(models.Model):
    name = models.CharField(max_length=200, blank=True)
    @property
    def bestpicurl(self):
        try:
            return self.placebestpic.picture.file.url
        except:
            return None

class PlaceBestPic(models.Model):
    place = models.OneToOneField(Place)
    picture = models.ForeignKey(Picture, on_delete=models.CASCADE)

class Picture(models.Model):
    file = ImageField(max_length=500, upload_to="/images/")

我需要类似的东西：

qs = Place.objects.all().select_related('bestpicurl')

任何线索如何做到这一点？谢谢！

我在尝试通过多个OneToOneField关系选择相关时遇到了一个奇怪的错误,例如在目标字段是孙子类的情况下.我希望有人帮助我了解正在发生的事情(或确认这是Django中的一个错误).

插图:

# models.py
from django.db import models

class A(models.Model):
    pass

class B(A):
    pass

class C(B):
    pass

很简单吧？现在我用一个干净的数据库打开Django shell:

>>> C().save()
>>> A.objects.select_related('b__c')
[]

等等,什么？为什么该查询集为空？快速健全检查:

>>> A.objects.select_related('b')[0].b.c
<C: C object>

那么为什么select_related调用不起作用呢？好吧,看这个:

>>> A.objects.select_related('b__c').__iter__().next()
... 
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/opt/webapps/asdf/lib/python2.6/site-packages/django/db/models/query.py", line 107, in _result_iter
    self._fill_cache()
  File "/opt/webapps/asdf/lib/python2.6/site-packages/django/db/models/query.py", line 772, in _fill_cache
    self._result_cache.append(self._iter.next())
  File "/opt/webapps/asdf/lib/python2.6/site-packages/django/db/models/query.py", line 273, in iterator
    for row in compiler.results_iter():
  File "/opt/webapps/asdf/lib/python2.6/site-packages/django/db/models/sql/compiler.py", line 680, in results_iter
    for rows in self.execute_sql(MULTI):
  File …

在Django中,在推荐的设置中,UserProfile实例由OneToOneField与其User实例链接.

class UserProfile(models.Model):
    user = models.OneToOneField(User)
    data = ...

检索用户和配置文件的视图中最有效的方法是什么？我可以执行select_related()内连接查询,以获取一个数据库命中的两个对象吗？或者它总是归结为两个单独的电话？可能,Django的auth中间件甚至在调用视图之前检索用户实例...有人知道吗？

我将项目从Django 1.6.7更新到1.8.7并且我在Django 1.8中有以下异常,尽管使用Django 1.6它的代码是正确的:

In[2]: from apps.route import models
In[3]: models.Trace.objects.select_related("trace_points")
Out[3]: <repr(<django.db.models.query.QuerySet at 0x3b50c10>) failed: django.core.exceptions.FieldError: Invalid field name(s) given in select_related: 'trace_points'. Choices are: user>

我的模特:

class Trace(SocialMixin, models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='traces')
    name = models.CharField(u'????????', max_length=255)
    rating = RatingField(range=5, weight=0)
    start_date = models.DateTimeField(u'???? ??????')
    finish_date = models.DateTimeField(u'???? ?????????', null=True, blank=True)
    distance = models.DecimalField(max_digits=15, decimal_places=6, null=True, blank=True)
    created = models.DateTimeField(auto_now_add=True)
    hits = generic.GenericRelation(HitCount, object_id_field='object_pk')
    description = models.TextField(null=True, blank=True)

class TracePoint(models.Model):
    country = models.ForeignKey(Country, null=True, blank=True)
    city = models.ForeignKey(City, …

我似乎有一些关于如何在 Django 中以前向和后向关系预取相关字段的示例，但我怀疑如果我们想预取相关模型的所有字段，如何应用它。

例如，如果我想从以下模型中获取所有内容，使用HealthCheck作为起点。哪一个是实现这一目标的最优化查询？

class HealthCheck(models.Model):
    id = models.Integer()
    person = models.ForeignKey('Person')


class Person(models.Model):
    profile = models.ForeignKey('Profile')
    vaccines = models.ManyToManyField('vaccines', through='PersonVaccines')


class Profile(models.Model):
    name = models.CharField(max_length=16)


class PersonVaccines(models.Model):
    person = models.ForeignKey(Person)
    vaccine = models.ForeignKey('Vaccine')


class Vaccine(models.Model):
    name = models.CharField(max_length=16)

我尝试过类似的方法，但似乎不起作用：

from django.db.models import Prefetch

HealthCheck.objects.filter(id=1).prefetch_related(
    Prefetch(
        'person__vaccines',
        queryset=PersonVaccines.objects.select_related('person', 'person__profile', 'vaccine')
    )
)

如何预取所有相关内容？

entry_set 是否应该与 select_related 一起缓存？即使在我使用 select_related 之后，我的数据库仍然接到电话。相关部分

class Alias(models.Model):
    achievements = models.ManyToManyField('Achievement', through='Achiever')

    def points(self) :
        points = 0
        for a in self.achiever_set.all() :
            points += a.achievement.points * a.count
        return points

class Achievement(models.Model):
    name = models.CharField(max_length=100)
    points = models.IntegerField(default=1)

class Achiever(models.Model):
    achievement = models.ForeignKey(Achievement)
    alias = models.ForeignKey(Alias)
    count = models.IntegerField(default=1)

aliases = Alias.objects.all().select_related()
for alias in aliases :
    print "points : %s" % alias.points()
    for a in alias.achiever_set.all()[:5] :
        print "%s x %d" % (a.achievement.name, a.count)

我在开始时看到一个很大的连接查询，然后是对每个成就的单独调用。用于点和名称查找。

这是一个错误，还是我做错了什么？

我希望能够使用select_related或检查是否已获取相关对象prefetch_related，以便可以相应地序列化数据。这是一个例子：

class Address(models.Model):
    street = models.CharField(max_length=100)
    zip = models.CharField(max_length=10)

class Person(models.Model):
    name = models.CharField(max_length=20)
    address = models.ForeignKey(Address)

def serialize_address(address):
    return {
        "id": address.id,
        "street": address.street,
        "zip": address.zip
    }

def serialize_person(person):
    result = {
        "id": person.id,
        "name": person.name
    }
    if is_fetched(person.address):
        result["address"] = serialize_address(person.address)
    else:
        result["address"] = None

######

person_a = Person.objects.select_related("address").get(id=1)
person_b = Person.objects.get(id=2)

serialize_person(person_a) #should be object with id, name and address
serialize_person(person_b) #should be object with only id and name

在此示例中，该功能is_fetched正是我要寻找的。我想确定person对象是否已经具有解析地址，并且只有在具有解析地址的情况下，也应该对其进行序列化。但是，如果没有，则不应再执行任何数据库查询。

那么有没有办法在Django中实现呢？

我有以下型号。

class Car(models.Model):
    owner = models.ForeignKey('Driver')

class Country(models.Model)
    name = models.CharField(max_length=255)

class Driver(models.Model):
    name = models.CharField(max_length=255)
    age = models.IntegerField()
    country = models.ForeignKey('Country')

我想选择拥有汽车的司机的姓名。

Car.objects.all().values('owner__name')

我是否需要使用 select_related() 方法来避免每个对象的连接，或者它是多余的，因为 values() 方法是隐式的？

Car.objects.all().select_related('owner').values('owner__name')

同样，这次我想要拥有汽车的司机的国家名称。哪一个是最好的？

Car.objects.all().values('owner__country__name')
Car.objects.all().select_related('owner', 'country').values('owner__country__name')
Car.objects.all().select_related('owner__country').values('owner__country__name')

我正在研究API,我有一个问题.我正在研究select_related()的用法,以便为自己保存一些数据库查询,实际上它确实有助于减少执行的数据库查询量,以及大型和更复杂的查询.

我的问题是,使用select_related()会导致heasvier内存使用吗？运行一些实验我注意到确实是这种情况,但我想知道为什么.无论我是否使用select_related(),响应都将包含完全相同的数据,那么为什么使用select_related()会导致使用更多的内存？

是因为缓存吗？也许使用单独的数据对象来缓存相同的模型实例？我不知道还有什么想法.

提前致谢.

我在使用时在模板中显示相关表的字段时遇到问题 select_related()

这是我的模型:

class Customer(models.model):
    customer_name = models.CharField(max_length=500)

class Orders(models.model):
    cust_id = models.ForeignKey(Customers)
    invoice_number = models.IntegerField()
    invoice_creation_date = models.DateTimeField('Invoice Created Date')

class Products(models.Model):                                                   
    name = models.CharField(max_length=500)                                     
    description = models.CharField(max_length=500)                              
    price = models.DecimalField(max_digits=20, decimal_places=2)

class Orders_Products(models.Model):                                            
    order_id = models.ForeignKey(Orders)                                        
    product_id = models.ForeignKey(Products)                                    
    quantity = models.IntegerField(default=0)

这是我的观点:

def home(request):                                                              
    list_of_orders = Orders_Products.objects.select_related()
    template = 'erp_app/home.html'
    context = RequestContext(request, {'list_of_orders': list_of_orders})
    return render(request, template, context)

如何代表来自相关领域Orders和Products,尤其是Customers在模板中.例如,我想显示Orders.invoice_number,Products.name并Customer.customer_name从相同的相关记录.

例如:

{% for order in …

我在Child模型中创建了一个OneToOneField(父)related_name='children'.在我的观点中,我曾经select_related得到了查询集.但在我的页面中,与父项关联的子项列表显示为空.

Models.py:

class Parent(models.Model):
    item = models.CharField(max_length=20)

class Child(models.Model):
    parent = models.OneToOneField(Parent, unique = True, related_name = 'children')
    price = models.IntegerField()

views.py:

def live_prices(request):
    parent_queryset = Parent.objects.all().select_related('children')
    return render(request, 'live_prices.html', 'parent_queryset' : parent_queryset)

模板:

{% for parent in parent_queryset %}
{% child in parent.children.all %}
{{ child.price }}
{% endfor %}
{% endfor %}