第十二章 ORM的多表操作

# test.py
import os, django
os.environ.setdefault(‘DJANGO_SETTINGS_MODULE‘, ‘项目名.settings‘)
django.setup()
from app01 import models

# models.py
from django.db import models
# 出版社和书的一对多关系
class Publisher(models.Model):
    name = models.CharField(max_length=32)
    def __str__(self):
        return ‘{}‘.format(self.name)
# 书籍信息 
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=6, decimal_places=2)
    pub = models.ForeignKey(‘Publisher‘, on_delete=models.CASCADE)
    def __str__(self):
        return ‘{}‘.format(self.title)
# 作者信息
class Author(models.Model):
    name = models.CharField(max_length=32)
    books = models.ManyToManyField(‘Book‘, related_name=‘authors‘, related_query_name=‘xxx‘)
    def __str__(self):
        return ‘{}‘.format(self.name)

author = models.Author.objects.get(pk=1)
# 关系管理对象，从1向多的方向拿都是关系管理对象
author.books
# 所有书籍
models.Author.objects.get(pk=1).books.all()

# book对象
book = models.Book.objects.filter(title=‘python之旅‘).first()
# 关系管理对象，不指定related_name参数
book.author_set
# 获取所有作者
book.author_set.all()
# 指定related_name=‘authors‘
book.authors.all()

# 不指定related_name/ related_query_name
author = models.Author.objects.filter(books__title=‘python之旅‘)
print(author)
# 不指定related_name/ related_query_name
book = models.Book.objects.filter(author__name=‘echo‘)
print(book)
# 指定related_name和related_query_name优先使用related_query_name=‘xxx‘
book = models.Book.objects.filter(xxx__name=‘echo‘)
print(book)

# 关系管理对象
author = models.Author.objects.get(pk=1)
book = models.Book.objects.get(pk=1)
publisher = models.Publisher.objects.get(pk=1)

books = author.books.all()

# 会覆盖历史数据
ret = author.books.set([‘书籍的id1‘,‘书籍的id2‘...])
# 返回值ret为None
# 可以写对象
author.books.set(modles.Book.objects.filter(pk__in[1,2,3]))

# 添加数据，已有数据不会新增
author.books.add(‘书籍的id1‘,‘书籍的id2‘...)
# 添加对象，* 表示打散
author.books.add(*models.Book.objects.filter(pk__in=[‘书籍的id1‘,‘书籍的id2‘...]))

# 删除数据
author.books.remove(‘书籍的id1‘,‘书籍的id2‘...)
# 删除对象
author.books.remove(*models.Book.objects.filter(pk__in=[‘书籍的id1‘,‘书籍的id2‘...]))

# 清除author对象的所有的多对多关系
author.books.clear()

# 创建书的信息,并添加关联信息
obj = author.books.create(title=‘python‘, pub_id=1)
# 通过书创建作者
book = models.objects.get(pk=1)
obj = book.authors.create(name=‘diane‘)

# 不指定related_name和related_query_name时，使用 类名_set获取关系管理对象
pub = models.Publisher.objects.get(pk=1)
pub.book_set.all()

publisher = models.Publisher.objects.get(pk=1)
# 不能使用id ，只能使用对象
publisher.books.set(models.Book.bojects.fitler(pk__in[4,5]))

publisher.books.add(*models.Book.bojects.fitler(pk__in[4,5]))

# remove/clear, 外键必须设置成 null=True参数
publisher.books.remove(*models.Book.bojects.fitler(pk__in[4,5]))

publisher.books.clear()

models.Publisher.objects.get(pk=1).books.create(title=‘xxx‘, price=10)

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

ret = models.Book.objects.all().aggregate(Max(‘price‘))
# 省略all()也会生效
ret = models.Book.objects.aggregate(Max(‘price‘))
# dict 类型，可以
print(ret)
# 如果给聚合结果重命名，注意位置和关键字传参的原则
ret = models.Book.objects.all().aggregate(Avg(‘price‘),max=Max(‘price‘))

