创建模型

实例:我们来假定下面这些概念,字段和关系

作者模型:一个作者有姓名和年龄。

作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息。作者详情模型和作者模型之间是一对一的关系(one-to-one)

出版商模型:出版商有名称,所在城市以及email。

书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many)。

  1. Book
  2. id title price publish
  3. 1 php 100 人民出版社
  4. 2 python 200 老男孩出版社
  5. 3 go 100 人民出版社
  6. 4 java 300 人民出版社
  7.  
  8. 为了存储出版社的邮箱,地址,在第一个表后面加字段
  9. Book
  10. id title price publish email addr
  11. 1 php 100 人民出版社 111 北京
  12. 2 python 200 老男孩出版社 222 上海
  13. 3 go 100 人民出版社 111 北京
  14. 4 java 300 人民出版社 111 北京
  15.  
  16. 这样会有大量重复的数据,浪费空间
  17. ####################################################################################
  18.  
  19. 一对多:一个出版社对应多本书(关联信息建在多的一方,也就是book表中)
  20. Book
  21. id title price publish_id
  22. 1 php 100 1
  23. 2 python 200 1
  24. 3 go 100 2
  25. 4 java 300 1
  26. Publish
  27. id name email addr
  28. 1 人民出版社 111 北京
  29. 2 沙河出版社 222 沙河
  30. 总结:一旦确定表关系是一对多:在多对应的表中创建关联字段(在多的表里创建关联字段) publish_id
  31. 查询python这本书的出版社的邮箱(子查询)
  32.  
  33. select publish_id from Book where title=“python
  34. select email from Publish where id=1
  35. ####################################################################################
  36. 多对多:一本书有多个作者,一个作者出多本书
  37. Book
  38. id title price publish_id
  39. 1 php 100 1
  40. 2 python 200 1
  41. 3 go 100 2
  42. 4 java 300 1
  43. Author
  44. id name age addr
  45.  
  46. 1 alex 34 beijing
  47. 2 egon 55 nanjing
  48. Book2Author
  49.  
  50. id book_id author_id
  51. 1 2 1
  52. 2 2 2
  53.  
  54. 3 3 2
  55. 总结:一旦确定表关系是多对多:创建第三张关系表(创建中间表,中间表就三个字段,自己的id,书籍id和作者id
  56. id book_id author_id
  57. # alex出版过的书籍名称(子查询)
  58. select id from Author where name='alex'
  59. select book_id from Book2Author where author_id=1
  60. select title from Book where id =book_id
  61. ####################################################################################
  62. 一对一:对作者详细信息的扩展(作者表和作者详情表)
  63. Author
  64. id name age ad_id(UNIQUE)
  65. 1 alex 34 1
  66. 2 egon 55 2
  67. AuthorDetail
  68.  
  69. id addr gender tel gf_name author_id(UNIQUE)
  70. 1 beijing male 110 小花 1
  71. 2 nanjing male 911 杠娘 2
  72.  
  73. 总结: 一旦确定是一对一的关系:在两张表中的任意一张表中建立关联字段+Unique

注意:关联字段与外键约束没有必然的联系(建管理字段是为了进行查询,建约束是为了不出现脏数据)

在Models创建如下模型

  1. class Book(models.Model):
  2. nid = models.AutoField(primary_key=True)
  3. name = models.CharField(max_length=32)
  4. price = models.DecimalField(max_digits=5, decimal_places=2)
  5. publish_date = models.DateField()
  6. # 阅读数
  7. # reat_num=models.IntegerField(default=0)
  8. # 评论数
  9. # commit_num=models.IntegerField(default=0)
  10.  
  11. publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
  12. authors=models.ManyToManyField(to='Author')
  13. def __str__(self):
  14. return self.name
  15.  
  16. class Author(models.Model):
  17. nid = models.AutoField(primary_key=True)
  18. name = models.CharField(max_length=32)
  19. age = models.IntegerField()
  20. author_detail = models.OneToOneField(to='AuthorDatail',to_field='nid',unique=True,on_delete=models.CASCADE)
  21.  
  22. class AuthorDatail(models.Model):
  23. nid = models.AutoField(primary_key=True)
  24. telephone = models.BigIntegerField()
  25. birthday = models.DateField()
  26. addr = models.CharField(max_length=64)
  27.  
  28. class Publish(models.Model):
  29. nid = models.AutoField(primary_key=True)
  30. name = models.CharField(max_length=32)
  31. city = models.CharField(max_length=32)
  32. email = models.EmailField()

生成的表如下:

注意事项:

  • 表的名称myapp_modelName,是根据 模型中的元数据自动生成的,也可以覆写为别的名称  
  •  id 字段是自动添加的
  • 对于外键字段,Django 会在字段名上添加"_id" 来创建数据库中的列名
  • 这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式,要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句
  • 定义好模型之后,你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置,在其中添加models.py所在应用的名称
  • 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL),你可以赋给它空值 None

