Ticket #2076: ticket-2076.6.diff

old-ticket2076.5/django/core/management.py

@@ -1033 +1033 @@
-                    field_name = field_name[1:]
-                if opts.order_with_respect_to and field_name == '_order':
-                    continue
-
+
+
+
-                try:
-                    opts.get_field(field_name, many_to_many=False)
-                except models.FieldDoesNotExist:

old-ticket2076.5/django/db/models/query.py

@@ -471 +471 @@
-        where.extend(where2)
-        params.extend(params2)
-
+        # Resolve order_by dependencies before joins to order by related tables
+        order_by = []
+        if self._order_by is not None: # use order_by = () to disable ordering
+            ordering_to_use = self._order_by
+        else:
+            ordering_to_use = opts.ordering
+
+        for f in handle_legacy_orderlist(ordering_to_use):
+            if "." in f: # dot-style field, fall back to old ordering code below
+                order_by = []
+                break
+            elif f == '?': # Special case.
+                order_by.append(backend.get_random_function_sql())
+                break
+            elif f.startswith('-'):
+                path = f[1:].split(LOOKUP_SEPARATOR)
+                order = "DESC"
+            else:
+                path = f.split(LOOKUP_SEPARATOR)
+                order = "ASC"
+
+            joins3, where3, params3 = lookup_inner(path, 'exact', False, opts, opts.db_table, None)
+            joins.update(joins3)
+
+            # hack to get fieldname to order by. modify lookup_inner to supply this instead.
+            field = where3[0].replace(' = %s', '')
+            order_by.append('%s %s' % (field, order))
+
-        # Add additional tables and WHERE clauses based on select_related.
-        if self._select_related:
-            fill_table_cache(opts, select, tables, where, opts.db_table, [opts.db_table])
@@ -496 +524 @@
-            sql.append(where and "WHERE " + " AND ".join(where))
-
-        # ORDER BY clause
-        order_by = []
-        if self._order_by is not None:
-            ordering_to_use = self._order_by
-        else:
-            ordering_to_use = opts.ordering
+        if order_by: # dont try to set up ordering again if already done
+            ordering_to_use = []
-        for f in handle_legacy_orderlist(ordering_to_use):
-
-
+
+
+
+
+
+
+
+
+
+
-            else:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        if order_by:
-            sql.append("ORDER BY " + ", ".join(order_by))
-

old-ticket2076.5/docs/db-api.txt

@@ -420 +420 @@
-
-    Entry.objects.order_by('?')
-
-
-
+
+
+
+
-
-
+
+
+
+
+
+
-
-There's no way to specify whether ordering should be case sensitive. With
-respect to case-sensitivity, Django will order results however your database

old-ticket2076.5/tests/modeltests/ordering/models.py

