外键字段的增删改查、多表查询(子查询和连表查询、正反向、聚合查询、 分组查询、 F与Q查询)、django中如何开启事务

一、 外键字段的增删改查

1.多对多的外键增删改查
	图书和作者是多对多，借助于第三张表实现的，如果想绑定图书和作者的关系，本质上就是在操作第三方表

2.如何操作第三张表
	问题：让你给图书添加一个作者，他俩的关系可是多对多
	多对多的增删该查
    
    1.给图书id=2添加一个作者id=1
    book_obj = models.Book.objects.filter(pk=2).first()
    print(book_obj.authors) # app01.Author.None 这句话的意思就是跨到了第三张表

    借助于内置方法add()
    book_obj.authors.add(1)  # 加一个作者
    book_obj.authors.add(2,3) # 一次性条件多个作者

   	也支持写对象
    # author_obj1 = models.Author.objects.filter(pk=1).first()
    # author_obj2 = models.Author.objects.filter(pk=2).first()
    # author_obj3 = models.Author.objects.filter(pk=3).first()
    # book_obj.authors.add(author_obj1, author_obj2, author_obj3)

    2.删除
    # 也支持写对象
    book_obj.authors.remove(1)
    # book_obj.authors.remove(2,3)


    3.修改
    # book_obj.authors.set(1,3) # set() takes 2 positional arguments but 3 were given
    book_obj.authors.set([1,3])  # 注意修改的时候得加上中括号[]

    4.清空表
    book_obj.authors.clear()  # 注意：这只能清空book_id=2的，若还有其他id数据，则还在
    
总结：
	操作第三张表 通过外键字段点下面的方法
	add remove set clear # 四个方法
	

二、 多表查询

1.子查询和连表查询

子查询：一个SQL语句的执行结果当成另一个SQL语句的执行条件，分步操作

连表查询：把多个表关联在一起拼接成一个大的虚拟表，然后按照单表查询
	inner join
    left  join
    right join
    union
select * from course inner join teacher on course.id=teacher_course_id where id=1;

select * from course as c inner join teacher as t on course.id=teacher_course_id left join class on class.id=c.class_id where c.id=1

2.正反向的概念

先判断是正向还是反向查询
1.正向
	外键字段在我手上，我查你就是正向查询
    # 图书查出版社：外键字段在图书表中，正向查询
2.反向
	外键字段在我手上，你查我就是反向查询
    # 出版社查图书，外键字段在图书表中，反向查询
 
3.判断出来正向和反向之后有什么用
	正向查询按照字段查询(外键字段)
	反向查询按照表名小写或者表名小写_set

3. 子查询

	# 1.查询书籍主键为1的出版社
    # 书籍查出版社----------->正向查询------------>按字段查询
    res = models.Book.objects.filter(pk=1).first()
    print(res.publish)  # 人民出版社 publish_obj
    print(res.publish.name)
    print(res.publish.addr)

   	# 2.查询书籍主键为2的作者
    # 书籍查作何------>正向查询------->按外键字段查询
    book_obj = models.Book.objects.filter(pk=2).first()
    print(book_obj)  # Book object (2)
    # 一本书有多个作者，所以得点all()
    print(book_obj.authors.all())  # <QuerySet [<Author: Author object (1)>]>
    print(book_obj.authors.all()[0].name)  # jerry
    print(book_obj.authors.all()[0].age)  # 18
    
    # for i in book_obj.authors.all():
    #     print(i)

    
    # 3.查询作者jack的电话号码
    # 作者查作者详情------------->正向查询---------------->按字段查询
    author_obj = models.Author.objects.filter(name='jerry').first()
    print(author_obj.author_detail) # AuthorDetail object (1)
    print(author_obj.author_detail.phone)

    # 4.查询出版社是北京出版社出版的书
    # 出版社查书------>反向查询------>按照表名小写或者_set
    publish_obj = models.Publish.objects.filter(name='北京出版社').first()
    print(publish_obj.book_set)  # app01.Book.None
    print(publish_obj.book_set.all())  # <QuerySet [<Book: Book object (2)>]>
    print(publish_obj.book_set.all()[0].title)  # 水浒

    # 5.查询作者是jack写过的书
    # 作者查询书籍------------->反向查询------------>按照表名小写或者_set
    author_obj = models.Author.objects.filter(name='tom').first()
    print(author_obj.book_set)  # app01.Book.None
    print(author_obj.book_set.all())  # <QuerySet []>

    # 6.查询手机号是110的作者姓名
    # 作者详细查询作者--------------->反向查询------------>按照表名小写或者_set
    author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    print(author_detail_obj.author) # Author object (1)
    print(author_detail_obj.author.name) 
    
总结：
	1. 什么时候加_Set
    2. 什么时候.all()
 	结论：当查询的结果是有多个的时候，就需要以上两个操作