新增或者删除字段

新增字段

第一步,在你要添加新字段的app的 models.py 文件中添加需要新增的字段

第二步,在终端命令行中python manage.py makemigrations AppTest(个人App文件名)

第三步,选择输入:1(这里要求你设置新建字段的默认值,它会在新建这个字段的同时把默认值也添加上去,)

第四步,如果不想让它有值,我们直接输''(中间没有空格),一样能达到效果,但是不能不设置默认值,(如果是数值类型呢,默认值为 ''不行,如果是年龄,需设置blank=True和null=True)

  1. blank:设置为True时,字段可以为空。设置为False时,字段是必须填写的。字符型字段CharFieldTextField是用空字符串来存储空值的。如果为True,字段允许为空,默认不允许.
  2.  
  3. null:设置为True时,djangoNull来存储空值。日期型、时间型和数字型字段不接受空字符串。所以设置IntegerFieldDateTimeField型字段可以为空时,需要将blanknull均设为True。如果为True,空值将会被存储为NULL,默认为False。如果想设置BooleanField为空时可以选NullBooleanField型字段。)

第五步,最后输入:python manage.py migrate

删除字段

只需要将想要删除的字段注释掉,再执行一遍两条命令

添加表记录

一对多的

  1. 方式1:
  2. publish_obj=Publish.objects.get(nid=1)
  3. book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish=publish_obj)
  4.  
  5. 方式2:
  6. book_obj=Book.objects.create(title="",publishDate="2012-12-12",price=100,publish_id=1)

核心:book_obj.publish与book_obj.publish_id是什么?

  1. 关键点:
  2.  
  3. book_obj.publish=Publish.objects.filter(id=book_obj.publish_id).first()
  4.  
  5. book_obj.authors.all()
  6. 关键点:book.authors.all() # 与这本书关联的作者集合
  7.  
  8. 1 book.id=3
  9. 2 book_authors
  10. id book_id author_ID
  11. 3 3 1
  12. 4 3 2
  13.  
  14. 3 author
  15. id name
  16. 1 alex
  17. 2 egon
  18.  
  19. book_obj.authors.all() -------> [alex,egon]

  

  1. # -----一对多添加
  2. pub=Publish.objects.create(name='egon出版社',email='445676@qq.com',city='山东')
  3. print(pub)
  4.  
  5. # 为book表绑定和publish的关系
  6. import datetime,time
  7. now=datetime.datetime.now().__str__()
  8. now = datetime.datetime.now().strftime('%Y-%m-%d')
  9. print(type(now))
  10. print(now)
  11. # 日期类型必须是日期对象或者字符串形式的2018-09-12(2018-9-12),其它形式不行
  12. Book.objects.create(name='海燕3',price=333.123,publish_date=now,publish_id=2)
  13. Book.objects.create(name='海3燕3',price=35.123,publish_date='2018/02/28',publish=pub)
  14. pub=Publish.objects.filter(nid=1).first()
  15. book=Book.objects.create(name='测试书籍',price=33,publish_date='2018-7-28',publish=pub)
  16. print(book.publish.name)
  17. # 查询出版了红楼梦这本书出版社的邮箱
  18. book=Book.objects.filter(name='红楼梦').first()
  19. print(book.publish.email)

