一 QuerySet对象

1.1可切片

使用Python 的切片语法来限制查询集记录的数目 。它等同于SQL 的LIMIT 和OFFSET子句。

  1. Entry.objects.all()[:5]      # (LIMIT 5)
  2. Entry.objects.all()[5:10]    # (OFFSET 5 LIMIT 5)

不支持负的索引（例如Entry.objects.all()[-1]）。通常，查询集的切片返回一个新的查询集—— 它不会执行查询。

1.2可迭代

  1. articleList=models.Article.objects.all()
  3. for article in articleList:
  4.     print(article.title)

1.3惰性查询

查询集是惰性执行的 —— 创建查询集不会带来任何数据库的访问。你可以将过滤器保持一整天，直到查询集需要求值时，Django 才会真正运行这个查询。

  1. queryResult=models.Article.objects.all() # not hits database
  3. print(queryResult)  # hits database
  5. for article in queryResult:
  6.     print(article.title)  # hits database

一般来说，只有在“请求”查询集 的结果时才会到数据库中去获取它们。当你确实需要结果时，查询集 通过访问数据库来求值

1.4缓存机制

每个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工作的将让你编写最高效的代码。

在一个新创建的查询集中，缓存为空。首次对查询集进行求值 —— 同时发生数据库查询 ——Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，如果正在迭代查询集，则返回下一个结果）。接下来对该查询集 的求值将重用缓存的结果。

请牢记这个缓存行为，因为对查查询集不当的话，它会坑你的。例如，下面的语句创建两个查查询集它们求值，然后扔掉它们：

  1. print([a.title for a in models.Article.objects.all()])
  2. print([a.create_time for a in models.Article.objects.all()])

这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，因为在两次请求期间有可能有Article被添加进来或删除掉。为了避免这个问题，只需保存查查询集新使用它：

  1. queryResult=models.Article.objects.all()
  2. print([a.title for a in queryResult])
  3. print([a.create_time for a in queryResult])

何时查询集不会被缓存?

查询集不会永远缓存它们的结果。当只对查询集的部分进行求值时会检查缓存， 如果这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。所以，这意味着使用切片或索引来限制查询集将不会填充缓存。

例如，重复获取查询集对象中一个特定的索引将每次都查询数据库：

  1. queryset = Entry.objects.all()
  2. print queryset[5] # Queries the database
  3. print queryset[5] # Queries the database again

然而，如果已经对全部查询集求值过，则将检查缓存：

  1. queryset = Entry.objects.all()
  2. [entry for entry in queryset] # Queries the database
  3. print queryset[5] # Uses cache
  4. print queryset[5] # Uses cache

下面是一些其它例子，它们会使得全部的查询集被求值并填充到缓存中：

  1. [entry for entry in queryset]
  2. bool(queryset)
  3. entry in queryset
  4. list(queryset)

注：简单地打印查询集不会填充缓存。

  1. queryResult=models.Article.objects.all()
  2. print(queryResult) #  hits database
  3. print(queryResult) #  hits database

1.5exists()与iterator()方法

exists

简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些 数据！为了避免这个，可以用exists()方法来检查是否有数据：

  1. if queryResult.exists():
  2.     # SELECT (1) AS "a" FROM "blog_article" LIMIT 1; args=()
  3.         print("exists")

iterator:

当queryset非常巨大时，cache会成为问题。

处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法 来获取数据，处理完数据就将其丢弃。

  1. objs = Book.objects.all().iterator()
  2. # iterator()可以一次只从数据库获取少量数据，这样可以节省内存
  3. for obj in objs:
  4.     print(obj.title)
  5. # BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
  6. for obj in objs:
  7.     print(obj.title)

当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询。

总结:

queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能 会造成额外的数据库查询。

二 中介模型

处理类似搭配 pizza 和 topping 这样简单的多对多关系时，使用标准的ManyToManyField 就可以了。但是，有时你可能需要关联数据到两个模型之间的关系上。

例如，有这样一个应用，它记录音乐家所属的音乐小组。我们可以用一个ManyToManyField 表示小组和成员之间的多对多关系。但是，有时你可能想知道更多成员关系的细节，比如成员是何时加入小组的。

