python ORM数据库操作

对单表的操作

增

• 方式一

book1 = Book(price="99",author="yuan",title="python基础",publishDdata="2019-05-02")
book1.save()

• 方式二(推荐)

    Book.objects.create(price="90",author="yuan",title="java基础",publishDdata="2019-05-01")
    Book.objects.create(**dic)

注：参数中少了nid因为它是设置的主键自增长

注：参数中的日期格式必须写为"yyyy-mm-dd"

改

• 方式一（推荐）

    Book.objects.filter(nid = '2').update(price=9.8)

filter - where

注：filter返回的是一个对象查询的集合

• 方式二

book = Book.objects.get(nid = '2')
book.price = 9.7
book.save()

注：get得到的是一个对象

删除

删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：e.delete()

def delstudent(request,id):
    # 删除数据
    models.Student.objects.filter(nid=id).delete()
    return redirect("/test/")

你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中所有的对象。

例如，下面的代码将删除 pub_date 是2005年的 Entry 对象：

Entry.objects.filter(pub_date__year=2005).delete()

要牢记这一点：无论在什么情况下，QuerySet 中的 delete() 方法都只使用一条 SQL 语句一次性删除所有对象，而并不是分别删除每个对象。如果你想使用在 model 中自定义的 delete() 方法，就要自行调用每个对象的delete 方法。(例如，遍历 QuerySet，在每个对象上调用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。

在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()

要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：

Entry.objects.all().delete()

查

• filter() = where条件 返回Queryset

    book_list = Book.objects.filter(author="yuan")

• all() = select all 可切片 返回Queryset

    # book_list = Book.objects.all()  取全部
    book_list = Book.objects.all()[:2]  #切片，取0-1
    book_list = Book.objects.all()[::2] #切片，取0,2
    book_list = Book.objects.all()[-1] #切片，倒序

注：切片相当于sql Limit Order

• get() 取单个对象(且只可取单个，如果查询结果为多个，抛出异常)

    book = Book.objects.get(price=95)

• filter().values() 取单个字段集合

    book_titles = Book.objects.filter(author="yuan").values("title","price")

返回的是一个字典QuerySet集

<QuerySet [{'title': 'python基础', 'price': Decimal('99.00')}, {'title': 'java基础', 'price': Decimal('9.70')}]>

• filter().values_list() 取单个字段集合

    book_titles = Book.objects.filter(author="yuan").values_list("title","price")

返回的是一个元组的QuerySet

<QuerySet [('python基础', Decimal('99.00')), ('java基础', Decimal('9.70'))]>

• exclude 排除 返回一个字典列表

    book_list = Book.objects.exclude(author="yuan")

• first() 查询第一个
• last() 查询最后一个
• order_by(field) 对结果排序
• reverse() 反向排序
• distinct() 去重

    book_list = Book.objects.all().values('title','price','author').distinct()

注：是对values进行去重

• count 取数

    book_count = Book.objects.all().values('title','price','author').distinct().count()

• exist() 存在

更多…

https://blog.csdn.net/hang916/article/details/79881647
http://www.cnblogs.com/haiyan123/p/7763710.html

3.使用__多条件查询

• __gt 大于

    book_list = Book.objects.filter(price__gt=50)

• __contain like

    book_list = Book.objects.filter(title__contains = "o")

更多…

https://www.cnblogs.com/yuanchenqi/articles/6083427.html

对多表的操作

操作，一对多

增

• 方式一

     #publish_id=2
    Book.objects.create(name="linux运维",price=77,pub_date="2017-12-12",publish_id=2)

注：如果是这样直接指定publish_id字段去添加值，前提是你的主表里面必须有数据

主表：没有被关联的（因为book表是要依赖于publish这个表的）也就是publish表

子表：关联的表

• 方式二(推荐)

    publish_obj = Publish.objects.filter(name="南方出版社")[0]
    Book.objects.create(name="oracle基础", price=78, pub_date="2017-12-12", publish=publish_obj)

• 方式三 save()

pubObj = Publish.objects.get(name="人大出版社")  # 只有一个的时候用get,拿到的直接就是一个对象
bookObj = Book(name="真正的勇士", pub_date="2015-9-9", price="50", publish=pubObj)
bookObj.save()

查

1. 通过对象查询

# 正向查询(外键所在表去查另一张表，Book >> Publisher)
# 找到python所对应的出版社名字
     book_obj=Book.objects.get(name="python")   
     pub_obj=book_obj.publish----》书籍对象对应的出版社对象
     pub_obj.name 
     pub_obj.city

# 反向查询（普通表去查外键所在的表，Publisher >> Book）
# 找到清华出版社出版的所有书籍
    pub_obj = Publish.objects.filter(name="人大出版社").first()
    # bookset = Book.objects.filter(publish = pub_obj).values("name","price")
    bookset = pub_obj.book_set.all().values("name","price") #推荐
    print(bookset)

 # 查询 人民出版社出版过的所有书籍
    publish=models.Publish.objects.get(name="人民出版社")   #get得到的直接是一个对象，不过get只能查看有一条记录的
    book_list=publish.book_set.all()  # 与人民出版社关联的所有书籍对象集合
     for book_obj in book_list:
      print(book_obj.title)
注意这里用for循环或是用values,vauleslist都是可以的。

2.通过filter values 双下划线__

# 人大出版社出版过的书籍与价格
ret = Book.objects.filter(publish__name = '人大出版社').values("name","price")
# python这本书出版社的名字
ret = Publish.objects.filter(book__name='python').values("name")
ret = Book.objects.filter(name='python').values("publish__name")
# 北京的出版社出版书的名字
ret = Book.objects.filter(publish__city='北京').values("name","price")
# 2019年5月上半旬出版过书的出版社的名字
ret = Book.objects.filter(pub_date__lt="2019-05-17",pub_date__gt="2019-05-01").values('name','publish__name','publish__city')
ret = Publish.objects.filter(book__pub_date__lt="2019-05-17",book__pub_date__gt="2019-05-01").values('book__name','name','city')

操作，多对多

1.多对多增加数据

• 通过对象的方式绑定关系

# 多对多的添加的两种方式
    # 方式一：
    # 先创建一本书：
    pub_obj=models.Publish.objects.filter(name="万能出版社").first()
    book_obj = models.Book.objects.create(title="醉玲珑",publishDdata="2015-4-10",price="222",publish=pub_obj)
    # #通过作者的名字django默认找到id
    haiyan_obj = models.Author.objects.filter(name="haiyan")[0]
    egon_obj = models.Author.objects.filter(name="egon")[0]
    xiaoxiao_obj = models.Author.objects.filter(name="xiaoxiao")[0]
    # 绑定多对多的关系、
    book_obj.authorlist.add(haiyan_obj, egon_obj, xiaoxiao_obj)

    # 方式二=========,查出所有的作者
    pub_obj = models.Publish.objects.filter(name="万能出版社").first()
    book_obj = models.Book.objects.create(title="醉玲珑", publishDdata="2015-4-10", price="222", publish=pub_obj)
    authers = models.Author.objects.all()
    # #绑定多对多关系
    book_obj.authorlist.add(*authers)

使用add传入数组时必须加*

• 解除多对多的关系 remove

解除绑定：remove： # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])

    # 解除多对多的关系（remove）
    book_obj=models.Book.objects.filter(title="醉玲珑").last() #找到书对象
    authers=models.Author.objects.filter(id__lt=3)  #找到符合条件的作者对象
    book_obj.authorlist.remove(*authers) #因为清除的是多条，得加个*

清除所有绑定 clean#清空被关联对象集合。

 # 清除关系方法(clean)
    book_obj= models.Book.objects.filter(title="红楼梦")
    for book_obj_item in book_obj:#把所有红楼梦的都给清空了
        book_obj_item.authorlist.clean()

总结：remove和clean的区别

remove：得吧你要清除的数据筛选出来，然后移除

clean：不用查，直接就把数据都清空了。

各有应用场景

2.多对多查找数据

• 同一对多的使用filter 和 value 查询

#方式一    
    ret = models.Author.objects.filter(name="egon").values("book__title")
    print(ret)
#方式二：两种方式也就是逻辑不一样
    ret2 = models.Book.objects.filter(authorlist__name="egon").values("title")
    print(ret2)

    # 方式一：
    author_obj = models.AuthorDeital.objects.filter(tel__startswith="151").first()
    print(author_obj.author.book_set.all().values("title","publish__name"))
    # 方式二：
    ret = models.Book.objects.filter(authorlist__author_deital__tel__startswith="151").values("title","publish__name")
    print(ret)

 # 查询年龄小于50的作者出版过的所有书以及出版社的名称
    ret = Book.objects.filter(authors__age__lt=50).values('publish__name','name','publish__book__name')

    # 查询韩寒出过的所有书及出版社的名称
    au_obj = Author.objects.filter(name='韩寒').first()
    ret = au_obj.book_set.all().values("name","publish__name")
    print('ret',ret)

聚合查询

1. 首先导入

from django.db.models import Avg,Sum,Count,Max,Min

使用聚合查询：aggregate(*args, **kwargs)，只对一个组进行聚合

# 1、查询所有图书的平均价格
print(models.Book.objects.all().aggregate(Avg("price")))
print(models.Book.objects.all().aggregate(avgprice = Avg("price")))

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

---

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

print(models.Book.objects.all().aggregate(Avg("price"),Max("price"),Min("price")))
#打印的结果是：  {'price__avg': 174.33333333333334, 'price__max': Decimal('366.00'), 'price__min': Decimal('12.00')}

---

Test

 # 查询所有图书的平均价格
    ret = Book.objects.all().aggregate(Avg('price'))
    ret = Book.objects.all().aggregate(avgPrice = Avg('price')) #加别名

    # 查询人大出版社的书的最低价格
    ret = Book.objects.filter(publish__name='人大出版社').aggregate(最低价格=Min('price'))

    # 查询韩寒写了多少本书
    ret = Book.objects.filter(authors__name='韩寒').aggregate(Count('price'))

使用分组查询 :annotate()：为QuerySet中每一个对象都生成一个独立的汇总值。是对分组完之后的结果进行的聚合

1.统计每一本书的作者个数

 # 方式一：
     # 思路是先 select *,count(author.'name') from ... 然后再取各个authorNum
    print(models.Book.objects.all().annotate(authorNum = Count("authorlist__name")).values("authorNum"))
# 方式二：
booklist =models.Book.objects.all().annotate(authorNum=Count("authorlist__name"))
for book_obj in booklist:
    print(book_obj.title,book_obj.authorNum)
# 方式三：
     # 思路：先求关系表中每一行作者所对应的书名，然后再根据每一组里的任意字段Count出该组是数目
    ret = Author.objects.values('book__name').annotate(Count('book__price'))

2、统计每一个出版社最便宜的书

    # 2、统计每一个出版社的最便宜的书
    # 方式一：
        # 思路:先按照出版社名字分组，再求出各组的最小价格
    print(models.Book.objects.values("publish__name").annotate(nMinPrice=Min('price')))  注意：values内的字段即group by的字段，，也就是分组条件
    # 方式二：
        # 思路：直接求出每个出版社的最小价格，再通过values取出来
    print(models.Publish.objects.all().annotate(minprice=Min("book__price")).values("name","minprice"))
    # 方式三
    publishlist = models.Publish.objects.annotate(minprice = Min("book__price"))
    for publish_obj in publishlist:
        print(publish_obj.name,publish_obj.minprice)

总结：我们可以把annotate（y函数）理解为按照xxx来分组(group by xxx) 然后执行y函数。至于xxx是什么，有2种情况：

1.当annotate前没有values(xxx)时，默认按照该表的主键来分，比如

ret=Book.objects.annotate(bookCount=Count(‘authors__name’)).filter(bookCount__gt=1)

就是按照每本书来计算每本书的作者数量，然后筛选出作者数量大于1 的

---

2.当annotate前有values(xxx)时，就是按照value(xx)中的xx字段来分组（group by xx）,我们可以把values（xx）理解为向该表中加入该字段（实际上是进行了表关联，做了类似笛卡尔积的操作）

ret = Book.objects.values(‘authors__name’).annotate(Sum(‘price’))

就是将Book表按照authors的name来进行分组(group by Author.name),然后在此基础上求Sum(Book.price)

这是本人自己总结的规律，暂时没发现问题，如有问题，欢迎指正

谢谢

---

Test

    # 每个作者有多少本书
    ret = Book.objects.values('authors__name').annotate(Count('price'))
    # 每个作者书的总价
    ret = Book.objects.values('authors__name').annotate(authorSum = Sum('price'))

    # 每本书有多少个作者
    # 思路是先 select *,count(author.'name') from ... 然后再取各个authorNum
    # print(Book.objects.all().annotate(authorNum = Count("authors__name")).values("authorNum"))

    # booklist = Book.objects.all().annotate(authorNum=Count("authors__name"))
    # for book_obj in booklist:
    #     print(book_obj.name, book_obj.authorNum)

    # 思路:先按照出版社名字分组，再求出各组的最小价格
    ret = Book.objects.values('publish__name').annotate(Min('price'))
    # 思路：直接求出每个出版社的最小价格，再通过values取出来
    # ret = Publish.objects.all().annotate(minPrice = Min('book__price')).values('name','minPrice')

    # 思路：先求关系表中每一行作者所对应的书名，然后再根据每一组里的任意字段Count出该组是数目
    # ret = Author.objects.values('book__name').annotate(Count('book__price'))

    # 统计包含p的书的作者个数
    # 先筛选出包含p的书，再给每行加上Count字段计算该书的作者个数，最后取出字段name和booCount
    ret = Book.objects.filter(name__contains='p')\
        .annotate(booCount = Count('authors__name')).values('name','booCount')

    # 统计作者大于1的书 .values('authors__name')
    # 先给每个书加上bookCount字段计算他们的值，再筛选出该字段大于1的书
    ret = Book.objects.annotate(bookCount=Count('authors__name')).filter(bookCount__gt=1)

    # 根据一本图书作者数量的多少对查询集QuerySet进行排序:
    ret = Book.objects.annotate(bookCount=Count('authors__name')).order_by('bookCount').values('name','bookCount')


    # 查询各个作者出的书的总价格:
    ret = Book.objects.values('authors__name').annotate(Sum('price'))

    ret = Author.objects.values('name').annotate(Sum('book__price'))
    ret = Author.objects.annotate(bsum = Sum('book__price')).values('name','bsum')

F函数和Q函数

F函数

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

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

1、查看评论数大于阅读数的书
 from django.db.models import F,Q
 print(models.Book.objects.filter(commentNum__gt=F("readNum")))
 
2、修改操作也可以使用F函数,比如将id大于1的所有的书的价格涨价100元
print(models.Book.objects.filter(nid__gt=1).update(price=F("price")+100))
 
3、Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍
    models.Book.objects.filter(commnetNum__lt=F('keepNum')*2)

---

Test

# 利用F更新所有价格
Book.objects.all().update(price=F('price')-10)

# 查询出cost < price-10 的书籍
ret = Book.objects.filter(cost__lt=F('price')-10)

Q函数

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

1、查询id大于1并且评论数大于100的书
 print(models.Book.objects.filter(nid__gt=1,commentNum__gt=100))
 print(models.Book.objects.filter(nid__gt=1).filter(commentNum__gt=100))
 print(models.Book.objects.filter(Q(nid__gt=1)&Q(commentNum__gt=100)))
2、查询评论数大于100或者阅读数小于200的书
print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))
Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。
3、查询年份等于2017年或者价格大于200的书
 print(models.Book.objects.filter(Q(publishDdata__year=2017)|Q(price__gt=200)))