多对多

  1. # 当前生成的书籍对象
  2. book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)
  3. # 为书籍绑定的做作者对象
  4. yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录
  5. egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录
  6.  
  7. # 绑定多对多关系,即向关系表book_authors中添加纪录
  8. book_obj.authors.add(yuan,egon) # 将某些特定的 model 对象添加到被关联对象集合中。 ======= book_obj.authors.add(*[])

  

  1. book = Book.objects.filter(name='红楼梦').first()
  2. egon=Author.objects.filter(name='egon').first()
  3. lqz=Author.objects.filter(name='lqz').first()
  4. # 1 没有返回值,直接传对象
  5. book.authors.add(lqz,egon)
  6. # 2 直接传作者id
  7. book.authors.add(1,3)
  8. # 3 直接传列表,会打散
  9. book.authors.add(*[1,2])
  10. # 解除多对多关系
  11. book = Book.objects.filter(name='红楼梦').first()
  12. # 1 传作者id
  13. book.authors.remove(1)
  14. # 2 传作者对象
  15. egon = Author.objects.filter(name='egon').first()
  16. book.authors.remove(egon)
  17. #3 传*列表
  18. book.authors.remove(*[1,2])
  19. #4 删除所有
  20. book.authors.clear()
  21. # 5 拿到与 这本书关联的所有作者,结果是queryset对象,作者列表
  22. ret=book.authors.all()
  23. # print(ret)
  24. # 6 queryset对象,又可以继续点(查询红楼梦这本书所有作者的名字)
  25. ret=book.authors.all().values('name')
  26. print(ret)
  27. # 以上总结:
  28. # (1)
  29. # book=Book.objects.filter(name='红楼梦').first()
  30. # print(book)
  31. # 在点publish的时候,其实就是拿着publish_id又去app01_publish这个表里查数据了
  32. # print(book.publish)
  33. # (2)book.authors.all()

多对多注意点

1.注意ManyToManyField()的设置位置;该实例中设置了Article模型中,在绑定两张表的时候,利用Article的对象a1进行绑定的,a1.publication.add()。但是不能使用Publication的对象p1进行绑定(p1.article.add())。

2.两张表之间的相互查询关系

查询a1这篇文章所属的出版社有哪些

print a1.publication.all()

查询某一出版社,所包含的所有文章有哪些

print p1.article_set.all()

多对多关系其它常用API:

  1. book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])
  2. book_obj.authors.clear() #清空被关联对象集合
  3. book_obj.authors.set() #先清空再设置 

基于对象的跨表查询

一对多查询(publish与book)

正向查询(按字段:publish)

  1. # 查询主键为1的书籍的出版社所在的城市
  2. book_obj=Book.objects.filter(pk=1).first()
  3. # book_obj.publish 是主键为1的书籍对象关联的出版社对象
  4. print(book_obj.publish.city)

反向查询(按表名:book_set)

  1. publish=Publish.objects.get(name="苹果出版社")
  2. #publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合
  3. book_list=publish.book_set.all()
  4. for book_obj in book_list:
  5. print(book_obj.title)
  1. # 一对多正向查询
  2. book=Book.objects.filter(name='红楼梦').first()
  3. print(book.publish)#与这本书关联的出版社对象
  4. print(book.publish.name)
  5. # 一对多反向查询
  6. # 人民出版社出版过的书籍名称
  7. pub=Publish.objects.filter(name='人民出版社').first()
  8. ret=pub.book_set.all()
  9. print(ret)

一对一查询(Author 与 AuthorDetail)

正向查询(按字段:authorDetail):

  1. egon=Author.objects.filter(name="egon").first()
  2. print(egon.authorDetail.telephone)

反向查询(按表名:author):

  1. # 查询所有住址在北京的作者的姓名
  2.  
  3. authorDetail_list=AuthorDetail.objects.filter(addr="beijing")
  4. for obj in authorDetail_list:
  5. print(obj.author.name)
  1. # 一对一正向查询
  2. # lqz的手机号
  3. lqz=Author.objects.filter(name='lqz').first()
  4. tel=lqz.author_detail.telephone
  5. print(tel)
  6. # 一对一反向查询
  7. # 地址在北京的作者姓名
  8. author_detail=AuthorDatail.objects.filter(addr='北京').first()
  9. name=author_detail.author.name
  10. print(name)