对于这些情况，Django 允许你指定一个中介模型来定义多对多关系。 你可以将其他字段放在中介模型里面。源模型的ManyToManyField 字段将使用through 参数指向中介模型。对于上面的音乐小组的例子，代码如下：

  1. from django.db import models
  3. class Person(models.Model):
  4.     name = models.CharField(max_length=128)
  6.     def __str__(self):              # __unicode__ on Python 2
  7.         return self.name
  9. class Group(models.Model):
  10.     name = models.CharField(max_length=128)
  11.     members = models.ManyToManyField(Person, through='Membership')
  13.     def __str__(self):              # __unicode__ on Python 2
  14.         return self.name
  16. class Membership(models.Model):
  17.     person = models.ForeignKey(Person)
  18.     group = models.ForeignKey(Group)
  19.     date_joined = models.DateField()
  20.     invite_reason = models.CharField(max_length=64)

既然你已经设置好ManyToManyField 来使用中介模型（在这个例子中就是Membership），接下来你要开始创建多对多关系。你要做的就是创建中介模型的实例：

  1. >>> ringo = Person.objects.create(name="Ringo Starr")
  2. >>> paul = Person.objects.create(name="Paul McCartney")
  3. >>> beatles = Group.objects.create(name="The Beatles")
  4. >>> m1 = Membership(person=ringo, group=beatles,
  5.      date_joined=date(1962, 8, 16),
  6.      invite_reason="Needed a new drummer.")
  7. >>> m1.save()
  8. >>> beatles.members.all()
  10. [<Person: Ringo Starr>]
  11. >>> ringo.group_set.all()
  12. [<Group: The Beatles>]
  13. >>> m2 = Membership.objects.create(person=paul, group=beatles,
  14.      date_joined=date(1960, 8, 1),
  15.      invite_reason="Wanted to form a band.")
  16. >>> beatles.members.all()
  17. [<Person: Ringo Starr>, <Person: Paul McCartney>]

与普通的多对多字段不同，你不能使用add、 create和赋值语句（比如，beatles.members = []）来创建关系：

  1. # THIS WILL NOT WORK
  2. >>> beatles.members.add(john)
  3. # NEITHER WILL THIS
  4. >>> beatles.members.create(name="George Harrison")
  5. # AND NEITHER WILL THIS
  6. >>> beatles.members = [john, paul, ringo, george]

为什么不能这样做？ 这是因为你不能只创建 Person和 Group之间的关联关系，你还要指定 Membership模型中所需要的所有信息；而简单的add、create 和赋值语句是做不到这一点的。所以它们不能在使用中介模型的多对多关系中使用。此时，唯一的办法就是创建中介模型的实例。

remove()方法被禁用也是出于同样的原因。但是clear() 方法却是可用的。它可以清空某个实例所有的多对多关系：

  1. >>> # Beatles have broken up
  2. >>> beatles.members.clear()
  3. >>> # Note that this deletes the intermediate model instances
  4. >>> Membership.objects.all()
  5. []

三 查询优化

