Django 模型高级部分及聚集查询

from django.db import models

# Some kind of document, like a blog post or a wiki page

class Document(models.Model):
name = models.CharField(max_length=255)

# A user-generated comment, such as found on a site like
# Digg or Reddit

class Comment(models.Model):
document = models.ForeignKey(Document, related_name='comments')
content = models.TextField()

from examples.model import *
import uuid

# First create a lot of documents and assign them random names

for i in range(0, 10000):
Document.objects.create(name=str(uuid.uuid4()))

# Get a selection of names back to be looked up later

names = Document.objects.values_list('name', flat=True)[0:5000]

# The really slow way to get back a list of Documents that
# match these names

documents = []

for name in names:
documents.append(Document.objects.get(name=name))

SELECT * FROM model WHERE fieldname IN ('1', '2', ...)

from examples import models
import uuid

for i in range(0, 10000):
Document.objects.create(name=str(uuid.uuid4()))

names = Document.objects.values_list('name', flat=True)[0:5000]

documents = list(Document.objects.filter(name__in=names))

for name in names:
documents.append(get_document_by_name(name))

def get_document_by_name(name):
return Document.objects.get(name=name))

from django.db import models

class Document(models.Model):
name = models.CharField(max_length=255)
format = models.ForeignKey('Format')

class Comment(models.Model):
document = models.ForeignKey(Document, related_name='comments')
content = models.TextField()

class Format(models.Model):
type = models.CharField(choices=( ('Text file', 'text'),
('ePub ebook', 'epub'),
('HTML file', 'html')),
max_length=10)

# First create a series of Format objects and save
them to the database

format_text = Format.objects.create(type='text')
format_epub = Format.objects.create(type='epub')
format_html = Format.objects.create(type='html')

# Create a few documents in various formats
for i in range(0, 10):
Document.objects.create(name='My text document',
format=format_text)
Document.objects.create(name='My epub document',
format=format_epub)
Document.objects.create(name='My HTML document',
format=format_html)

Documents.objects.filter(format=format_text,publish_on__week_day=todays_week_day,
is_public=True).distinct().order_by(date_added).reverse()

Documents.home_page.all()

from django.db import models

class DocumentManager(models.Manager):

# The model class for this manager is always available as
# self.model, but in this example we are only relying on the
# filter() method inherited from models.Manager.

def text_format(self):
return self.filter(format__type='text')

def epub_format(self):
return self.filter(format__type='epub')

def html_format(self):
return self.filter(format__type='html')

class Document(models.Model):
name = models.CharField(max_length=255)
format = models.ForeignKey('Format')

# The new model manager
get_by_format = DocumentManager()

# The default model manager now needs to be explicitly defined
objects = models.Manager()

class Comment(models.Model):
document = models.ForeignKey(Document, related_name='comments')
content = models.TextField()

class Format(models.Model):
type = models.CharField(choices=( ('Text file', 'text'),
('ePub ebook', 'epub'),
('HTML file', 'html')),
max_length=10)
def __unicode__(self):
return self.type

In [1]: [d.format for d in Document.get_by_format.text_format()][0]
Out[1]: <Format: text>

In [2]: [d.format for d in Document.get_by_format.epub_format()][0]
Out[2]: <Format: epub>

In [3]: [d.format for d in Document.get_by_format.html_format()][0]
Out[3]: <Format: html>

class HTMLManager(models.Manager):
def get_query_set(self):
return super(HTMLManager, self).get_query_set().filter(format__type='html')

class Document(models.Model):
name = models.CharField(max_length=255)
format = models.ForeignKey('Format')
html = HTMLManager()
get_by_format = DocumentManager()
objects = models.Manager()

# Our HTML query returns the same number of results as the manager
# which explicitly filters the result set.

In [1]: Document.html.all().count()
Out[1]: 10

In [2]: Document.get_by_format.html_format().count()
Out[2]: 10

# In fact we can prove that they return exactly the same results

In [3]: [d.id for d in Document.get_by_format.html_format()] ==
[d.id for d in Document.html.all()]
Out[3]: True

# It is not longer possible to operate on the unfiltered
# query in HTMLManager()

In [4]: Document.html.filter(format__type='epub')
Out[4]: []

# Return the canonical name for a format extension based on some
# common values that might be seen "in the wild"

def check_extension(extension):
if extension == 'text' or extension == 'txt' or extension == '.csv':
return 'text'
if extension.lower() == 'epub' or extension == 'zip':
return 'epub'
if 'htm' in extension:
return 'html'
raise Exception('Did not get known extension')

class Format(models.Model):
type = models.CharField(choices=( ('Text file', 'text'),
('ePub ebook', 'epub'),
('HTML file', 'html')),
max_length=10)
@staticmethod
def check_extension(extension):
if extension == 'text' or extension == 'txt' or extension == '.csv':
return 'text'
if extension.lower() == 'epub' or extension == 'zip':
return 'epub'
if 'htm' in extension:
return 'html'
raise Exception('Did not get known extension')

def __unicode__(self):
return self.type

from django.db.models import Count

# Create some sample Documents
unpopular = Document.objects.create(name='Unpopular document', format=format_html)
popular = Document.objects.create(name='Popular document', format=format_html)

# Assign more comments to "popular" than to "unpopular"
for i in range(0,10):
Comment.objects.create(document=popular)

for i in range(0,5):
Comment.objects.create(document=unpopular)

# If we return results in the order they were created (id order, by default), we get
# the "unpopular" document first.
In [1]: Document.objects.all()
Out[1]: [<Document: Unpopular document>, <Document: Popular document>]

# If we instead annotate the result set with the total number of
# comments on each Document and then order by that computed value, we
# get the "popular" document first.

In [2]: Document.objects.annotate(Count('comments')).order_by('-comments__count')
Out[2]: [<Document: Popular document>, <Document: Unpopular document>]

Document.objects.annotate(popularity=Count('comments'))

In [1]: from django.db.models import Avg
In [2]: Document.objects.aggregate(Avg('comments'))
Out[2]: {'comments__avg': 8.0}