多对多查询 (Author 与 Book)

正向查询(按字段:authors):

  1. # 眉所有作者的名字以及手机号
  2.  
  3. book_obj=Book.objects.filter(title="眉").first()
  4. authors=book_obj.authors.all()
  5. for author_obj in authors:
  6. print(author_obj.name,author_obj.authorDetail.telephone)

反向查询(按表名:book_set):

  1. # 查询egon出过的所有书籍的名字
  2.  
  3. author_obj=Author.objects.get(name="egon")
  4. book_list=author_obj.book_set.all() #与egon作者相关的所有书籍
  5. for book_obj in book_list:
  6. print(book_obj.title)
  1. # 正向查询----查询红楼梦所有作者名称
  2. book=Book.objects.filter(name='红楼梦').first()
  3. ret=book.authors.all()
  4. print(ret)
  5. for auth in ret:
  6. print(auth.name)
  7. # 反向查询 查询lqz这个作者写的所有书
  8. author=Author.objects.filter(name='lqz').first()
  9. ret=author.book_set.all()
  10. print(ret)

注意:

你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如,如果 Article model 中做一下更改:

  1. publish = ForeignKey(Book, related_name='bookList') 

那么接下来就会如我们看到这般:

  1. # 查询 人民出版社出版过的所有书籍
  2.  
  3. publish=Publish.objects.get(name="人民出版社")
  4. book_list=publish.bookList.all() # 与人民出版社关联的所有书籍对象集合

基于双下划线的跨表查询

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系,它能自动确认 SQL JOIN 联系。要做跨关系查询,就使用两个下划线来链接模型(model)间关联字段的名称,直到最终链接到你想要的model 为止。

  1. '''
  2. 正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
  3. '''

一对多查询

  1. # 练习: 查询苹果出版社出版过的所有书籍的名字与价格(一对多)
  2.  
  3. # 正向查询 按字段:publish
  4.  
  5. queryResult=Book.objects
  6.             .filter(publish__name="苹果出版社")
  7.             .values_list("title","price")
  8.  
  9. # 反向查询 按表名:book
  10.  
  11. queryResult=Publish.objects
  12.               .filter(name="苹果出版社")
  13.               .values_list("book__title","book__price")
  14. 查询的本质一样,就是select from的表不一样

  

  1. # 正向查询按字段,反向查询按表名小写
  2. # 查询红楼梦这本书出版社的名字
  3. # select * from app01_book inner join app01_publish
  4. # on app01_book.publish_id=app01_publish.nid
  5. ret=Book.objects.filter(name='红楼梦').values('publish__name')
  6. print(ret)
  7. ret=Publish.objects.filter(book__name='红楼梦').values('name')
  8. print(ret)

多对多查询 

  1. # 练习: 查询alex出过的所有书籍的名字(多对多)
  2.  
  3. # 正向查询 按字段:authors:
  4. queryResult=Book.objects
  5.             .filter(authors__name="yuan")
  6.             .values_list("title")
  7.  
  8. # 反向查询 按表名:book
  9. queryResult=Author.objects
  10.               .filter(name="yuan")
  11.               .values_list("book__title","book__price")
  1. # 正向查询按字段,反向查询按表名小写
  2. # 查询红楼梦这本书出版社的名字
  3. # select * from app01_book inner join app01_publish
  4. # on app01_book.publish_id=app01_publish.nid
  5. ret=Book.objects.filter(name='红楼梦').values('publish__name')
  6. print(ret)
  7. ret=Publish.objects.filter(book__name='红楼梦').values('name')
  8. print(ret)
  9. # sql 语句就是from的表不一样
  10. # -------多对多正向查询
  11. # 查询红楼梦所有的作者
  12. ret=Book.objects.filter(name='红楼梦').values('authors__name')
  13. print(ret)
  14. # ---多对多反向查询
  15. ret=Author.objects.filter(book__name='红楼梦').values('name')
  16. ret=Author.objects.filter(book__name='红楼梦').values('name','author_detail__addr')
  17. print(ret)