3.1表数据

  1. class UserInfo(AbstractUser):
  2.     """
  3.     用户信息
  4.     """
  5.     nid = models.BigAutoField(primary_key=True)
  6.     nickname = models.CharField(verbose_name='昵称', max_length=32)
  7.     telephone = models.CharField(max_length=11,
  8.                                 blank=True, null=True,
  9.                                 unique=True, verbose_name='手机号码')
  11.     avatar = models.FileField(verbose_name='头像',
  12.                                 upload_to = 'avatar/',
  13.                                 default="/avatar/default.png")
  14.     create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
  16.     fans = models.ManyToManyField(verbose_name='粉丝们',
  17.                                   to='UserInfo',
  18.                                   through='UserFans',
  19.                                   related_name='f',
  20.                                   through_fields=('user', 'follower'))
  22.     def __str__(self):
  23.         return self.username
  25. class UserFans(models.Model):
  26.     """
  27.     互粉关系表
  28.     """
  29.     nid = models.AutoField(primary_key=True)
  30.     user = models.ForeignKey(verbose_name='博主',
  31.                              to='UserInfo', to_field='nid',
  32.                              related_name='users')
  34.     follower = models.ForeignKey(verbose_name='粉丝',
  35.                                  to='UserInfo', to_field='nid',
  36.                                  related_name='followers')
  38. class Blog(models.Model):
  40.     """
  41.     博客信息
  42.     """
  43.     nid = models.BigAutoField(primary_key=True)
  44.     title = models.CharField(verbose_name='个人博客标题', max_length=64)
  45.     site = models.CharField(verbose_name='个人博客后缀',
  46.     					  max_length=32, unique=True)
  48.     theme = models.CharField(verbose_name='博客主题', max_length=32)
  49.     user = models.OneToOneField(to='UserInfo', to_field='nid')
  51.     def __str__(self):
  52.         return self.title
  54. class Category(models.Model):
  55.     """
  56.     博主个人文章分类表
  57.     """
  58.     nid = models.AutoField(primary_key=True)
  59.     title = models.CharField(verbose_name='分类标题', max_length=32)
  61.     blog = models.ForeignKey(verbose_name='所属博客',
  62.     					    to='Blog', to_field='nid')
  64. class Article(models.Model):
  65.     nid = models.BigAutoField(primary_key=True)
  66.     title = models.CharField(max_length=50, verbose_name='文章标题')
  67.     desc = models.CharField(max_length=255, verbose_name='文章描述')
  68.     read_count = models.IntegerField(default=0)
  69.     comment_count= models.IntegerField(default=0)
  70.     up_count = models.IntegerField(default=0)
  71.     down_count = models.IntegerField(default=0)
  73.     category = models.ForeignKey(verbose_name='文章类型',
  74.                                  to='Category', to_field='nid',
  75.                                  null=True)
  77.     create_time = models.DateField(verbose_name='创建时间')
  78.     blog = models.ForeignKey(verbose_name='所属博客',
  79.     						to='Blog', to_field='nid')
  81.     tags = models.ManyToManyField(
  82.         to="Tag",
  83.         through='Article2Tag',
  84.         through_fields=('article', 'tag'),
  85. )
  87. class ArticleDetail(models.Model):
  88.     """
  89.     文章详细表
  90.     """
  91.     nid = models.AutoField(primary_key=True)
  92.     content = models.TextField(verbose_name='文章内容', )
  94.     article = models.OneToOneField(verbose_name='所属文章',
  95.     							 to='Article', to_field='nid')
  97. class Comment(models.Model):
  98.     """
  99.     评论表
  100.     """
  101.     nid = models.BigAutoField(primary_key=True)
  102.     article = models.ForeignKey(verbose_name='评论文章',
  103.     						  to='Article', to_field='nid')
  104.     content = models.CharField(verbose_name='评论内容',
  105.     						 max_length=255)
  106.     create_time = models.DateTimeField(verbose_name='创建时间',
  107.     								auto_now_add=True)
  109.     parent_comment = models.ForeignKey('self', blank=True, null=True,
  110.     								verbose_name='父级评论')
  112.     user = models.ForeignKey(verbose_name='评论者',
  113.                               to='UserInfo',
  114.                               to_field='nid')
  116.     up_count = models.IntegerField(default=0)
  118.     def __str__(self):
  119.         return self.content
  121. class ArticleUpDown(models.Model):
  122.     """
  123.     点赞表
  124.     """
  125.     nid = models.AutoField(primary_key=True)
  126.     user = models.ForeignKey('UserInfo', null=True)
  127.     article = models.ForeignKey("Article", null=True)
  128.     models.BooleanField(verbose_name='是否赞')
  130. class CommentUp(models.Model):
  131.     """
  132.     点赞表
  133.     """
  134.     nid = models.AutoField(primary_key=True)
  135.     user = models.ForeignKey('UserInfo', null=True)
  136.     comment = models.ForeignKey("Comment", null=True)
  138. class Tag(models.Model):
  139.     nid = models.AutoField(primary_key=True)
  140.     title = models.CharField(verbose_name='标签名称', max_length=32)
  141.     blog = models.ForeignKey(verbose_name='所属博客',
  142.     						to='Blog', to_field='nid')
  144. class Article2Tag(models.Model):
  145.     nid = models.AutoField(primary_key=True)
  146.     article = models.ForeignKey(verbose_name='文章',
  147.     						  to="Article", to_field='nid')
  148.     tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')

