What you are seeing is a reverse related object lookup. In your example: class Blog(models.Model): pass class Entry(..): blog = Blog(..) Now, given object e of type Entry, you would do e.blog to access the related object Blog – which is a forward relation. The _set is a reverse lookup class variable django puts in … Read more
Concatenating the querysets into a list is the simplest approach. If the database will be hit for all querysets anyway (e.g. because the result needs to be sorted), this won’t add further cost. from itertools import chain result_list = list(chain(page_list, article_list, post_list)) Using itertools.chain is faster than looping each list and appending elements one by … Read more
Asset.objects.filter( project__name__contains=”Foo” )
You can use JsonResponse with values. Simple example: from django.http import JsonResponse def some_view(request): data = list(SomeModel.objects.values()) # wrap in list(), because QuerySet is not JSON serializable return JsonResponse(data, safe=False) # or JsonResponse({‘data’: data}) Or another approach with Django’s built-in serializers: from django.core import serializers from django.http import HttpResponse def some_view(request): qs = SomeModel.objects.all() qs_json … Read more
This is exactly what select_related() does. The only gotcha is that you have to start with the Answer model, rather than Question, but the result is the same: answers = Answer.objects.filter(question_id=1).select_related() Now each answer object has a pre-fetched ‘question’ attribute, and accessing it won’t hit the db again.
In your admin definition, you can define a queryset() method that returns the queryset for that model’s admin. eg: class MyModelAdmin(admin.ModelAdmin): def queryset(self, request): qs = super(MyModelAdmin, self).queryset(request) return qs.filter(user=request.user) Then only objects with user=request.user will be visible in the admin.
>>> from django.db import connection >>> cursor = connection.cursor() >>> cursor.execute(”’SELECT count(*) FROM people_person”’) 1L >>> row = cursor.fetchone() >>> print row (12L,) >>> Person.objects.all().count() 12 use WHERE clause to filter vote for yes: >>> cursor.execute(”’SELECT count(*) FROM people_person WHERE vote = “yes””’) 1L
You may not be able to do it directly. From the documentation of list_display ManyToManyField fields aren’t supported, because that would entail executing a separate SQL statement for each row in the table. If you want to do this nonetheless, give your model a custom method, and add that method’s name to list_display. (See below … Read more
The values() method returns a QuerySet containing dictionaries: <QuerySet [{‘comment_id’: 1}, {‘comment_id’: 2}]> The values_list() method returns a QuerySet containing tuples: <QuerySet [(1,), (2,)]> If you are using values_list() with a single field, you can use flat=True to return a QuerySet of single values instead of 1-tuples: <QuerySet [1, 2]>
Ok…this post is now old BUT what you could do is get all the ids of the objects in your list, then perform a model.objects.filter(pk__in=list_of_ids)