4.多表查询之连表查询(基于双下划线的查询)

'''多表查询之连表查询(基于双下划线的查询)'''
    # 1.查询jerry的手机号和作者姓名
    # 作者查作者详情 ----->正向查询------->按字段
    res = models.Author.objects.filter(name='jerry').values('author_detail__phone', 'name')
    print(res)  # <QuerySet [{'author_detail__phone': 110, 'name': 'jerry'}]>
    

    # 作者详情查作者------>反向查询-------->表名小写
    res = models.AuthorDetail.objects.filter(author__name='jerry').values('phone', 'author__name')
    print(res)  # <QuerySet [{'phone': 110, 'author__name': 'jerry'}]>

    # 2.查询书籍主键为1的出版社名称和书的名称
    # 书籍查出版社 ----->正向查询------->按字段
    res = models.Book.objects.filter(pk=1).values('publish__name', 'title')
    print(res)  # <QuerySet [{'publish__name': '人民出版社', 'title': '三国'}]>

    # 出版社查询书籍---------->反向查询----------->按表名小写
    res = models.Publish.objects.filter(book__pk=1).values('name', 'book__title')
    print(res)  # <QuerySet [{'name': '人民出版社', 'book__title': '三国'}]>

    # 3.查询书籍主键为1的作者姓名
    # 书籍查询作者------------->正向查询------------>按字段
    res = models.Book.objects.filter(pk=1).values('authors__name')
    print(res)

    # 作者查询书籍-------------->反向查询----------->按表名小写
    res = models.Author.objects.filter(book__pk=1).values('name')
    print(res)

    # # 查询书籍主键是1的作者的手机号
    # 书籍---->作者----->作者详情
    # book   正向   author  正向    author_detail
    res = models.Book.objects.filter(pk=2).values('authors__author_detail__phone')
    print(res)  # <QuerySet [{'authors__author_detail__phone': 110}]>
    

5. 聚合查询(aggregate)

sum max min avg count

# sql:
select sum(price) from table group by '';
 # 求书籍表中得书的平均价格
select avg(price) from book;
from django.db.models import Max, Min, Sum, Avg, Count

注意：以后在导模块的时候，只要是跟数据库相关的一般都在
django.db
django.db.models

# res = models.Book.objects.aggregate(Avg('price'))
res = models.Book.objects.aggregate(Max('price'), Min('price'), Sum('price'), Avg('price'), Count('id'))
    print(res)
    

6. 分组查询annotate

# 分组查询：group by
# 分组之后只能取到分组的依据，按照什么字段分组就只能取到这个字段的值，前提是严格模式

# 非严格模式就可以取到所有字段的值
# 如何设置严格模式
1. 使用命令修改
	查看sql_mode
    show variables like '%mode%';
    @@select sql_mode;
    
    # 设置严格模式
    set global sql_mode='ONLY_FULL_GROUP_BY'
2. 使用配置文件
	# 1.统计每一本书的作者个数
    # 按照书的id来分组
    # select * from table group by id
    # res = models.Book.objects.annotate() # annotate这个关键字它就是按照models后面的这个表分组
    # res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('author_num', 'title')
    res = models.Book.objects.annotate(author_num=Count('authors')).values('author_num', 'title')
    print(res)

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

    # 3.统计不止一个作者的图书
    # 先按照图书分组，求出每个图书的作者个数，包括了作者个数为0或者1的等，再次过滤做这个个数大于1的
    res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('author_num', 'title','id')
    print(res)

    # 4.查询每个作者出的书的总价格
    res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('sum_price', 'name')
    print(res)

7. F查询

	# 1. 查询卖出数大于库存数的书籍
	# sql： select * from table where maichu > kucun;
	'''F查询'''
    from django.db.models import F
    # 1. 查询卖出数大于库存数的书籍
    res = models.Book.objects.filter(maichu__gt=F('kucun')).all()
    print(res[0].title)

    # 2.将所有书籍的价格提升500块
    sql: update book set price = price+500 ;
    res = models.Book.objects.update(price=F('price')+500)

    # 3.将所有书的名称后面加上爆款两个字
    # 如果是更新的字符串不能够这么来写，专业的语法来写
    # res = models.Book.objects.update(title=F('title')+'爆款')

    from django.db.models.functions import Concat
    from django.db.models import Value
    res = models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    

8. Q 查询

