Django中的数据库查询

web应用需要经常向数据库查询相关的数据，Django语言http://www.maiziedu.com/course/307/也不例外。了解Django中的数据查询操作，对于优化应用的性能，有着重要的意义。

基础信息

Django中，model通过Manager获取QuerySet，每个model至少有objects这个 Manager 。

QuerySet 可以有一个或多个 filter , filter 根据传入的参数返回 QuerySet 结果。

用SQL来对比， QuerySet 相当于 SELECT ， filter 相当于 WHERE 或者是 LIMIT

每次添加一条filter，会获得一个新的 QuerySet 。


思路

利用Django的测试框架，构造测试数据，查看Django构建的SQL，以及查询到的内容。

设计表结构


schema

创建model

创建测试app，并加入settings.py APPS中

python manage.py startapp learning

INSTALLED_APPS = [
     ...
    'learning',
    ...
]
创建对应的model

class Student(models.Model):
    name = models.CharField(max_length=255, help_text="学生姓名")
    create_time = models.DateTimeField(auto_now_add=True, help_text="创建时间")
    def __str__(self):
        return self.name


class Teacher(models.Model):
    name = models.CharField(max_length=255, help_text="老师姓名")
    create_time = models.DateTimeField(auto_now_add=True, help_text="创建时间")
    def __str__(self):
        return self.name


class Classe(models.Model):
    name = models.CharField(max_length=255, help_text="班级名称")
    teacher = models.ForeignKey(Teacher, help_text="老师")
    create_time = models.DateTimeField(auto_now_add=True, help_text="创建时间")
    def __str__(self):
        return self.name


class ClasseStudent(models.Model):
    student = models.ForeignKey(Student)
    classe = models.ForeignKey(Classe)
    create_time = models.DateTimeField(auto_now_add=True, help_text="创建时间")
测试数据

使用factory-boy来辅助构造测试数据，代码如下

class TeacherFactory(factory.DjangoModelFactory):
    class Meta:
        model = Teacher

    name = factory.Sequence(lambda n: "Teacher #%s" % n)

class StudentFactory(factory.DjangoModelFactory):
    class Meta:
        model = Student

    name = factory.Sequence(lambda n: "Student #%s" % n)

class ClasseFactory(factory.DjangoModelFactory):
    class Meta:
        model = Classe

    name = factory.Sequence(lambda n: "Class #%s" % n)

class ClasseStudentFactory(factory.DjangoModelFactory):
    class Meta:
        model = ClasseStudent

    student = factory.SubFactory(StudentFactory)
    classe = factory.SubFactory(ClasseFactory)
现在来伪造测试数据

在tests.py添加测试用例

class ModelTestCase(TestCase):
    def setUp(self):
        self.teacher_one = TeacherFactory()
        self.class_one = ClasseFactory(teacher=self.teacher_one)
        self.class_two = ClasseFactory(teacher=self.teacher_one)
        for i in range(40):
            ClasseStudentFactory(student=StudentFactory(), classe=self.class_one)
        for i in range(40):
            ClasseStudentFactory(student=StudentFactory(), classe=self.class_two)
可以看到，添加了一个老师，两个班，每个班加入了40个学生

filter和exclude

添加testcase

def test_filter_chain(self):
    query_set = Student.objects.filter(name__startswith='Student').exclude(pk=1).filter(create_time__year__gte=2015)[3:10]
    print query_set.query
    print query_set
执行

python manage.py test python manage.py test learning.test.test.ModelTestCase.test_filter_chain
可以看到结果

SELECT `learning_student`.`id`, `learning_student`.`name`, `learning_student`.`create_time` FROM `learning_student` WHERE (`learning_student`.`name` LIKE BINARY Student% AND NOT (`learning_student`.`id` = 1) AND `learning_student`.`create_time` >= 2014-12-31 16:00:00) LIMIT 7 OFFSET 3
<QuerySet [<Student: Student #4>, <Student: Student #5>, <Student: Student #6>, <Student: Student #7>, <Student: Student #8>, <Student: Student #9>, <Student: Student #10>]>
和我们预期的一致，值得注意的是，Django执行的是lazy query，也就是说前面的filter和exclude并没有去查询数据库，后面的分片才导致了那次的查询

order_by

def test_order_by(self):
        query_set = Classe.objects.order_by("-create_time")
        print query_set.query
        print query_set
SELECT `learning_classe`.`id`, `learning_classe`.`name`, `learning_classe`.`teacher_id`, `learning_classe`.`create_time` FROM `learning_classe` ORDER BY `learning_classe`.`create_time` DESC
<QuerySet [<Classe: Class #3>, <Classe: Class #2>]>
如果有多个column参与排序，可以使用 Coalesce

select_related

可以用select_related查询外键的信息，并将结果保存，这样查找外键信息时，将不会向数据库发送请求，如下所示

def test_select_related(self):
        query_set = Classe.objects.select_related("teacher")
        print query_set.query
        print query_set[0].teacher
SELECT `learning_classe`.`id`, `learning_classe`.`name`, `learning_classe`.`teacher_id`, `learning_classe`.`create_time`, `learning_teacher`.`id`, `learning_teacher`.`name`, `learning_teacher`.`create_time` FROM `learning_classe` INNER JOIN `learning_teacher` ON (`learning_classe`.`teacher_id` = `learning_teacher`.`id`)
<QuerySet [<Classe: Class #0>, <Classe: Class #1>]>
defer和only

有时候查询只需要部分字段的结果，可以用defer和only来限制查询的结果

def test_defer(self):
        print Classe.objects.defer("create_time").query
        print Classe.objects.only("create_time").query
SELECT `learning_classe`.`id`, `learning_classe`.`name`, `learning_classe`.`teacher_id` FROM `learning_classe`
SELECT `learning_classe`.`id`, `learning_classe`.`create_time` FROM `learning_classe`
如果访问到没有获取的字段时，会再从数据库中读一次

文章来源：简书