@@ -11 +11 @@
-
-The ordering attribute is not required. If you leave it off, ordering will be
-undefined -- not random, just undefined.
+
+This also applies for models that have a relationship to another model, you
+can use the name of the related field just like you'd any other field to
+specify ordering of the model instances in the ``Meta.ordering`` attribute or
+the ``order_by`` queryset method.
+
+Another feature is that you can even order by a field of the related model,
+for this you use a notation similar to the one used in field lookup, that is
+``relationname__fieldname`` (that's a double-underscore).
-"""
-
-from django.db import models
@@ -24 +33 @@
-    def __str__(self):
-        return self.headline
-
+class ReaderLetter(models.Model):
+    article = models.ForeignKey(Article, null=True)
+    reader_name = models.CharField(maxlength=100)
+    date_sent = models.DateTimeField()
+    class Meta:
+        ordering = ('reader_name',)
+
+    def __str__(self):
+        if self.article is None:
+            return self.reader_name
+        else:
+            return "%s, %s" % (self.reader_name, self.article)
+
+class EditorResponse(models.Model):
+    reader_letter = models.ForeignKey(ReaderLetter)
+    editor_name = models.CharField(maxlength=100)
+    class Meta:
+        ordering = ('editor_name',)
+
+    def __str__(self):
+        return "%s, %s" % (self.editor_name, self.reader_letter)
+
+class Reporter(models.Model):
+    name = models.CharField(maxlength=30)
+    articles = models.ManyToManyField(Article)
+    class Meta:
+        ordering = ('articles__headline',)
+
+    def __str__(self):
+        r = "%s" % (self.name)
+        if self.articles.count():
+            r += '; articles: %s' % ', '.join([str(a) for a in self.articles.all()])
+        return r
+
-__test__ = {'API_TESTS':"""
-# Create a couple of Articles.
->>> from datetime import datetime
@@ -64 +107 @@
-# don't know what order the output will be in.
->>> Article.objects.order_by('?')
-[...]
+
+# Create some reader letters.
+# First the ones sent as comments about some article.
+>>> rl1 = ReaderLetter.objects.create(reader_name='Reader D', article=a1, date_sent=(datetime(2005, 8, 5)))
+>>> rl2 = ReaderLetter.objects.create(reader_name='Reader D', article=a2, date_sent=(datetime(2005, 8, 4)))
+>>> rl3 = ReaderLetter.objects.create(reader_name='Reader C', article=a4, date_sent=(datetime(2005, 8, 3)))
+>>> rl4 = ReaderLetter.objects.create(reader_name='Reader B', article=a4, date_sent=(datetime(2005, 8, 2)))
+>>> rl5 = ReaderLetter.objects.create(reader_name='Reader A', article=None, date_sent=(datetime(2005, 8, 1)))
+
+# By default ReaderLetter.objects.all() orders by the name
+# of the reader that wrote it ascending.
+>>> ReaderLetter.objects.all()
+[<ReaderLetter: Reader A>, <ReaderLetter: Reader B, Article 4>, <ReaderLetter: Reader C, Article 4>, <ReaderLetter: Reader D, Article 1>, <ReaderLetter: Reader D, Article 2>]
+
+# Composite ordering using the related article headline descending as one of the components
+>>> ReaderLetter.objects.order_by('reader_name', '-article__headline')
+[<ReaderLetter: Reader B, Article 4>, <ReaderLetter: Reader C, Article 4>, <ReaderLetter: Reader D, Article 2>, <ReaderLetter: Reader D, Article 1>]
+
+>>> er1 = EditorResponse.objects.create(editor_name='Editor A', reader_letter=rl1)
+>>> er2 = EditorResponse.objects.create(editor_name='Editor B', reader_letter=rl2)
+>>> er3 = EditorResponse.objects.create(editor_name='Editor B', reader_letter=rl3)
+
+>>> EditorResponse.objects.all()
+[<EditorResponse: Editor A, Reader D, Article 1>, <EditorResponse: Editor B, Reader D, Article 2>, <EditorResponse: Editor B, Reader C, Article 4>]
+
+# Order just by the relationship field, this should order by the natural
+# ordering of the ReaderLetter model (i.e. as dictated by its Meta.ordering),
+# but right now is ordering by the ReaderLetter PK.
+>>> EditorResponse.objects.order_by('reader_letter')
+[<EditorResponse: Editor A, Reader D, Article 1>, <EditorResponse: Editor B, Reader D, Article 2>, <EditorResponse: Editor B, Reader C, Article 4>]
+
+# Order by another field of the related ReaderLetter object.
+>>> EditorResponse.objects.order_by('reader_letter__reader_name')
+[<EditorResponse: Editor B, Reader C, Article 4>, <EditorResponse: Editor A, Reader D, Article 1>, <EditorResponse: Editor B, Reader D, Article 2>]
+
+# The ordering specification can span models through relationships too.
+# Order by the PK of the article related to the reader letter related
+# to the editor response, descending.
+>>> EditorResponse.objects.order_by('-reader_letter__article')
+[<EditorResponse: Editor B, Reader C, Article 4>, <EditorResponse: Editor B, Reader D, Article 2>, <EditorResponse: Editor A, Reader D, Article 1>]
+
+# Order by the article publication date, ascending.
+>>> EditorResponse.objects.order_by('reader_letter__article__pub_date')
+[<EditorResponse: Editor A, Reader D, Article 1>, <EditorResponse: Editor B, Reader D, Article 2>, <EditorResponse: Editor B, Reader C, Article 4>]
+
+# Composite ordering with one of the components being a specification that
+# spans a FK relationship
+>>> EditorResponse.objects.order_by('-editor_name', 'reader_letter__article')
+[<EditorResponse: Editor B, Reader D, Article 2>, <EditorResponse: Editor B, Reader C, Article 4>, <EditorResponse: Editor A, Reader D, Article 1>]
+
+# Test many-to-many relationships
+>>> r1 = Reporter.objects.create(name='John')
+>>> r2 = Reporter.objects.create(name='Jane')
+>>> r3 = Reporter.objects.create(name='Paul')
+
+>>> r1.articles = [a1, a2]
+>>> r2.articles = [a4, a3]
+>>> r3.articles = [a4, a2]
+
+# The natural ordering of the Reporter model as dictated by its
+# `Meta.ordering` option is by 'article__headline' (i.e. by a field of a
+# related model)
+>>> Reporter.objects.all().distinct()
+[<Reporter: John; articles: Article 2, Article 1>, <Reporter: Paul; articles: Article 4, Article 2>, <Reporter: Jane; articles: Article 4, Article 3>]
+
+# Order by a a related model of a many-to-many relationship. Remember the
+# Article model natural ordering as dictated by its `Meta.ordering`
+# option is ('-pub_date', 'headline')
+>>> Reporter.objects.distinct().order_by('articles')
+[<Reporter: John; articles: Article 2, Article 1>, <Reporter: Paul; articles: Article 4, Article 2>, <Reporter: Jane; articles: Article 4, Article 3>]
+
+# Order the reporters by the headlines of the articles they contributed
+# to, descending
+>>> Reporter.objects.distinct().order_by('-articles__headline')
+[<Reporter: Jane; articles: Article 4, Article 3>, <Reporter: Paul; articles: Article 4, Article 2>, <Reporter: John; articles: Article 2, Article 1>]
+
+# Note how the ordering can also span backward relationships. Here we order
+# the reporters by the date the letter in response to the articles she/he
+# contributed to was sent (if any)
+>>> Reporter.objects.distinct().order_by('articles__readerletter__date_sent')
+[<Reporter: Jane; articles: Article 4, Article 3>, <Reporter: Paul; articles: Article 4, Article 2>, <Reporter: John; articles: Article 2, Article 1>]
+
-"""}