Django görünümünde iki veya daha fazla sorgu kümesini nasıl birleştiririm?

Yaptığım bir Django sitesi için arama yapmaya çalışıyorum ve bu aramada 3 farklı modelde arıyorum. Ve arama sonucu listesinde sayfalandırma almak için, sonuçları görüntülemek için genel bir object_list görünümü kullanmak istiyorum. Ama bunu yapmak için, 3 sorgu kümesini bir araya getirmeliyim.

Bunu nasıl yapabilirim? Bunu denedim:

result_list = []            
page_list = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
article_list = Article.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term) | 
    Q(tags__icontains=cleaned_search_term))
post_list = Post.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term) | 
    Q(tags__icontains=cleaned_search_term))

for x in page_list:
    result_list.append(x)
for x in article_list:
    result_list.append(x)
for x in post_list:
    result_list.append(x)

return object_list(
    request, 
    queryset=result_list, 
    template_object_name='result',
    paginate_by=10, 
    extra_context={
        'search_term': search_term},
    template_name="search/result_list.html")

Ama bu işe yaramıyor. Bu listeyi genel görünümde kullanmaya çalıştığımda bir hata alıyorum. Listede klon özelliği eksik.

Üç listeyi nasıl birleştirebileceğimi bilen var mı page_list, article_listve post_list?

Querysets'i bir liste halinde birleştirmek en basit yaklaşımdır. Veritabanı yine de tüm sorgu kümeleri için vurulacaksa (örneğin sonucun sıralanması gerektiğinden), bu ek maliyet getirmez.

from itertools import chain
result_list = list(chain(page_list, article_list, post_list))

Kullanılması itertools.chainiçin, daha hızlı her liste döngü ve elemanları tek tek ekleme daha itertoolsAyrıca bitiştirme önce liste halinde her Sorgu Kümesi dönüştürmek daha az bellek kullanır C'de uygulanır.

Artık ortaya çıkan listeyi örneğin tarihe göre sıralamak mümkündür (hasen j'nin başka bir cevaba yaptığı yorumda istendiği gibi). sorted()Fonksiyon elverişli bir jeneratör kabul eder ve bir liste döndürür:

result_list = sorted(
    chain(page_list, article_list, post_list),
    key=lambda instance: instance.date_created)

Python 2.4 veya üstünü kullanıyorsanız attrgetterlambda yerine kullanabilirsiniz . Daha hızlı olduğunu okuduğumu hatırlıyorum, ancak bir milyon öğe listesi için fark edilir bir hız farkı görmedim.

from operator import attrgetter
result_list = sorted(
    chain(page_list, article_list, post_list),
    key=attrgetter('date_created'))

Bunu dene:

matches = pages | articles | posts

İsterseniz order_byveya benzeri güzel olan querysetlerin tüm işlevlerini korur .

Lütfen dikkat: Bu, iki farklı modeldeki sorgu kümelerinde çalışmaz.

İlgili, aynı modeldeki sorgu kümelerini veya birkaç modeldeki benzer alanları karıştırmak için, Django 1.11 ile başlayarak bir qs.union()yöntem de mevcuttur:

union()

union(*other_qs, all=False)

Django 1.11'de yeni . İki veya daha fazla Sorgu Kümesinin sonuçlarını birleştirmek için SQL'in UNION işlecini kullanır. Örneğin:

>>> qs1.union(qs2, qs3)

UNION operatörü varsayılan olarak yalnızca farklı değerler seçer. Yinelenen değerlere izin vermek için all = True bağımsız değişkenini kullanın.

union (), intersection () ve fark (), argümanlar diğer modellerin QuerySets olsa bile, ilk QuerySet türünün model örneklerini döndürür. Farklı modelleri geçmek, SEÇİM listesi tüm Sorgu Kümelerinde aynı olduğu sürece çalışır (en azından türler, adlar aynı sıradaki türler kadar önemli değildir).

Ayrıca, elde edilen Sorgu Kümesinde yalnızca LIMIT, OFFSET ve ORDER BY (dilimleme ve order_by ()) işlevlerine izin verilir. Ayrıca, veritabanları birleştirilmiş sorgularda hangi işlemlere izin verildiğine kısıtlamalar getirir. Örneğin, çoğu veritabanı birleştirilmiş sorgularda LIMIT veya OFFSET öğesine izin vermez.

https://docs.djangoproject.com/en/1.11/ref/models/querysets/#django.db.models.query.QuerySet.union

QuerySetChainAşağıdaki sınıfı kullanabilirsiniz . Django'nun sayfalandırıcısı ile birlikte kullanıldığında, veritabanına yalnızca COUNT(*)tüm SELECT()sorgu kümeleri için sorgularla ve yalnızca kayıtları geçerli sayfada görüntülenen sorgu kümeleri için sorgularla vurulmalıdır.

Zincirlenmiş sorgu kümelerinin tümü aynı modeli kullanıyor olsa bile, genel görünümlere sahip template_name=bir a kullanıp kullanmayacağınızı belirtmeniz gerektiğini unutmayın QuerySetChain.

from itertools import islice, chain

class QuerySetChain(object):
    """
    Chains multiple subquerysets (possibly of different models) and behaves as
    one queryset.  Supports minimal methods needed for use with
    django.core.paginator.
    """

    def __init__(self, *subquerysets):
        self.querysets = subquerysets

    def count(self):
        """
        Performs a .count() for all subquerysets and returns the number of
        records as an integer.
        """
        return sum(qs.count() for qs in self.querysets)

    def _clone(self):
        "Returns a clone of this queryset chain"
        return self.__class__(*self.querysets)

    def _all(self):
        "Iterates records in all subquerysets"
        return chain(*self.querysets)

    def __getitem__(self, ndx):
        """
        Retrieves an item or slice from the chained set of results from all
        subquerysets.
        """
        if type(ndx) is slice:
            return list(islice(self._all(), ndx.start, ndx.stop, ndx.step or 1))
        else:
            return islice(self._all(), ndx, ndx+1).next()

Örneğinizde, kullanım şöyle olacaktır:

pages = Page.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term))
articles = Article.objects.filter(Q(title__icontains=cleaned_search_term) |
                                  Q(body__icontains=cleaned_search_term) |
                                  Q(tags__icontains=cleaned_search_term))
