Models-详细操作

# 单表简单查询13种方法

 1.all(): 查询所有结果
 all： models.表名.objects.all()
 book_all=models.Book.objects.all() # 结果是querySet集合 [model对象，....]
 print(book_all) # <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]>

 2.filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
 filter： models.表名.objects.filter() # 结果是querySet集合 [model对象，....]
 ret1=models.Book.objects.filter(author="yuan") # # <QuerySet [<Book: 追风筝的人>, <Book: asd>]>
 ret2=models.Book.objects.filter(nid=1) # <QuerySet [<Book: yuan>]>
 filter多条件逗号分隔
 ret2=models.Book.objects.filter(author="yuan",price=123) # <QuerySet [<Book: yuan>]>
 print(ret2)

 3.get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 get models.表名.objects.get() # model对象，必须是一个，没有报错，多了报错
 ret3=models.Book.objects.get(author="yuan")
 print(ret3.price)

 5.exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
 exclude : 排除条件
 ret4=models.Book.objects.exclude(author="yuan")
 print(ret4)

 4.values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列,model的实例化对象，而是一个可迭代的字典序列
 values方法
 ret=models.Book.objects.filter(author="yuan").values("title","price")
 print(ret)# <QuerySet [{'title': '追风筝的人', 'price': Decimal('99.00')}, {'title': 'asd', 'price': Decimal('123.00')}]>

 9.values_list(*field): 它与values()，非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 ret = models.Book.objects.filter(author="yuan").values_list("title", "price")
 print(ret) # <QuerySet [('追风筝的人', Decimal('99.00')), ('asd', Decimal('123.00'))]>

 6.order_by(*field): 对查询结果排序
 7.reverse(): 对查询结果反向排序

 8.distinct(): 从返回结果中剔除重复纪录
 ret=models.Book.objects.filter(author="yuan").values("author").distinct()
 print(ret)

 10.count(): 返回数据库中匹配查询(QuerySet)的对象数量。
 count计数方法
 ret=models.Book.objects.filter(author="yuan").count()
 print(ret)

 11.first(): 返回第一条记录
 ret = models.Book.objects.all().first()
 print(ret)

 12.last(): 返回最后一条记录

 13.exists(): 如果QuerySet包含数据，就返回True，否则返回False
 exists方法，是否存在数据，只会查询一条，效率高
 if models.Book.objects.all().exists():
 print("exists")
 else:
 print("nothing")

