python-django_多表操作_模型创建_一对多-多对多增删改查_多对多API_对象&双下划线的跨表查询_连续跨表查询

django 多表操作

1. 创建模型

1. 实例分析

# 示例
作者模型
	一个作者有姓名和年龄

作者详细模型
	把作者的详情放到详情表，包含生日，手机号，家庭住址等信息
    作者详情模型和作者模型之间是一对一的关系（one-to-one）

出版商模型
	出版商有名称，所在城市以及email

书籍模型
	书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many)
    一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)
 
# 总结
1. 需要创建的数据表
    图书表: book
    作者表: author
    作者详情表: authordetail
    出版社表: publish (第三张中间表)

2. 作者跟作者详情
    是一对一，关联字段写在哪一方都可以
    
3. 图书跟出版社
	是一对多，一对多关系一旦确立，关联字段写在多的一方
    
4. 图书和作者
	是多对多，多对多的关系需要建立第三张表（可以自动生成） 
    
5. 在models.py中把关系建立出来 

6. 同步到mysql数据库
	-配置文件 settings.py
    	DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 'database name',
            'HOST': '127.0.0.1',
            'PORT': 3306,
            'USER': 'root',
            'PASSWORD': '',
            'CHARSET': 'utf8'
            }
        }
    -在app的__init__.py中写
        import pymysql
    	pymysql.install_as_MySQLdb() 
    -数据库迁移命令
    	python manage.py makemigrations
        python manage.py migrate
    
7. 注意: 2.x版本的django
	-外键字段必须加参数：on_delete
    -1.x版本不需要，默认就是级联删除
    -假设:
    	删除出版社，该出版社出版的所有图书也都删除
        	on_delete=models.CASCADE
        删除出版社，该出版社出版的图书不删除，设置为空
        	on_delete=models.SET_NULL,null=True
        删除出版社，该出版社出版的图书不删除，设置为默认
        	on_delete=models.SET_DEFAULT,default=0

# 注意
	关联字段与外键约束没有必然的联系（建关联字段是为了进行查询，建约束是为了不出现脏数据）

2. 原生sql语句

# 在MySQL中创建表
    Publish  
    Book
    Author
    AuthorDetail
    Book2Author

# Publish 
CREATE TABLE publish(
                id INT PRIMARY KEY auto_increment ,
                name VARCHAR (20)
              );

# Book
CREATE TABLE book(
                id INT PRIMARY KEY auto_increment ,
                title VARCHAR (20),
                price DECIMAL (8,2),
                pub_date DATE ,
                publish_id INT ,
                FOREIGN KEY (publish_id) REFERENCES publish(id)
              );

# AuthorDetail
CREATE TABLE authordetail(
                id INT PRIMARY KEY auto_increment ,
                tel VARCHAR (20)
              );

# Author
CREATE TABLE author(
                id INT PRIMARY KEY auto_increment ,
                name VARCHAR (20),
                age INT,
                authordetail_id INT UNIQUE ,
                FOREIGN KEY (authordetail_id) REFERENCES authordetail(id)
              );

# Book2Author
CREATE  TABLE book2author(
       id INT PRIMARY KEY auto_increment ,
       book_id INT ,
       author_id INT ,
       FOREIGN KEY (book_id) REFERENCES book(id),
       FOREIGN KEY (author_id) REFERENCES author(id)
)

3. models.py

from django.db import models

# Create your models here.

class Publish(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    phone = models.CharField(max_length=64)
    email = models.EmailField()

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=6, decimal_places=2)
    publish_date = models.DateTimeField(auto_now_add=True)

    # to='Publish'跟Publish表做关联（ForeignKey，一对多）
    # to_field='id'跟id字段做关联
    # publish=models.CharField(max_length=32)
    # publish=models.ForeignKey(to='Publish',to_field='id')
    # publish = models.ForeignKey(to='Publish')  # 不写，默认跟主键做关联
    publish = models.ForeignKey(to=Publish)  # 不写，默认跟主键做关联

    # 自动创建出第三张表(这句话会自动创建第三章表)
    # 在数据库中不存在authors字段，没有to_field
    # 默认情况：第三张表有id字段，当前Book表的id和Author表的id字段
    authors=models.ManyToManyField(to='Author')

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.SmallIntegerField()
    author_detail=models.OneToOneField(to='AuthorDetail',to_field='id')
    # 一对一的本质是 ForeignKey+unique 上下同等作用
    # author_detail=models.ForeignKey(to='AuthorDetail',to_field='id',unique=True)