4、查询年份不是2017年或者价格大于200的书
print(models.Book.objects.filter(~Q(publishDdata__year=2017)&Q(price__gt=200)))

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

bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python")

---

Test

 # 查询ID大于4且价格大于100的书
ret = Book.objects.filter(id__gt=4,price__gt=100)
ret = Book.objects.filter(id__gt=4).filter(price__gt=100)
ret = Book.objects.filter(Q(id__gt=4)&Q(price__gt=100))

# 查询ID小于3或者价格大于100的书
ret = Book.objects.filter(Q(id__lt=3)|Q(price__gt=100))

# 查询年份不是2019或者price大于100的书
ret = Book.objects.filter(~Q(pub_date__year=2019)|Q(price__gt=100))

QuerySet的特性

1.QuerySet使用的是惰性查询，只有当要使用的时候才会执行SQL语句，否则的话只能当作一个SQL语句集

2.QuerySet是具有cache（缓存），一条查询使用2次时只会在第一次使用时运行SQL语句。

优点：效率更高了，不必执行多余的重复查询

缺点：1.当数据库又变化时，还是取的缓存的内容，因为在这种情况下我们必须手动重新拿到一个QuerySet。 2.当QuerySet数据量过大时，cache开销压力会很大

3.可迭代，可切片

4.当我们仅仅需要判断查询后QuerySe中是否含有数据时，使用exisits方法，有返回True，否则返回False,注意是为了降低缓存压力

5.当查询数据量过大时，可以使用iterator()方法将其变成一个生成器，特点是，用一个取一个，内存开销小，缺点是基于next方法只能遍历一次。这时候就不要使用cache缓存啦

ret = ret.iterator()

更多参考

http://www.cnblogs.com/haiyan123/p/7745536.html
https://www.cnblogs.com/yuanchenqi/articles/6083427.html