3.2 select_related

3.2.1简单使用

对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化 。select_related 返回一个QuerySet，当执行它的查询时它沿着外键关系查询关联的对象的数据。它会生成一个复杂的查询并引起性能的损耗，但是在以后使用外键关系时将不需要数据库查询。简单说，在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。

下面的例子解释了普通查询和select_related() 查询的区别。

查询id=2的文章的分类名称,下面是一个标准的查询：

  1. # Hits the database.
  2. article=models.Article.objects.get(nid=2)
  4. # Hits the database again to get the related Blog object.
  5. print(article.category.title)
  1. '''
  3. SELECT
  4.     "blog_article"."nid",
  5.     "blog_article"."title",
  6.     "blog_article"."desc",
  7.     "blog_article"."read_count",
  8.     "blog_article"."comment_count",
  9.     "blog_article"."up_count",
  10.     "blog_article"."down_count",
  11.     "blog_article"."category_id",
  12.     "blog_article"."create_time",
  13.      "blog_article"."blog_id",
  14.      "blog_article"."article_type_id"
  15.              FROM "blog_article"
  16.              WHERE "blog_article"."nid" = 2; args=(2,)
  18. SELECT
  19.      "blog_category"."nid",
  20.      "blog_category"."title",
  21.      "blog_category"."blog_id"
  22.               FROM "blog_category"
  23.               WHERE "blog_category"."nid" = 4; args=(4,)
  25. '''

如果我们使用select_related()函数：

  1. articleList=models.Article.objects.select_related("category").all()
  3.     for article_obj in articleList:
  4.         #  Doesn't hit the database, because article_obj.category
  5.         #  has been prepopulated in the previous query.
  6.         # 不再查询数据库，因为第一次查询，数据已经填充进去了
  7.         print(article_obj.category.title)
  1. SELECT
  2.      "blog_article"."nid",
  3.      "blog_article"."title",
  4.      "blog_article"."desc",
  5.      "blog_article"."read_count",
  6.      "blog_article"."comment_count",
  7.      "blog_article"."up_count",
  8.      "blog_article"."down_count",
  9.      "blog_article"."category_id",
  10.      "blog_article"."create_time",
  11.      "blog_article"."blog_id",
  12.      "blog_article"."article_type_id",
  14.      "blog_category"."nid",
  15.      "blog_category"."title",
  16.      "blog_category"."blog_id"
  18. FROM "blog_article"
  19. LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid");

3.2.2 多外键查询

这是针对category的外键查询，如果是另外一个外键呢？让我们一起看下：

  1. article=models.Article.objects.select_related("category").get(nid=1)
  3. print(article.articledetail)

观察logging结果，发现依然需要查询两次，所以需要改为：

  1. article=models.Article.objects.select_related("category",
  2. 											"articledetail"
  3. 											).get(nid=1)
  5. print(article.articledetail)

或者：1.7以后支持链式操作

  1. article=models.Article.objects
  2. 　　　　　　　　　　　　　.select_related("category")
  3. 　　　　　　　　　　　　　.select_related("articledetail")
  4. 　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持链式操作
  5. 　　　　　　　　　　　　　
  6. print(article.articledetail)
  1. SELECT
  3.     "blog_article"."nid",
  4.     "blog_article"."title",
  6.     "blog_category"."nid",
  7.     "blog_category"."title",
  8.     "blog_category"."blog_id",
  10.     "blog_articledetail"."nid",
  11.     "blog_articledetail"."content",
  12.     "blog_articledetail"."article_id"
  14.    FROM "blog_article"
  15.    LEFT OUTER JOIN "blog_category" ON ("blog_article"."category_id" = "blog_category"."nid")
  16.    LEFT OUTER JOIN "blog_articledetail" ON ("blog_article"."nid" = "blog_articledetail"."article_id")
  17.    WHERE "blog_article"."nid" = 1; args=(1,)