class AuthorDetail(models.Model):
    id = models.AutoField(primary_key=True)
    sex = models.SmallIntegerField()
    addr = models.CharField(max_length=64)
    phone = models.BigIntegerField()  

2. 一对多添加记录

# 先新增出版社，再新增图书

# 新增北京出版社
publish=models.Publish.objects.create(name='北京出版社',addr='北京',phone='0536-12345678',email='邮箱地址')

# 新增金瓶梅
book=models.Book.objects.create(name='金瓶梅',price='23.45',publish=publish) 
# publish=对象

# 新增西游记
book=models.Book.objects.create(name='西游记',price='23.55',publish_id=1) 
# publish_id=数字

# 新增西游记
book=models.Book.objects.create(name='西游记',price='23.55',publish_id=publish.id)
# publish_id=数字

# 通过书籍查询出版社及id
book=models.Book.objects.get(name='金瓶梅')
print(book.publish)    # 出版社对象
print(book.publish.id) # 出版社对象id
print(book.publish_id) # 出版社id

# 总结：
	1. email可以不传email，本质就是varchar（admin中会判断）
    2. 新增图书：
            -publish=publish
            -publish_id=publish.id
    3. 写在表模型中的publish字段，到数据库中会变成publish_id(ForeignKey)
    4. 查到book对象以后
            -book.publish     对象
            -book.publish_id  id号，数字

3. 多对多记录的增删改查

# 自动创建的表，表模型就拿不到，book.authors代指表模型

# 多对多，作者和书
# 给西游记这本书新增两个作者lqz和egon
# 去到西游记这本书
book=models.Book.objects.get(name='西游记')

# 代指中间表book.authors
lqz=models.Author.objects.get(id=2)
egon=models.Author.objects.get(id=3)
# 新增作者,通过id新增
book.authors.add(2,3) 
# 新增作者,通过对象新增
book.authors.add(lqz,egon) 
# 新增作者,通过对象新增
book.authors.add(2,egon)   

# 西游记删除一个作者
book = models.Book.objects.get(name='西游记')
book.authors.remove(2)
egon = models.Author.objects.get(id=3)
book.authors.remove(egon)

# clear 清空所有作者
book.authors.add(2, 3)
book.authors.clear()

# set 先清空，再add,前提是不存在的作者
'''多对多中set是清除参数中没有的，新增参数中新增加的，保留原来就有的'''
book.authors.set([4, ])

# 多对多关系常用API
	1. add  2. remove  3. clear  4. set
    
    1. 将某个特定的对象添加到被关联对象集合中
    	book.authors.add(2,3) 
    
    2. 将某个特定的对象从被关联对象集合中去除 
        book_obj.authors.remove(2,3)    =>   book_obj.authors.remove(*[2,3])
        
    3. 清空被关联对象集合    
        book_obj.authors.clear()  
        
    4. 先清空再设置　    
        book_obj.authors.set([4,5])         

4. 跨表查询

跨表查询有两种方式

​ 1. 基于对象的跨表查询：子查询

​ 2. 基于双下划线的跨表查询：关联查询，联表查询

1. 基于对象的跨表查询

1. 一对多
    # 查询主键为1的书籍的出版社所在的城市
    book=models.Book.objects.get(id=1)   # 第一次查询
    book=models.Book.objects.filter(id=1).first()
    publish=book.publish   # 内部又执行了一次查询，根据publish_id查询publish
    print(publish.addr)

    # 北京出版社出版的所有书籍
    publish=models.Publish.objects.get(name='北京出版社')  # 第一次查询了出版社
    books=publish.book_set.all()    # 表名小写_set  第二次，根据出版社id，查询所有书
    print(books)

    # 正向查询：（按字段：publish）
    	book表内有publish字段 直接对象.字段名
    # 反向查询：（按表名：book_set）
    	publish表内没有book字段，出版社对象.Book小写_set.all()