# 双下划线之单表查询

 1.models.Book.objects.filter(publishDate__year=2017,publishDate__month=10) # 通过日期查询

 2.models.Book.objects.filter(author__startswith="张") # 通过开头包含查询
 startswith，istartswith, endswith, iendswith

 3.models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
 models.Book.objects.filter(price__gt=100)
 models.Book.objects.filter(price__gte=99) # 大于等于

 4.models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
 models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in

 5.models.Tb1.objects.filter(name__contains="ven"） # 通过包含字符查询
 models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

 6.models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and

# 图书馆里系统增删改查表操作

 # 表 结构 图书管理系统
 from django.db import models
 # Create your models here.
 class Book(models.Model):
 title = models.CharField(max_length=32)
 publishDate = models.DateField()
 price = models.DecimalField(max_digits=5, decimal_places=2) # 999.99

 # 创建一对多的关联字段 : 是与某个书籍对象关联的出版社对象(注意，只有一个对象)
 publish=models.ForeignKey("Publish")

 # 创建的多对多的关系
 authors=models.ManyToManyField("Author")

 def __str__(self):
 return self.title

 class Publish(models.Model):
 nid = models.AutoField(primary_key=True)
 name=models.CharField( max_length=32)
 email=models.EmailField()

 class Author(models.Model):
 name=models.CharField(max_length=32)
 age=models.IntegerField()

 def __str__(self):
 return self.name

 class AuthorDetail(models.Model):
 addr=models.CharField(max_length=32)
 email=models.EmailField()
 author=models.OneToOneField("Author")
 ’‘’
 # 更新表记录
 通过对象下字段更新，效率低
 book_obj=models.Book.objects.filter(nid=id)[0]
 book_obj.title=title1
 book_obj.save()

 通过update效率高
 Book.objects.filter(id=2).update(price=255,name='linux')

 # 删除表记录
 Book.objects.filter(id=2).delete()

 # 添加记录操作
 添加数据库，单表
 第一种写法，效率低
 models.Book(title=title1,author=author1,publishDate=publishDate1,price=price1).save()
 第二种写法
 models.Book.objects.create(title=title1,author=author1,publishDate=publishDate1,price=price1)

 添加数据库，多表
 关联表必须有数据
 pub_obj=Publish.objects.get(name="沙河出版社")

 ########################## 一对多添加##################################
 方式1 关联字段放关联对象：
 Book.objects.create(title="python",publishDate="2001-12-12",price=122,publish=pub_obj)
 方式2 关联字段放关联ID：
 book_obj=Book.objects.create(title="小红书3",publishDate="2011-08-12",price=112,publish_id=1)

 ########################## 多对多添加##################################
 找到对象
 book_obj = Book.objects.create(title="小红书3", publishDate="2011-08-12", price=112, publish_id=1)

 第三张表关联添加
 alex=Author.objects.get(name="alex") # aler.id
 egon=Author.objects.get(name="egon") # egon.id

 绑定关系1，对象
 book_obj.authors.add(alex,egon)

 追加一个作者
 book_obj=Book.objects.filter(title="小红书3").first()

 wenzhou=Author.objects.get(name="文州")
 book_obj.authors.add(wenzhou)

 删除一个作者
 alex=Author.objects.get(name="alex")
 book_obj = Book.objects.filter(title="小红书3").first()
 book_obj.authors.remove(alex)

 清空所有作者
 book_obj = Book.objects.filter(title="小红书3").first()
 book_obj.authors.clear()

 绑定关系2，全部
 book_obj = Book.objects.create(title="linux", publishDate="2011-08-13", price=113.00, publish=pub_obj)

 authors=Author.objects.all()
 book_obj.authors.add(*authors)

 绑定关系3，利用id
 book_obj.authors.add(1)

# 批量操作

在Hibenate中，通过批量提交SQL操作，部分地实现了数据库的批量操作。但在Django的ORM中的批量操作却要完美得多，真是一个惊喜。

数据模型定义
首先，定义一个实例使用的django数据库模型Product，只是象征性地定义了两个字段name和price。

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=10, decimal_places=2)
批量插入数据
批量插入数据时，只需先生成个一要传入的Product数据的列表，然后调用bulk_create方法一次性将列表中的数据插入数据库。

product_list_to_insert = list()
for x in range(10):
    product_list_to_insert.append(Product(name='product name ' + str(x), price=x))
Product.objects.bulk_create(product_list_to_insert)
批量更新数据
批量更新数据时，先进行数据过滤，然后再调用update方法进行一次性地更新。下面的语句将生成类似update...where...的SQL语句。

Product.objects.filter(name__contains='name').update(name='new name')
批量删除数据
批量更新数据时，先是进行数据过滤，然后再调用delete方法进行一次性地删除。下面的语句将生成类似delete from...where...的SQL语句。

Product.objects.filter(name__contains='name query').delete()
如果是通过运行普通Python脚本的方式而不是在view中调用上述的代码的，别忘了先在脚本中进行django的初始化：

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testproject.settings")

import django
django.setup()
Hibernate的所谓“批量操作”中，对每一个实体的更新操作，都会生成一条update语句，然后只是把好几个update语句一次性提交给数据库服务器而已。对实体的删除操作也是一样。

Django ORM中的批量操作的实现更接近于SQL操作的体验，运行效率也会比Hibernate中的实现更加高效。