# 适用于或者的关系查询
'''Q查询'''
    from django.db.models import Q

    # 1.查询卖出数大于100或者价格小于600的书籍
    # select *from table where maichu>100 or price < 600;
    # res = models.Book.objects.filter(maichu__gt=100, price__lt=600).all()  # and关系
    # res = models.Book.objects.filter(Q(maichu__gt=100), Q(price__lt=600)).all()  # and关系 <QuerySet []>
    
    # 或
    # res = models.Book.objects.filter(Q(maichu__gt=100)| Q(price__lt=600)).all()  # OR关系 <QuerySet []>
    # res = models.Book.objects.filter(~Q(maichu__gt=100)| Q(price__lt=600)).all()  # OR关系 <QuerySet []>
    
    # 非
    # res = models.Book.objects.filter(~Q(maichu__gt=100)| ~Q(price__lt=600)).all()  # OR关系 <QuerySet []>
    # res = models.Book.objects.filter(~(Q(maichu__gt=100)| Q(price__lt=600))).all()  # OR关系 <QuerySet []>
    # print(res)

    # Q的高阶用法
    q = Q()
    q.connector = 'or'
    # param = requests.GET.get("param")
    q.children.append(("maichu__gt", 600))
    # q.children.append((param +"__gt", 600))
    q.children.append(("price__lt", 100))
    res = models.Book.objects.filter(q)
    print(res)
    

三、django中如何开启事务

1.事务的四大特性(ACID)
	事务的四大特性通常简称为 ACID 特性，它们是数据库管理系统（DBMS）中用于确保事务正确执行和数据的一致性的基本属性。ACID 是由以下四个特性组成：
	1. **原子性（Atomicity）**：
	   原子性指的是事务是一个不可分割的单位，要么全部执行成功，要么全部执行失败，不存在中间状态。如果事务中的任何操作失败，整个事务会被回滚到初始状态，所有已经执行的操作都会撤销，保证数据库的一致性。
	2. **一致性（Consistency）**：
	   一致性指的是事务使数据库从一个一致性状态转变为另一个一致性状态。这意味着事务的执行不会破坏数据库中定义的完整性约束和规则，保持数据库数据的正确性。
	3. **隔离性（Isolation）**：
	   隔离性指的是并发执行的事务之间是相互隔离的，一个事务的执行不应该影响其他事务的执行。事务的隔离性确保了每个事务都感觉自己在独立地操作数据，避免了并发执行时的数据冲突和不一致问题。
	4. **持久性（Durability）**：
	   持久性指的是一旦事务被提交，其对数据库的修改是永久性的，不会因为系统崩溃或断电而丢失。已提交的事务对数据库的修改会被持久化存储，保证数据的持久性。
	ACID 特性确保了数据库中的事务正确执行，即使在并发访问的情况下也能维护数据的完整性和一致性。这些特性是数据库管理系统设计的基本原则，用于保证事务的可靠性和数据的可控性。

2.事务的隔离级别
	事务的隔离级别是数据库管理系统（DBMS）中用于控制并发事务之间相互影响的程度。不同的隔离级别提供了不同的数据一致性和并发性保证。常见的事务隔离级别包括：
	1. **读未提交（Read Uncommitted）**：
	   最低的隔离级别，在该级别下，事务可以读取其他事务尚未提交的数据。这可能导致脏读、不可重复读和幻读问题。
	2. **读已提交（Read Committed）**：
	   在该级别下，事务只能读取其他事务已经提交的数据。这可以避免脏读问题，但仍可能出现不可重复读和幻读问题。
	3. **可重复读（Repeatable Read）**：
	   在该级别下，事务在读取数据时会对其进行加锁，确保其他事务无法修改这些数据。这可以避免脏读和不可重复读问题，但仍可能出现幻读问题。
	4. **序列化（Serializable）**：
	   最高的隔离级别，在该级别下，事务会对读取的每一行数据都进行加锁，确保其他事务无法读取或修改这些数据。这可以避免脏读、不可重复读和幻读问题，但会降低并发性能。
	不同的数据库管理系统支持不同的隔离级别，并且默认隔离级别可能因数据库而异。在使用事务时，需要根据具体需求和业务逻辑来选择合适的隔离级别，以平衡数据的一致性和并发性。需要注意的是，较高的隔离级别可能会降低数据库的并发性能，因为它需要使用更多的锁来保证数据的一致性。

3.事务的几个关键
	1.开启事务
	start transaction;
	2. 提交事务
	commit;
	3. 回滚事务
	rollback;

4.事务的作用：保证安全，保证多个SQL语句要么同时执行成名， 要么同时失败
  '''Django中如何开启事务'''
    from django.db import transaction

    try:
        with transaction.atomic():
            # sql1
            # sql2
            ...
            models.Book.objects.filter(maichu__gt=100, price__lt=600).update()
            models.Book.objects.filter(maichu__gt=100, price__lt=600).create()
    except Exception as e:
        print(e)
        transaction.rollback()

文章来源地址https://www.toymoban.com/news/detail-631092.html

到了这里，关于外键字段的增删改查、多表查询(子查询和连表查询、正反向、聚合查询、 分组查询、 F与Q查询)、django中如何开启事务的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！