2. 一对一
    # 查询所有住址在山东的作者的姓名
    # 反向查询：author_detail没有author字段，author_detail.表名小写 (按表名：author)
    author_detail=models.AuthorDetail.objects.filter(addr__contains='山东').first()
    print(author_detail.author.name)

    # 查询egon作者的地址
    # 正向查询 (按字段：author_Detail)
    author=models.Author.objects.get(name='egon')
    print(author.author_detail.addr)


3. 多对多 (Author 与 Book)
    # 金瓶梅所有作者的名字以及手机号
    book=models.Book.objects.get(name='金瓶梅')
    
    # 正向 (按字段：authors)
    authors=book.authors.all()
    for author in authors:
        print(author.name)
        print(author.author_detail.phone)

    # 反向 (按表名：book_set)
    # 查询egon出过的所有书籍的名字
    egon=models.Author.objects.get(name='egon')
    books=egon.book_set.all()
    for book in books:
        print(book.name)  

2. 基于双下划线的跨表查询

# 简介	
    Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系
    要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的model为止

# 查询方式 (先查对象，通过对象再去查另一个对象)
    1. 正向查询按字段
    2. 反向查询按表名小写用来告诉ORM引擎join哪张表
   （正向：字段名，反向：表名小写/表名小写_set.all()）
    
# 示例
	# 地址为山东的作者写的所有书
    author_detail=models.AuthorDetail.objects.get(addr='山东')
    author=author_detail.author
    books=author.book_set.all()
    print(books[0].name)
    
1. 一对多
 	# 正向：字段名
    # 反向: 表名小写
    # filter，values,values_list(写 __ 跨表)
    # 练习:  查询北京出版社出版过的所有书籍的名字与价格(一对多)
    res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    print(res)

    res=models.Book.objects.filter(publish__name='北京出版社').values('name','price')
    print(res)

2. 多对多
    # 练习: 查询egon出过的所有书籍的名字,价格(多对多)
    # 反向
    res=models.Author.objects.filter(name='egon').values('book__name','book__price')
    print(res)

    # 正向
    res=models.Book.objects.filter(authors__name='egon').values('name','price')
    print(res)

    # 查询egon的手机号
    res=models.Author.objects.filter(name='egon').values('author_detail__phone')
    print(res)
    res=models.AuthorDetail.objects.filter(author__name='egon').values('phone')
    print(res)     

3. 连续跨表查询

# 查询北京出版社出版过的所有书籍的名字以及作者的姓名
res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__authors__name')
print(res)

res=models.Book.objects.filter(publish__name='北京出版社').values('name','authors__name')
print(res)

res=models.Author.objects.filter(book__publish__name='北京出版社').values('book__name','name')
print(res)

# 手机号以189开头的作者出版过的所有书籍名称以及出版社名称  
res=models.AuthorDetail.objects.filter(phone__startswith='189').values('author__book__name','author__book__publish__name')
print(res)

res=models.Author.objects.filter(author_detail__phone__startswith='189').values('book__name','book__publish__name')
print(res)

5. 扩展

1. 安装模块相关

# pip3 install django    
	本质是去https://pypi.python.org/simple，搜这个模块
    会根据你的平台下载在一个安装包（windows平台是whl）,下载完，再安装

# pip安装失败的情况
	1. 我们可以绕过它，下载.whl文件自己装 https://www.lfd.uci.edu/~gohlke/pythonlibs/#opencv
	2. pip3 install django.whl   

# 官方库没有上传到pypi，官方也不给制作whl文件 如何安装包（setup.py）
    1. 到达安装目录，setup.py所在的目录
    2. python setup.py build
    3. python setup.py install

# 配置清华源 豆瓣源的本质
	豆瓣源会把pypi包拉到自己的服务器上，你需要使用的包，去它的服务器上下，所以速度快

2. 外键关系

1. 关联字段与外键约束没有必然的联系（建管理字段是为了进行查询，建约束是为了不出现脏数据）

2. 默认情况，关联关系建好以后，外键约束就自然建立了

3. 实际工作中，外键约束一般不建(影响效率）)，都是人为约束(代码约束) (取消外键约束db_constraint=False)
    
4. 表模型和数据库表的对应，不要直接修改表（这是可以的，但是不建议），要修改表模型，同步到表中