26 ORM多表操作

 1 前期准备
2 一对多外键增删改查
3 多对多外键增删改查（就是在操作第三张关系表）
4 正反向的概念
5 多表查询
6 聚合查询
7 分组查询
8 F与Q查询
9 django中开启事务

1 前期准备

1.1 建表：models.py

书和出版社是一对多
书和作者是多对多
作者和作者详情是一对一

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField(auto_now_add=True)

    # 库存
    kucun = models.IntegerField(default=1000)
    # 卖出
    maichu = models.IntegerField(default=1000)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.title


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    email = models.EmailField()

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

    def __str__(self):
        return self.name

class AuthorDetail(models.Model): 
    phone = models.BigIntegerField() 
    addr = models.CharField(max_length=64)

    def __str__(self):

       return self.addr

1.2 数据库迁移命令

python manage.py makemigrations
python manage.py migrate

 1.3 插入数据（可手动插入）

AuthorDetail表

INSERT INTO `app01_authordetail` VALUES (1, 110, '芜湖');
INSERT INTO `app01_authordetail` VALUES (2, 120, '山东');
INSERT INTO `app01_authordetail` VALUES (3, 130, '惠州');

Author表

INSERT INTO `app01_author` VALUES (1, 'Jason', 18, 1);
INSERT INTO `app01_author` VALUES (2, 'egon', 84, 2);
INSERT INTO `app01_author` VALUES (3, 'tank', 50, 3);

Publish表

INSERT INTO `app01_publish` VALUES (1, '东方出版社', '东方', '123@qq.com');
INSERT INTO `app01_publish` VALUES (2, '北方出版社', '北方', '666@qq.com');

2 一对多外键字段增删改查

2.1 增

2.1.1 直接写实际字段 id（直接录入相关的主键字段数据）

models.Book.objects.create(title='三国演义',price=123.32,publish_id=1)

2.1.2 虚拟字段 对象

 publish_obj = models.Publish.objects.filter(pk=2).first()
 models.Book.objects.create(title='水浒传',price=345.78,publish=publish_obj)

2.2 删

models.Publish.objects.filter(pk=1).delete()  # 级联删除

2.3 改 

 models.Book.objects.filter(pk=2).update(publish_id=2)
或者：
  publish_obj = models.Publish.objects.filter(pk=1).first()
  models.Book.objects.filter(pk=3).update(publish=publish_obj)

3 多对多外键字段增删改查（就是在操作第三张关系表）

3.1 增：如何给书籍添加作者？

book_obj = models.Book.objects.filter(pk=2).first()
    book_obj.authors.add(1)  # 书籍对象点多对多虚拟字段就相当于在操作第三张关系表

book_obj.authors.add(1,2)   #增加多个

按对象增加一个或多个：

   author_obj = models.Author.objects.filter(pk=1).first()
   author_obj1 = models.Author.objects.filter(pk=2).first()
   book_obj.authors.add(author_obj)   #增加一个
   book_obj.authors.add(author_obj,author_obj1)  #增加多个

add
在第三张关系表中添加数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个

3.2 删

book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.remove(1)   #删除一个
book_obj.authors.remove(1,2)   #删除多个

 author_obj = models.Author.objects.filter(pk=1).first()
 author_obj1 = models.Author.objects.filter(pk=2).first()
 book_obj.authors.remove(author_obj)   #按对象删一个
 book_obj.authors.remove(author_obj, author_obj1) #按对象删多个

remove
在第三张关系表中删除数据
括号内既可以传主键字段也可以传数据对象 并且都支持传多个

3.3 修改

set：括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个

   book_obj = models.Book.objects.filter(pk=2).first()
   book_obj.authors.set([1,])   #改一个
   book_obj.authors.set([1,2])    #改多个

 author_obj = models.Author.objects.filter(pk=1).first()
 author_obj1 = models.Author.objects.filter(pk=2).first()
 book_obj.authors.set([author_obj])    #按对象改一个，括号内必须给一个可迭代对象

book_obj.authors.set([author_obj,author_obj1])   #按对象改多个，括号内必须给一个可迭代对象

set
在第三张关系表中修改数据
括号内需要传一个可迭代对象
可迭代对象里面的元素既可以传主键字段也可以传数据对象 并且都支持传多个

3.4清空数据（clear : 括号内不要加任何参数）

 book_obj = models.Book.objects.filter(pk=2).first()
 book_obj.authors.clear()  # 清空当前书籍与作者的所有绑定关系
 
    clear
        在第三张关系表中清空数据
            括号内无需传值

4 正反向的概念

正向查询
    书籍对象查出版社对象 外键字段在书表中   # 正向查询
    书籍对象查作者对象 外键字段在书表中  # 正向查询
    作者对象查作者详情 外键字段在作者中  # 正向查询
    