一对一查询

  1. # 查询alex的手机号
  2.  
  3. # 正向查询
  4. ret=Author.objects.filter(name="alex").values("authordetail__telephone")
  5.  
  6. # 反向查询
  7. ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")
  1. # 查询lqz的手机号
  2. # 正向查
  3. ret=Author.objects.filter(name='lqz').values('author_detail__telephone')
  4. print(ret)
  5. # 反向查
  6. ret= AuthorDatail.objects.filter(author__name='lqz').values('telephone')
  7. print(ret)

进阶练习(连续跨表)

  1. # 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名
  2. # 正向查询
  3. queryResult=Book.objects
  4.             .filter(publish__name="人民出版社")
  5.             .values_list("title","authors__name")
  6. # 反向查询
  7. queryResult=Publish.objects
  8.               .filter(name="人民出版社")
  9.               .values_list("book__title","book__authors__age","book__authors__name")
  10. # 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称
  11. # 方式1:
  12. queryResult=Book.objects
  13.             .filter(authors__authorDetail__telephone__regex="151")
  14.             .values_list("title","publish__name")
  15. # 方式2:
  16. ret=Author.objects
  17. .filter(authordetail__telephone__startswith="151")
  18. .values("book__title","book__publish__name")
  1. # ----进阶练习,连续跨表
  2. # 查询手机号以33开头的作者出版过的书籍名称以及书籍出版社名称
  3. # author_datail author book publish
  4. # 基于authorDatail表
  5. ret=AuthorDatail.objects.filter(telephone__startswith='33').values('author__book__name','author__book__publish__name')
  6. print(ret)
  7. # 基于Author表
  8. ret=Author.objects.filter(author_detail__telephone__startswith=33).values('book__name','book__publish__name')
  9. print(ret)
  10. # 基于Book表
  11. ret=Book.objects.filter(authors__author_detail__telephone__startswith='33').values('name','publish__name')
  12. print(ret)
  13. # 基于Publish表
  14. ret=Publish.objects.filter(book__authors__author_detail__telephone__startswith='33').values('book__name','name')
  15. print(ret)

related_name

  1. publish = ForeignKey(Blog, related_name='bookList')
  1. # 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)
  2.  
  3. # 反向查询 不再按表名:book,而是related_name:bookList
  4.  
  5. queryResult=Publish.objects
  6.               .filter(name="人民出版社")
  7.               .values_list("bookList__title","bookList__price")

反向查询时,如果定义了related_name ,则用related_name替换表名,例如:

聚合查询与分组查询

value在annotate前面时,相当于group by,即models.表名.objects.values('group by 字段').annotate(统计字段)

value放在annotate后面时,相当于select

annotate前面没有value时,默认按当前表的主键分组

这里需要注意的是,values中的字段信息需要使用单引号进行包裹 

如果只有一个符合条件的值,就是一个列表里面有一个字典.如果多个符合条件的值则是多个字典放在列表中

聚合

aggregate(*args, **kwargs)

  1. # 计算所有图书的平均价格
  2. from django.db.models import Avg
  3. Book.objects.all().aggregate(Avg('price'))
  4. #{'price__avg': 34.35}

aggregate()QuerySet 的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称,可以向聚合子句提供它。

  1. Book.objects.aggregate(average_price=Avg('price'))
  2. #{'average_price': 34.35}

如果你希望生成不止一个聚合,你可以向aggregate()子句中添加另一个参数。所以,如果你也想知道所有图书价格的最大值和最小值,可以这样查询:

  1. from django.db.models import Avg, Max, Min
  2. Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
  3. #{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
  1. # 查询所有书籍的平均价格
  2. from django.db.models import Avg,Count,Max,Min
  3. ret=Book.objects.all().aggregate(Avg('price'))
  4. # {'price__avg': 202.896}
  5. # 可以改名字
  6. ret=Book.objects.all().aggregate(avg_price=Avg('price'))
  7. # 统计平均价格和最大价格
  8. ret=Book.objects.all().aggregate(avg_price=Avg('price'),max_price=Max('price'))
  9. # 统计最小价格
  10. ret = Book.objects.all().aggregate(avg_price=Avg('price'), min_price=Min('price'))
  11. # 统计个数和平均价格
  12. ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('price'))
  13. ret = Book.objects.all().aggregate(avg_price=Avg('price'), max_price=Max('price'),count=Count('nid'))
  14. print(ret)