3.2.3 深层查询

  1. # 查询id=1的文章的用户姓名
  2. article=models.Article.objects.select_related("blog").get(nid=1)
  4. print(article.blog.user.username)

依然需要查询两次：

  1. SELECT
  2.     "blog_article"."nid",
  3.     "blog_article"."title",
  5.      "blog_blog"."nid",
  6.      "blog_blog"."title",
  8.    FROM "blog_article" INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid")
  9.    WHERE "blog_article"."nid" = 1;
  11. SELECT
  12.     "blog_userinfo"."password",
  13.     "blog_userinfo"."last_login",
  15. FROM "blog_userinfo"
  16. WHERE "blog_userinfo"."nid" = 1;

这是因为第一次查询没有query到userInfo表，所以，修改如下：

  1. article=models.Article.objects.select_related("blog__user").get(nid=1)
  3. print(article.blog.user.username)
  1. SELECT
  3. "blog_article"."nid", "blog_article"."title",
  5. "blog_blog"."nid", "blog_blog"."title",
  7. "blog_userinfo"."password", "blog_userinfo"."last_login",
  9. FROM "blog_article"
  11. INNER JOIN "blog_blog" ON ("blog_article"."blog_id" = "blog_blog"."nid")
  13. INNER JOIN "blog_userinfo" ON ("blog_blog"."user_id" = "blog_userinfo"."nid")
  14. WHERE "blog_article"."nid" = 1;

3.2.4 总结

1.select_related主要针一对一和多对一关系进行优化。

2.select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。

3.可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。

4.没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。

5.也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。

6.也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。

7.Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。

3.3 prefetch_related()

对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。

prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。

prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。

  1. # 查询所有文章关联的所有标签
  2.     article_obj=models.Article.objects.all()
  3.     for i in article_obj:
  5.         print(i.tags.all())  # 4篇文章: hits database 5

改为prefetch_related：

  1. # 查询所有文章关联的所有标签
  2.     article_obj=models.Article.objects.prefetch_related("tags").all()
  3.     for i in article_obj:
  5.         print(i.tags.all())  # 4篇文章: hits database 2
  1. SELECT "blog_article"."nid",
  2.                "blog_article"."title",
  4. FROM "blog_article";
  6. SELECT
  7.   ("blog_article2tag"."article_id") AS "_prefetch_related_val_article_id",
  8.   "blog_tag"."nid",
  9.   "blog_tag"."title",
  10.   "blog_tag"."blog_id"
  11.    FROM "blog_tag"
  12.   INNER JOIN "blog_article2tag" ON ("blog_tag"."nid" = "blog_article2tag"."tag_id")
  13.   WHERE "blog_article2tag"."article_id" IN (1, 2, 3, 4);
  1. def select_related(self, *fields)
  2.      性能相关：表之间进行join连表操作，一次性获取关联的数据。
  3.      model.tb.objects.all().select_related()
  4.      model.tb.objects.all().select_related('外键字段')
  5.      model.tb.objects.all().select_related('外键字段__外键字段')
  7. def prefetch_related(self, *lookups)
  8.     """
  9.     性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询
  10.     在Python代码中实现连表操作。
  11.     """
  12. 	# 获取所有用户表
  13. 	# 获取用户类型表where id in (用户表中的查到的所有用户ID)
  14. 	models.UserInfo.objects.prefetch_related('外键字段')
  16. 	from django.db.models import Count, Case, When, IntegerField
  17.     Article.objects.annotate(
  18.     	numviews=Count(
  19.     	Case(
  20.     	When(readership__what_time__lt=treshold, then=1),
  21. 		output_field=CharField(),
  22. 		)))
  24. students =Student.objects.all().annotate(
  25. 					num_excused_absences=models.Sum(
  26.                 	models.Case(
  27.                     models.When(absence__type='Excused', then=1),
  28.                 	default=0,
  29. 					output_field=models.IntegerField()
  30.             )))
  1. # 加select_related 主动做链表，相当于直接链表把数据全取出来了，
  2. # 不加：for循环几次，就再次查几次数据库
  3. # select_related('author_detail')参数是fk的字段，
  4. # 可能有多个外键，所以可以写多个
  6. ret=models.Author.objects.all().select_related('author_detail')
  8. for i in ret:
  9. 	print(i.author_detail.addr)
  10. ret = models.Author.objects.all()
  12. for i in ret:
  13. 	print(i.author_detail.addr)
  15. # 用了fk,但是不做链表，做多次查询,把结果集都放到对象中
  16. # 两次查询，相当于select * from author_detail where nid in [1,2]
  17. ret=models.Author.objects.all().prefetch_related('author_detail')
  18. for i in ret:
  19. 	print(i.author_detail.addr)
  20. # 总结：数据量少，可以用select_related
  21. # 数据量比较多用prefetch_related