# 查询操作

 正向查询是字段，反向查询看表名
 --------- 基于对象跨表查询（子查询）

 注意：找出是一个，一般是对象就是.，找出是多个，一半是要all
 .publish
 ==== 一对多(Book----------------->Publish)
 <----------------
 .book_set.all()    

 # 查询python这本书的出版社的名字 （正向查询，按字段）
 book_obj=Book.objects.get(title="python")
 print(book_obj.publish.name)

 # 查询沙河出版社出版过的书籍名称 (反向查询按:表名_set)
 pub_obj=Publish.objects.get(name="沙河出版社")
 print(pub_obj.book_set.all())

 .authors.all()
 ==== 多对多（Book------------------->Author）
 <--------------------
 .book_set.all()

 # 查询python这本书的所有作者的名字 （正向查询，按字段）
 book_obj=Book.objects.get(title="python")
 print(book_obj.authors.all())    

 # 查询alex出版过的所有书籍 (反向查询按:表名_set)
 author_obj=Author.objects.get(name="alex")
 print(author_obj.book_set.all()) # <QuerySet [<Book: pyhton>]>

 .author
 ==== 一对一（AuthorDetail--------------->Author）
 <----------------
 .authordetail

 # 查询地址在沙河并且email是alex@126.com的作者的名字 （正向查询，按字段）
 authordetail=AuthorDetail.objects.get(addr="沙河",email=alex@126.com)
 print(authordetail.author.name)

 # 查询alex的email (反向查询按:表名)
 alex=Author.objects.get(name="alex")
 print(alex.authordetail.email)    

 # 查询住在沙河的作者出版过的所有书籍的名称以及出版社名称
 authordetail=AuthorDetail.objects.get(addr="沙河")
 author=authordetail.author
 bookList=author.book_set.all()
 for book in bookList:
 print(book.title,book.publish.name)

# 基于双下划线查询（join查询）

 ##########################基于双下划线的查询：正向查询，按字段，反向查询，按表名#####################

 ########################################一对多查
 # 查询python的出版社名称
 ret=Book.objects.filter(title="python").values("publish__name") # <QuerySet [{'publish__name': '沙河出版社'}]>
 print(ret)
 Publish.objects.filter(book__title="小红书").values("name")

 # 查询沙河出版社出版过的书籍名称
 ret=Publish.objects.filter(name="沙河出版社").values("book__title")
 print(ret)
 Book.objects.filter(publish__name="沙河出版社").values("title")

 # 查询python所有作者的名字
 ret=Book.objects.filter(title="python").values_list("authors__name")
 print(ret)

 # 查询alex出版过的所有书籍
 ret=Author.objects.filter(name="alex").values("book__title")
 print(ret)
 Book.objects.filter(authors__name="alex").values("title")

 # 查询地址在沙河并且email是alex@126.com的作者的名字
 ret=AuthorDetail.objects.filter(addr="沙河",email=alex@126.com).values("author__name")
 print(ret)

 # email以alex开头的作者出版过的所有书籍名称以及出版社名称
 ret=Book.objects.filter(authors__authordetail__email__startswith="alex").values("title","publish__name")
 print(ret)

# 分组，聚合函数

 rom django.db.models import Avg,Sum,Count,Min
 #############################聚合函数：aggregate###################
 # 查询所有书籍的平均价格

 ret=Book.objects.all().aggregate(avgPrice=Avg("price"))
 print(ret) # {}

 ############################分组函数：annotate ###################
 # 查询每一个出版社出版过的书籍个数
 ret=Publish.objects.all().annotate(c=Count("book__title"))
 for pub_obj in ret:
 print(pub_obj.name,pub_obj.c)

 # 查询每一本书的作者个数
 ret=Book.objects.all().annotate(counts=Count("authors__id")).values("title","counts")
 print(ret)

 # 查询每一个作者出版过的书籍的平均价格
 ret=Author.objects.all().annotate(avgPrice=Avg("book__price")).values("name","avgprice")
 print(ret)

# F Q查询 （不支持字符串）

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

 # 查询评论数大于收藏数2倍的书籍（可以做一些运算）
 Book.objects.filter(commnetNum__lt=F('keepNum')*2)

 # 修改操作也可以使用F函数,比如将每一本书的价格提高30元
 Book.objects.all().update(price=F("price")+30)　

 Q 查询
 # filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。
 from django.db.models import Q
 # 查询作者是yuan 或者 是egon 的书
 bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

 # 查询作者是yuan 并且 出版日期不是2017年的书
 bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")
20 # Q查询的时候，Q要在关键词查询前面，否则报错，例如 filter(Q(authors__name="yuan"),authors__name="egon")