分组

annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)。

总结 :跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询。 

查询练习

练习:统计每一本书作者个数

  1. from django.db.models import Avg, Max, Sum, Min, Max, Count
  2. book_list = models.Book.objects.all().annotate(author_num=Count("authors"))
  3. for book in book_list:
  4. print(book.name)
  5. print(book.author_num)
  6. book_list = models.Book.objects.all().annotate(author_num=Count("authors")).values('name','author_num')
  7. print(book_list)

练习:统计每一个出版社的最便宜的书

  1. publishList=Publish.objects.annotate(MinPrice=Min("book__price"))
  2. for publish_obj in publishList:
  3. print(publish_obj.name,publish_obj.MinPrice)

annotate的返回值是querySet,如果不想遍历对象,可以用上valuelist:

  1. queryResult= Publish.objects.annotate(MinPrice=Min("book__price")).values_list("name","MinPrice")
  2. print(queryResult)

练习:统计每一本以py开头的书籍的作者个数:

  1. queryResult=Book.objects.filter(title__startswith="Py").annotate(num_authors=Count('authors'))

练习:统计不止一个作者的图书:(作者数量大于一)

  1. ret=models.Book.objects.annotate(author_num=Count("authors")).filter(author_num__gt=1).values('name','author_num')print(ret)

练习:根据一本图书作者数量的多少对查询集 QuerySet进行排序:

  1. Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')

练习:查询各个作者出的书的总价格:

  1. ret=models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
  2. print(ret)

练习:查询每个出版社的名称和书籍个数

  1. ret=models.Publish.objects.all().annotate(c=Count('book__name')).values('name','c')
  2. print(ret)
  1. # ————————————单表下的分组查询
  2. '''
  3. 查询每一个部门名称以及对应的员工数
  4. emp:
  5. id name age salary dep
  6. 1 alex 12 2000 销售部
  7. 2 egon 22 3000 人事部
  8. 3 wen 22 5000 人事部
  9. '''
  10. # select count(id) from emp group by dep
  11. # 示例一:查询每一个部门的名称,以及平均薪水
  12. # select dep,Avg(salary) from app01_emp group by dep
  13. from django.db.models import Avg, Count, Max, Min
  14. ret=Emp.objects.values('dep').annotate(Avg('salary'))
  15. # 重新命名
  16. ret=Emp.objects.values('dep').annotate(avg_salary=Avg('salary'))
  17. print(ret)
  18. # ---*******单表分组查询ORM总结:表名.objects.values('group by 的字段').annotate(聚合函数('统计的字段'))
  19. # 示例2 查询每个省份对应的员工数
  20. ret=Emp.objects.values('province').annotate(Count('id'))
  21. ret=Emp.objects.values('province').annotate(c=Count('id'))
  22. print(ret)
  23. # 补充知识点:
  24. ret=Emp.objects.all()
  25. # select * from emp
  26. ret=Emp.objects.values('name')
  27. # select name from emp
  28. # ****单表下,按照id进行分组是没有任何意义的
  29. ret=Emp.objects.all().annotate(Avg('salary'))
  30. print(ret)
  31. # ******多表分组查询
  32. # 查询每一个出版社出版的书籍个数
  33. ret=Book.objects.values('publish_id').annotate(Count('nid'))
  34. print(ret)
  35. # 查询每个出版社的名称以及出版社书的个数(先join在跨表分组)
  36. # 正向
  37. ret=Publish.objects.values('name').annotate(Count('book__name'))
  38. ret=Publish.objects.values('nid').annotate(c=Count('book__name')).values('name','c')
  39. print(ret)
  40. # 反向
  41. ret=Book.objects.values('publish__name').annotate(Count('name'))
  42. ret=Book.objects.values('publish__name').annotate(c=Count('name')).values('publish__name','c')
  43. print(ret)
  44. # 查询每个作者的名字,以及出版过书籍的最高价格
  45. ret=Author.objects.values('pk').annotate(c=Max('book__price')).values('name','c')
  46. print(ret)
  47. # 跨表查询的模型:每一个后表模型.objects.value('pk').annotate(聚合函数('关联表__统计字段')).values()
  48.  
  49. # 查询每一个书籍的名称,以及对应的作者个数
  50. ret=Book.objects.values('pk').annotate(c=Count('authors__name')).values('name','c')
  51. print(ret)
  52. # 统计不止一个作者的图书
  53. ret=Book.objects.values('pk').annotate(c=Count('authors__name')).filter(c__gt=1).values('name','c')
  54. print(ret) 