四 extra

  1. extra(select=None, where=None, params=None,
  2.       tables=None, order_by=None, select_params=None)

有些情况下，Django的查询语法难以简单的表达复杂的 WHERE 子句，对于这种情况, Django 提供了 extra() QuerySet修改机制 — 它能在 QuerySet生成的SQL从句中注入新子句

extra可以指定一个或多个 参数,例如 select, where or tables. 这些参数都不是必须的，但是你至少要使用一个!要注意这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),除非万不得已,尽量避免这样做

4.1参数之select

The select 参数可以让你在 SELECT 从句中添加其他字段信息，它应该是一个字典，存放着属性名到 SQL 从句的映射。

  1. queryResult=models.Article.objects.extra(
  2.                     select={
  3.                     'is_recent': "create_time > '2017-09-05'"
  4.                     })

结果集中每个 Entry 对象都有一个额外的属性is_recent, 它是一个布尔值，表示 Article对象的create_time是否晚于2017-09-05.

练习：

  1. # in sqlite:
  2. article_obj=models.Article.objects
  3. 　　　　　　　　　.filter(nid=1)
  4. 　　　　　　　　　.extra(select={
  5. 　　　　　　　　　"standard_time":"strftime(
  6. 　　　　　　　　　'%%Y-%%m-%%d',create_time
  7. 　　　　　　　　　)"
  8. 　　　　　　　　　})
  9. 　　　　　　　　　.values(
  10. 　　　　　　　　　"standard_time","nid","title"
  11. 　　　　　　　　　)
  13. print(article_obj)
  15. """
  16. <QuerySet [
  17.         {'title': 'MongoDb 入门教程',
  18.         'standard_time': '2017-09-03',
  19.         'nid': 1}
  20. ]>
  22. """

4.2参数之where/ tables

您可以使用where定义显式SQL WHERE子句 - 也许执行非显式连接。您可以使用tables手动将表添加到SQL FROM子句。

where和tables都接受字符串列表。所有where参数均为“与”任何其他搜索条件。