# 返回值为字典，给终止子句
ret = models.Book.objects.filter(pk_gt=3).aggregate(Avg(‘price‘),max=Max(‘price‘))

# .all()可以省略不写
ret = models.Book.objects[.all()].annotate(count=Count(‘author‘))
for i in ret:
    print(i.count)

# 以出版社的ID进行分组
ret = models.Publisher.objects.annotate(Min(‘book__price‘).values()
for i in ret:
    print(i)

ret = models.Book.objects.values(‘pub/pub_id/pub__name‘).annotate(Min(‘price‘))
for i in ret:
  print(i)
# 错误示范,如果values添加额外字段，则分组条件也会添加这个字段
ret = models.Book.objects.values(‘pub/pub_id/pub__name‘).annotate(Min(‘price‘)).values()
# 正确
ret = models.Book.objects.values(‘pub/pub_id/pub__name‘).annotate(min=Min(‘price‘)).values(‘pub_id‘, min)

# 统计每本书的作者个数
obj = models.Book.objects.values(‘title‘).annotate(Count(‘xxx__name‘))
for i in obj:
    print(i)
    
    
# 统计出每个出版社买的最便宜的书的价格
obj = models.Publisher.objects.values(‘name‘).annotate(Min(‘xxx__price‘))
for i in obj:
  print(i)

# 统计不止一个作者的图书，比较两种分组方式的区别
ret=models.Book.objects.annotate(count=Count(‘author__id‘)).filter(count__gt=1)
print(ret)
obj=models.Book.objects.values(‘title‘).annotate(count=Count(‘xxx__id‘)).filter(count__gt=1)
print(obj)

# 根据一本图书作者数量的多少对查询集 QuerySet进行排序
obj = models.Author.objects.annotate(count=Count(‘books__id‘)).order_by(‘count‘)
print(obj)

# 查询各个作者书的总价格
ret = models.Author.ojects.annotate(Sum(‘books__price‘)).values()
print(ret)

ret = models.Book.objects.filter(price__gt=100)
print(ret)

# F,动态获取字段值
from django.db.models import F
ret = models.Book.objects.filter(sale__gt=F(‘inventory‘))

# 更改一个对象，会更新所有的对象
obj = models.Book.objects.get(pk=1)
obj.sale = 100
obj.save()

# 批量更新，queryset对象支持update， 只更新sale字段
obj = models.Book.objects.filter(pk=1).update(sale=100)
# 直接更新到数据库
models.Book.objects.filter(pk=1).update(sale=F(‘sale‘)*2+10)

from django.db.models import Q
ret = models.Book.objects.filter(Q(pk__gt=3)|Q(pk__lt=2))
print(ret)
# q条件的组合，逻辑判断
models.Book.objects.filter(~Q(Q(pk__gt=3)|Q(pk__lt=2))&Q(price__gt=50))

from django.db import transaction
try:
  with transaction.atomic():
    # orm操作为事务操作
      models.Publiser.objects.create(name=‘xxx‘)
      int(‘sss‘)
      models.Publiser.objects.create(name=‘xxx2‘)
except Exception as e:
   print(e)

LOGGING = {
    ‘version‘: 1,
    ‘disable_existing_loggers‘: False,
    ‘handlers‘: {
        ‘console‘:{
            ‘level‘:‘DEBUG‘,
            ‘class‘:‘logging.StreamHandler‘,
        },
    },
    ‘loggers‘: {
        ‘django.db.backends‘: {
            ‘handlers‘: [‘console‘],
            ‘propagate‘: True,
            ‘level‘:‘DEBUG‘,
        },
    }
}

from django.db import connection
cursor=connection.cursor()
# 插入操作
cursor.execute("insert into hello_author(name) values(‘钱钟书‘)")
# 更新操作
cursor.execute("update hello_author set name=‘abc‘ where name=‘bcd‘")
# 删除操作
cursor.execute("delete from hello_author where name=‘abc‘")
# 查询操作
cursor.execute("select * from hello_author")
raw=cursor.fetchone()  # 返回结果
cursor.fetchall()      # 读取所有