反向查询
    出版社查书籍对象 外键字段不在出版社表中  # 反向查询
    作者查书籍对象 外键字段不在作者表中  # 反向查询
    作者详情查作者 外键字段不在作者详情表中  # 反向查询 
"""
    查询数据的时候如果外键字段"在你的手上"则为正向查询
    如果外键字段不在则为反向查询
"""

口诀:
    正向查询按外键字段 ...
    反向查询按表名小写 ...

5 多表查询

5.1 子查询(基于对象的跨表查询)

"""将一条SQL语句的查询结果当做另外一条SQL语句的查询条件"""

'''基于对象的跨表查询'''
     1.查询主键为2的书籍对应的出版社
     先查询书籍对象
     book_obj = models.Book.objects.filter(pk=2).first()
     再基于书籍对象查询出版社对象(书跟出版社的外键字段在书中 所以为正向)
     res = book_obj.publish
     print(res, res.pk, res.name, res.addr)

     2.查询主键为3的书籍对应的作者
     先查询书籍对象
     book_obj = models.Book.objects.filter(pk=3).first()
     再基于书籍对象查询作者对象(书跟作者的外键字段在书中 所以为正向)
     res = book_obj.authors
     print(res)  # app01.Author.None  只差一个all方法即可
     res = book_obj.authors.all()
     for author_obj in res:
         print(author_obj.pk)
         print(author_obj.name)
         print(author_obj.age)

     3.查询jason的详情数据
     先查询作者对象
     author_obj = models.Author.objects.filter(name='jason').first()
     再基于作者对象查询作者详情对象(作者跟作者详情的外键字段在作者表中 所以为正向)
     res = author_obj.author_detail
     print(res,res.phone)
    """
    小总结
        基于对象的正向查询 数据对象点了外键字段之后
        是否需要再点all 取决于关联的数据项有几个 单个无需点 多个则需要点
    """
     4.查询北方出版社出版的书籍
     先查询北方出版社对象
      publish_obj = models.Publish.objects.filter(name='北方出版社').first()
     再基于北方出版社对象对象查询书籍对象(北方出版社对象跟书籍的外键字段在书籍表中 所以为反向)
     res = publish_obj.book_set
     print(res)  # app01.Book.None
     res = publish_obj.book_set.all()
     print(res)  # , ]>

     5.查询jason写过的书籍
     先查询jason对象
     author_obj = models.Author.objects.filter(name='jason').first()
     再基于jason对象查询书籍对象(jason对象跟书籍的外键字段在书籍表中 所以为反向)
     res = author_obj.book_set
     print(res)  # app01.Book.None
     res = author_obj.book_set.all()
     print(res)  # app01.Book.None

     6.查询电话是110的作者姓名
     先查询110详情对象
     author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
     再基于110详情对象查询作者对象(110详情对象跟作者的外键字段在作者表中 所以为反向)
     res = author_detail_obj.author
     print(res)
    """
    基于对象的反向查询
        如果查询出来的数据对象可以有多个 那么需要 
            表名小写_set.all()
        如果查询出来的数据对象只有一个
            表名小写

5.2 联表查询(基于双下划线的跨表查询)  

      1.查询主键为2的书籍对应的出版社
     res = models.Book.objects.filter(pk=2).values('publish__name','publish__addr')
     print(res)


     2.查询主键为3的书籍对应的作者
     res = models.Book.objects.filter(pk=3).values('authors__name','authors__age')
     print(res)
     res = models.Book.objects.filter(pk=3).values_list('authors__name', 'authors__age')
     print(res)


     3.查询jason的详情数据
     res = models.Author.objects.filter(name='jason').values('author_detail__phone','author_detail__addr')
     print(res)


     4.查询书籍pk为2的作者的电话
     res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
     print(res)
    """小总结:自己总结"""


     5.查询北方出版社出版的书籍
     res = models.Publish.objects.filter(name='北方出版社').values('book__title','book__price')
     print(res)


     6.查询jason写过的书籍
     res = models.Author.objects.filter(name='jason').values('book__title','book__price')
     print(res)


     7.查询电话是110的作者姓名
    res = models.AuthorDetail.objects.filter(phone=110).values('author__name')
    print(res)

双下划綫进阶操作

   1.查询主键为2的书籍对应的出版社(不能点书籍)
     res = models.Publish.objects.filter(book__pk=2)
    print(res)  # ]>


     2.查询主键为3的书籍对应的作者
     res = models.Author.objects.filter(book__pk=3)
     print(res)  # , ]>

     3.查询jason的详情数据
     res = models.AuthorDetail.objects.filter(author__name='jason')
     print(res)


     4.查询北方出版社出版的书籍
     res = models.Book.objects.filter(publish__name='北方出版社')
     print(res)


    5.查询jason写过的书籍
     res = models.Book.objects.filter(authors__name='jason')
     print(res)


     6.查询电话是110的作者姓名
    res = models.Author.objects.filter(author_detail__phone=110)
    print(res)

6.聚合查询

    聚合查询通常情况下都是配合分组一起使用的
    只要是跟数据库相关的模块 
        基本上都在django.db.models里面
        如果上述没有那么应该在django.db里面

聚合函数
    max min sum count avg
  
from django.db.models import Max,Min,Sum,Count,Avg
    # 1.统计所有书籍的总价格
    # res = models.Book.objects.aggregate(Sum('price'))
    # print(res)
    # 2.统计所有书籍的总数
    # res = models.Book.objects.aggregate(Count('pk'))
    # print(res)
    # 3.统计价格最高的    # res = models.Book.objects.aggregate(Max('price'))
    # print(res)
    res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('price'),Avg('price'))
    print(res)

7.分组查询

 MySQL分组查询都有哪些特点
        分组之后默认只能获取到分组的依据 组内其他字段都无法直接获取了
            严格模式
                ONLY_FULL_GROUP_BY

"""分组查询:annotate"""
     1.统计每一本书的作者个数
    '''author_num是必须要起的别名 因为后面的values中需要使用'''
     res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num','title')
     print(res)       # models后面点什么 就是按什么分组

                            # author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数

     2.统计出每个出版社卖的最便宜的书的价格
     res = models.Publish.objects.annotate(min_price=Min('book__price')).values('min_price','name','book__title')
     print(res)


     3.统计不止一个作者的图书
     res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1)
     print(res)


     4.查询各个作者出的书的总价格
     res = models.Author.objects.annotate(price_sum=Sum('book__price')).values('name','price_sum')
     print(res)
    """
    1.大的分组
        models.表名.objects.annotate  按照models后面的表名分组(主键)
    2.小的分组（如果我想按照指定的字段分组该如何处理呢？）
    models.表名.objects.values('price').annotate() 按照values括号内指定的字段分组 """

8.F与Q查询

F查询

from django.db.models import F
     F的功能是获取数据库中字段原有的数据
     1.将所有书籍的价格提升100块
     models.Book.objects.update(price=F('price')+1000)


     2.将所有书籍名称后面加上爆款后缀
     from django.db.models.functions import Concat
     from django.db.models import Value
     ret3 = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    '''F查询默认操作数字类型 如果需要操作字符类型需要上述方式'''


     3.查询库存数大于卖出数的书籍
    res = models.Book.objects.filter(kucun__gt=F('maichu'))
    print(res)

 Q查询

 Q查询
     1.查询卖出数大于100或者价格小于600的书籍
     res = models.Book.objects.filter(maichu__gt=100,price__lt=600)   #逗号分隔为and关系，那么怎么用或者呢？？？
    """filter括号内多个参数是and关系"""
    from django.db.models import Q
     res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))  # Q包裹逗号分割 还是and关系
     res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600))  # | or关系
     res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))  # ~ not关系
     print(res)  # 

    # Q的高阶用法  能够将查询条件的左边也变成字符串的形式
   # filter(title='123') filter('title'='123')

    q = Q()
   # q.connector = 'or'    #也可以修改链接关系（默认是True）
   # q.children.append(('title', '三国演义爆款'))
    #q.children.append(('title__contains', '爆'))
    q.children.append(('maichu__gt',100))
    q.children.append(('price__lt',600))
    res = models.Book.objects.filter(q)  # 默认还是and关系
    print(res)

orm事务操作

"""
事务:ACID
        A原子性   不可分割的最小单位
        C一致性   跟原子性是相辅相成的
        I隔离性   事物之间互不干扰
        D持久性   事物一旦确认永久生效
start transaction
...
事物的回滚 rollback
事物的确认 commit
"""
开启事物有2中方式：with上下文的形式、装饰器的形式，下面以with上下文的形式为例
from django.db import transaction
    # 事务
    # 买一本 跟jason学Linux 书
    # 在数据库层面要做的事儿
    # 1. 创建一条订单数据
    # 2. 去产品表 将卖出数+1， 库存数-1
    from django.db.models import F
    # 开启事务处理
    try:
        with transaction.atomic():     #在with代码块内书写的所有orm操作都属于同一个事物
            # 创建一条订单数据
            models.Book.objects.create(num="110110111", product_id=1, count=1)
            # 能执行成功
            models.Book.objects.filter(id=1).update(kucun=F("kucun") - 1, maichu=F("maichu") + 1)
    except Exception as e:
        print(e)

        transaction.rollback()  # 回滚
        transaction.commit()  # 提交