举例来讲：

  1. queryResult=models.Article
  2. 　　　　　　　　　　　.objects.extra(
  3. 　　　　　　　　　　　where=['nid in (1,3)
  4. 　　　　　　　　　　　OR title like "py%" ',
  5. 　　　　　　　　　　　'nid>2'
  6. 　　　　　　　　　　　])
  1. extra, 额外查询条件以及相关表，排序
  2. 	models.UserInfo.objects.filter(id__gt=1)
  3. 	models.UserInfo.objects.all()
  4. 	# id name age ut_id
  6. models.UserInfo.objects.extra(
  7.                         self, select=None,
  8.                         where=None, params=None,
  9.                         tables=None, order_by=None,
  10.                         select_params=None)
  12. # a. 映射
  13. # select
  14. # select_params=None
  15. # select 此处 from 表
  17. # b. 条件
  18. # where=None
  19. # params=None,
  20. # select * from 表 where 此处
  22. # c. 表
  23. # tables
  24. # select * from 表,此处
  26. # c. 排序
  27. # order_by=None
  28. # select * from 表 order by 此处
  30. models.UserInfo.objects.extra(
  31.                     select={
  32.                     'newid':'select count(1)
  33.                     from app01_usertype
  34.                     where id>%s'},
  35.                     select_params=[1,],
  36.                     where = ['age>%s'],
  37.                     params=[18,],
  38.                     order_by=['-age'],
  39.                     tables=['app01_usertype']
  40.                 )
  42.     """
  43.     select
  44.     app01_userinfo.id,
  45.     (select count(1) from app01_usertype where id>1) as newid
  46.     from app01_userinfo,app01_usertype
  47.     where
  48.     app01_userinfo.age > 18
  49.     order by
  50.     app01_userinfo.age desc
  51.     """
  53. 	result = models.UserInfo.objects.filter(id__gt=1).extra(
  54. 		where=['app01_userinfo.id < %s'],
  55. 		params=[100,],
  56.          tables=['app01_usertype'],
  57.          order_by=['-app01_userinfo.id'],
  58.          select={'uid':1,'sw':"select count(1) from app01_userinfo"}
  59.      )
  60.      print(result.query)
  62. """
  63. SELECT (1) AS "uid", (select count(1) from app01_userinfo) AS "sw", "app01_userinfo"."id", "app01_userinfo"."name", "app01_userinfo"."age", "app01_userinfo"."ut_id" FROM "app01_userinfo" , "app01_usertype" WHERE ("app01_userinfo"."id" > 1 AND (app01_userinfo.id < 100)) ORDER BY ("app01_userinfo".id) DESC
  64. """
  1. # 在对象中加入字段
  2. ret=models.Author.objects.all().filter(nid__gt=1).extra(
  3. 							select={'n':'select count(*)
  4. 							from app01_book where nid>%s'},
  5. 							select_params=[1])
  7. print(ret[0].n)
  8. print(ret.query)
  10. # 给字段重命名
  11. ret=models.Author.objects.all().filter(
  12. 				author_detail__telephone=132234556).extra(
  13. 				select={'bb':"app01_authordatail.telephone"}
  14. 				).values('bb')
  16. print(ret)
  17. print(ret.query)

五 原生sql

  1. from django.db import connection, connections
  3. cursor = connection.cursor() # connection=default数据
  4. cursor = connections['db2'].cursor()
  6. cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  8. row = cursor.fetchone()
  9. row = cursor.fetchall()
  1. ret=models.Author.objects.raw(
  2. 	'select * from app01_author where nid>1'
  3. )
  4. print(ret)
  6. for i in ret:
  7. 	print(i)
  8.     print(ret.query)
  9.     # 会把book的字段放到author对象中
  10.     ret=models.Author.objects.raw(
  11.     'select * from app01_book where nid>1'
  12.     )
  14.     print(ret)
  15.     for i in ret:
  16.         print(i.price)
  17.         print(type(i))

六 整体插入

创建对象时，尽可能使用bulk_create()来减少SQL查询的数量。例如：

  1. Entry.objects.bulk_create([
  2.     Entry(headline="Python 3.0 Released"),
  3.     Entry(headline="Python 3.1 Planned")
  4. ])

更优于：

  1. Entry.objects.create(headline="Python 3.0 Released")
  2. Entry.objects.create(headline="Python 3.1 Planned")

注意该方法有很多注意事项，所以确保它适用于你的情况。

这也可以用在ManyToManyFields中，所以：

  1. my_band.members.add(me, my_friend)

更优于：

  1. my_band.members.add(me)
  2. my_band.members.add(my_friend)

其中Bands和Artists具有多对多关联。

七 事务操作

  1. # 事务操作
  2. from django.db import transaction
  3. with transaction.atomic():
  4. 	pass

八 defer和only

defer('id','name'):取出对象，字段除了id和name都有

only('id','name'):取的对象，只有id和name

如果点，依然能点出其它列，但是不要点了，因为取没有的列，会再次查询数据库

  1. ret=models.Author.objects.only('nid')
  2. for i in ret:
  3. 	# 查询不在的字段，会再次查询数据库，造成数据库压力大
  4. 	print(i.name)

Django-model更上层楼的更多相关文章

  1. 【转】Django Model field reference学习总结

    Django Model field reference学习总结(一) 本文档包含所有字段选项(field options)的内部细节和Django已经提供的field types. Field 选项 ...

  2. Django model字段类型清单

    转载:<Django model字段类型清单> Django 通过 models 实现数据库的创建.修改.删除等操作,本文为模型中一般常用的类型的清单,便于查询和使用: AutoField ...

  3. Django:Model的Filter

    转自:http://www.douban.com/note/301166150/   django model filter 条件过滤,及多表连接查询.反向查询,某字段的distinct   1.多表 ...

  4. Django model中 双向关联问题，求帮助

    Django model中 双向关联问题,求帮助 - 开源中国社区 Django model中 双向关联问题,求帮助

  5. django 自定用户系统 以及 Django Model 定义语法

    http://www.tuicool.com/articles/jMzIr2 django使用自己的用户系统 http://www.jianshu.com/p/c10be59aad7a Django ...

  6. tornado with MySQL, torndb, django model, SQLAlchemy ==> JSON dumped

    现在,我们用torndo做web开发框架,用他内部机制来处理HTTP请求.传说中的非阻塞式服务. 整来整去,可谓之一波三折.可是,无论怎么样,算是被我做成功了. 在tornado服务上,采用三种数据库 ...

  7. Django Model field reference

    ===================== Model field reference ===================== .. module:: django.db.models.field ...

  8. Django model对象接口

    Django model查询 # 直接获取表对应字段的值,列表嵌元组形式返回 Entry.objects.values_list('id', 'headline') #<QuerySet [(1 ...

  9. Django学习之四：Django Model模块

    目录 Django Model 模型 MODEL需要在脑子里记住的基础概念 区分清楚,必须不能混淆的 class Meta 内嵌元数据定义类 简单model创建实例 数据源配置 接着通过models在 ...

  10. Django Model Form

    ModelForm ModelForm结合了Form和Model,将models的field类型映射成forms的field类型,复用了Model和Model验证, 写更少的代码,并且还实现了存储数据 ...

随机推荐

  1. learning java FileReader

    import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import ...

  2. WinDbg常用命令系列---!teb

    !teb 简介 !teb扩展显示线程环境块(teb)中信息的格式化视图. 使用形式 !teb [TEB-Address] 参数 TEB-Address 要检查其TEB的线程的十六进制地址.(这不是从线 ...

  3. 开源项目 06 NPOI

    using NPOI.HSSF.UserModel; using NPOI.SS.UserModel; using NPOI.XSSF.UserModel; using System; using S ...

  4. Codevs 2800 送外卖(状压DP)

    2800 送外卖 时间限制: 2 s 空间限制: 256000 KB 题目等级 : 钻石 Diamond 题目描述 Description 有一个送外卖的,他手上有n份订单,他要把n份东西,分别送达n ...

  5. QBXT 2017GoKing problems 补完计划

    10.11 Updata : 烦死了...麻烦死了...不补了..就这些吧 20171001 上: 100 + 90 + 90 = 280 = rank 8 T1 /* T1 从最大的数开始倒着枚举 ...

  6. ImageView.ScaleType

    前言 对ImageView.ScaleType,学习安卓需掌握.以官方链接:http://android.xsoftlab.net/reference/android/widget/ImageView ...

  7. coci2011 debt 还债

    coci2011 debt 还债 Description 有N个人,每个人恰好欠另一个人Bi元钱,现在大家都没有钱,政府想要给其中一些人欠,使得大家都不欠别人钱. 如A欠B 50,B欠C 20,则当政 ...

  8. ICEM-缺口圆柱

    原视频下载地址:https://pan.baidu.com/s/1bpahxd9 密码: bpp7

  9. 解决PHP7无法监听9000端口问题/502错误解决办法

    问题背景 昨晚帮配置nginx+php服务的时候,发生了一个奇怪的事情netstat -anp|grep 9000查看9000端口,一直没有监听,于是nginx无法通过fastcgi来代理php请求. ...

  10. Selenium对浏览器支持的版本【2019/10/25更新】

    最新的selenium与几种常用浏览器的版本兼容情况:(以下驱动,点击直接跳转官方下载地址) 尽量选择最新版本-1的浏览器,比如最新的是60,那就使用59.(建议Chrome更新至72+版本.Fire ...