posts = Post.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term) | 
                            Q(tags__icontains=cleaned_search_term))
matches = QuerySetChain(pages, articles, posts)

Ardından , örneğinizde matcheskullandığınız gibi sayfalayıcı ile kullanın result_list.

itertoolsO Django üzerinde çalışan tüm Python sürümlerinde kullanılabilir olduğundan bu modül, Python 2.3 kullanılmaya başlandı.

Mevcut yaklaşımınızın en büyük dezavantajı, yalnızca bir sayfa sayfasını görüntüleyecek olsanız bile, her seferinde tüm sonuç kümesini veritabanından çekmeniz gerektiğinden, büyük arama sonucu kümelerindeki verimsizliğidir.

Sadece gerçekten ihtiyacınız olan nesneleri veritabanından aşağı çekmek için, bir liste değil, bir Sorgu Kümesi'nde sayfalandırma kullanmanız gerekir. Bunu yaparsanız, Django aslında QuerySet'i sorgu yürütülmeden önce dilimler, böylece SQL sorgusu yalnızca gerçekte görüntüleyeceğiniz kayıtları almak için OFFSET ve LIMIT kullanır. Ancak, aramanızı bir şekilde tek bir sorguda sıkıştıramadıkça bunu yapamazsınız.

Üç modelinizin de başlık ve gövde alanlarına sahip olduğu düşünüldüğünde, neden model mirasını kullanmıyorsunuz ? Her üç modelin de başlık ve gövdeye sahip ortak bir atadan miras almasını ve aramayı ata modelinde tek bir sorgu olarak gerçekleştirmesini sağlayın.

Çok sayıda sorgu kümesini zincirlemek istiyorsanız, şunu deneyin:

from itertools import chain
result = list(chain(*docs))

burada: dokümanlar sorgu kümelerinin bir listesidir

DATE_FIELD_MAPPING = {
    Model1: 'date',
    Model2: 'pubdate',
}

def my_key_func(obj):
    return getattr(obj, DATE_FIELD_MAPPING[type(obj)])

And then sorted(chain(Model1.objects.all(), Model2.objects.all()), key=my_key_func)

Alıntı: https://groups.google.com/forum/#!topic/django-users/6wUNuJa4jVw . Bakınız Alex Gaynor

Bu da iki şekilde gerçekleştirilebilir.

Bunu yapmanın ilk yolu

Queryset |için birleşim operatörünü kullanarak iki queryset birleşimini alın. Her iki queryset de aynı modele / tek modele aitse, senders operatörünü kullanarak queryset'leri birleştirmek mümkündür.

Bir örnek için

pagelist1 = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
pagelist2 = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
combined_list = pagelist1 | pagelist2 # this would take union of two querysets

Bunu yapmanın 2. yolu

İki queryset arasındaki birleştirme işlemini gerçekleştirmenin bir başka yolu da itertools zincir fonksiyonunu kullanmaktır .

from itertools import chain
combined_results = list(chain(pagelist1, pagelist2))

Gereksinimler: Django==2.0.2 ,django-querysetsequence==0.8

Birleştirmek querysetsve hala a ile çıkmak QuerySetistiyorsanız, django-queryset-dizisini kontrol etmek isteyebilirsiniz .

Ama bununla ilgili bir not. querysetsTartışma olarak sadece iki tane alır . Ancak python ile reduceher zaman birden fazla querysets'ye uygulayabilirsiniz .

from functools import reduce
from queryset_sequence import QuerySetSequence

combined_queryset = reduce(QuerySetSequence, list_of_queryset)

Ve bu kadar. Aşağıda ben koştum bir durumdur ve ben istihdam nasıl list comprehension, reducevedjango-queryset-sequence

from functools import reduce
from django.shortcuts import render    
from queryset_sequence import QuerySetSequence

class People(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    mentor = models.ForeignKey('self', null=True, on_delete=models.SET_NULL, related_name='my_mentees')

class Book(models.Model):
    name = models.CharField(max_length=20)
    owner = models.ForeignKey(Student, on_delete=models.CASCADE)

# as a mentor, I want to see all the books owned by all my mentees in one view.
def mentee_books(request):
    template = "my_mentee_books.html"
    mentor = People.objects.get(user=request.user)
    my_mentees = mentor.my_mentees.all() # returns QuerySet of all my mentees
    mentee_books = reduce(QuerySetSequence, [each.book_set.all() for each in my_mentees])

    return render(request, template, {'mentee_books' : mentee_books})

işte bir fikir ... sadece üçünün her birinden tam bir sonuç sayfası çekin ve en az 20 yararlı olanı atın ... bu büyük sorgu kümelerini ortadan kaldırır ve bu şekilde çok değil, sadece küçük bir performanstan ödün verirsiniz.

Bu işi başka kütüphaneler kullanmadan yapacak

result_list = list(page_list) + list(article_list) + list(post_list)

Bu özyinelemeli işlev, sorgu kümesi dizisini bir sorgu kümesinde birleştirir.

def merge_query(ar):
    if len(ar) ==0:
        return [ar]
    while len(ar)>1:
        tmp=ar[0] | ar[1]
        ar[0]=tmp
        ar.pop(1)
        return ar