F查询与Q查询

F查询

在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?

Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段,来比较同一个 model 实例中两个不同字段的值。

  1. # 查询评论数大于收藏数的书籍
  2. from django.db.models import F
  3. Book.objects.filter(commnetNum__lt=F('keepNum'))

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。

  1. # 查询评论数大于收藏数2倍的书籍
  2. Book.objects.filter(commnetNum__lt=F('keepNum')*2)

修改操作也可以使用F函数,比如将每一本书的价格提高30元:

  1. Book.objects.all().update(price=F("price")+30) 

Q查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR 语句),你可以使用Q 对象

  1. from django.db.models import Q
  2. Q(title__startswith='Py')

Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。

  1. bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

等同于下面的SQL WHERE 子句:

  1. WHERE name ="yuan" OR name ="egon"

你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时,Q 对象可以使用~ 操作符取反,这允许组合正常的查询和取反(NOT) 查询:

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。例如:

  1. bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")
  1. # 查询评论数大于阅读数的书籍
  2. from django.db.models import F,Q
  3. # select * from book where commit_num>read_num;
  4. # 这样肯定是不行的
  5. # Book.objects.filter(commit_num__gt=read_num)
  6. ret=Book.objects.filter(commit_num__gt=F('reat_num'))
  7. print(ret)
  8. # 把所有书籍的价格加10
  9. Book.objects.all().update(price=F('price')+10)
  10. # ----Q函数,描述一个与,或,非的关系
  11. # 查询名字叫红楼梦或者价格大于100的书
  12. ret=Book.objects.filter(Q(name='红楼梦')|Q(price__gt=100))
  13. print(ret)
  14. # 查询名字叫红楼梦和价格大于100的书
  15. ret = Book.objects.filter(Q(name='红楼梦') & Q(price__gt=100))
  16. print(ret)
  17. # # 等同于
  18. ret2=Book.objects.filter(name='红楼梦',price__gt=100)
  19. print(ret2)
  20. # 也可以Q套Q
  21. # 查询名字叫红楼梦和价格大于100 或者 nid大于2
  22. ret=Book.objects.filter((Q(name='红楼梦') & Q(price__gt=100))|Q(nid__gt=2))
  23. print(ret)
  24. # ----非
  25. ret=Book.objects.filter(~Q(name='红楼梦'))
  26. print(ret)
  27. # Q和键值对联合使用,但是键值对必须放在Q的后面(描述的是一个且的关系)
  28. # 查询名字不是红楼梦,并且价格大于100的书
  29. ret=Book.objects.filter(~Q(name='红楼梦'),price__gt=100)
  30. print(ret)

Django框架(八) Django之ORM数据库操作的更多相关文章

  1. 第三百零六节,Django框架,models.py模块,数据库操作——创建表、数据类型、索引、admin后台,补充Django目录说明以及全局配置文件配置

    Django框架,models.py模块,数据库操作——创建表.数据类型.索引.admin后台,补充Django目录说明以及全局配置文件配置 数据库配置 django默认支持sqlite,mysql, ...

  2. 四 Django框架,models.py模块,数据库操作——创建表、数据类型、索引、admin后台,补充Django目录说明以及全局配置文件配置

    Django框架,models.py模块,数据库操作——创建表.数据类型.索引.admin后台,补充Django目录说明以及全局配置文件配置 数据库配置 django默认支持sqlite,mysql, ...

  3. 第三百零九节,Django框架,models.py模块,数据库操作——F和Q()运算符:|或者、&并且——queryset对象序列化

    第三百零九节,Django框架,models.py模块,数据库操作——F()和Q()运算符:|或者.&并且 F()可以将数据库里的数字类型的数据,转换为可以数字类型 首先要导入 from dj ...

  4. 第三百零八节,Django框架,models.py模块,数据库操作——链表结构,一对多、一对一、多对多

    第三百零八节,Django框架,models.py模块,数据库操作——链表结构,一对多.一对一.多对多 链表操作 链表,就是一张表的外键字段,连接另外一张表的主键字段 一对多 models.Forei ...

  5. 第三百零七节,Django框架,models.py模块,数据库操作——表类容的增删改查

    Django框架,models.py模块,数据库操作——表类容的增删改查 增加数据 create()方法,增加数据 save()方法,写入数据 第一种方式 表类名称(字段=值) 需要save()方法, ...

  6. 五 Django框架,models.py模块,数据库操作——表类容的增删改查

    Django框架,models.py模块,数据库操作——表类容的增删改查 增加数据 create()方法,增加数据 save()方法,写入数据 第一种方式 表类名称(字段=值) 需要save()方法, ...

  7. 七 Django框架,models.py模块,数据库操作——F和Q()运算符:|或者、&并且——queryset对象序列化

    F()可以将数据库里的数字类型的数据,转换为可以数字类型 首先要导入 from django.db.models import F from django.shortcuts import rende ...

  8. 六 Django框架,models.py模块,数据库操作——链表结构,一对多、一对一、多对多

    链表操作 链表,就是一张表的外键字段,连接另外一张表的主键字段 一对多 models.ForeignKey()外键字段一对多,值是要外键的表类 from __future__ import unico ...

  9. django(六)之ORM数据库操作

    https://www.cnblogs.com/haiyan123/p/7732190.html 一.ORM介绍 ORM——object relation mapping 映射关系: 表名 ----- ...

随机推荐

  1. IE浏览器解决无法识别js中getElementsByClassName问题

    关于ie浏览器无法识别js中getElementsByClassName问题,现通过以下方法,引用如下js /** *打印js对象详细信息 */ function alertObj(obj) { va ...

  2. Yii Restful api自定义字段

  3. Applegate 方法使用

    1. - (void)application:(UIApplication *)application didRegisterUserNotificationSettings:(UIUserNotif ...

  4. Spark学习之路 (八)SparkCore的调优之开发调优

    摘抄自:https://tech.meituan.com/spark-tuning-basic.html 前言 在大数据计算领域,Spark已经成为了越来越流行.越来越受欢迎的计算平台之一.Spark ...

  5. python sqlite3 数据库操作

    python sqlite3 数据库操作 SQLite3是python的内置模块,是一款非常小巧的嵌入式开源数据库软件. 1. 导入Python SQLite数据库模块 import sqlite3 ...

  6. [转载]String.Empty、string=”” 和null的区别

    String.Empty是string类的一个静态常量: String.Empty和string=””区别不大,因为String.Empty的内部实现是: 1 2 3 4 5 6 7 8 9 10 1 ...

  7. 浏览器从输入URL到页面加载显示完成全过程解析

    一 浏览器查找域名对应的 IP 地址(域名解析的过程,先进行缓存的查看): 1.在浏览器中输入www.qq.com域名,操作系统会先检查自己本地的hosts文件是否有这个网址映射关系,如果有,就先调用 ...

  8. OGG 12.3中支持系统procedure复制的几点说明

    如果需要同步系统级别的过程和package,则需要满足以下条件: 要求使用OGG12.3及以后的版本 需要使用oracle db12.2及以后的版本 需要使用集成抽取和集成投递 在DBA_GG_SUP ...

  9. The Little Prince-12/10

    The Little Prince-12/10 审判自己比审判别人难多了.如果你成功地正确审判了自己,那么你就是一个真正的智者了. ————确实,正视自己是非常难的人生准则.以人为镜,可以明得失,从别 ...

  10. 怎样从外网访问内网MongoDB数据库?

    本地安装了一个MongoDB数据库,只能在局域网内访问到,怎样从外网也能访问到本地的MongoDB数据库呢?本文将介绍具体的实现步骤. 1. 准备工作 1.1 安装并启动MongoDB数据库 默认安装 ...