day68

## 1 多表操作之模型创建

```python
1 图书表：book,作者表：author，作者详情表：authordetail，出版社表：publish,(第三张中间表)
2 作者跟作者详情：是一对一，关联字段写在哪一方都可以
3 图书跟出版社：是一对多，一对多关系一旦确立，关联字段写在多的一方
4 图书和作者：是多对多，多对多的关系需要建立第三张表（可以自动生成）

5 models.py中把关系建立出来
from django.db import models
### django:  1.11.1     2.0.7
# 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'跟哪个字段做关联
    # publish=models.CharField(max_length=32)
    # publish=models.ForeignKey(to='Publish',to_field='id')
    # publish = models.ForeignKey(to='Publish')  # 如果不写to_field，则默认跟主键做关联
    publish = models.ForeignKey(to=Publish)     # 如果Publish表写在Book表前，这里就可以不需加引号

    # 自动创建出第三张表(以下会自动创建第三张表)
    # 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()
    # 一对一的本质是  ForeignKey+unique
    author_detail=models.OneToOneField(to='AuthorDetail',to_field='id')
    # 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()
    
 
6 同步到mysql数据库
   -配置文件
    -pymysql.install_as_mysqldb()
      -公司可以用过的mysqlclient
    -两条命令
    
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 一对多添加记录

```python
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=数字


# 总结：
   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 多对多添加记录，修改，删除

```python
1 自动创建的表，表模型就拿不到，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)
    # book.authors.add(2,3) # 新增作者,通过id新增
    # # 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 = models.Book.objects.get(name='西游记')
    # book.authors.add(2, 3)
    # book.authors.clear()

    # set 先清空，再add,前提是不存在的作者
    book.authors.set([4, ])
    
    # add ,remove，set clear
```



## 4 多对对多其他api

```python
# add ,remove，set clear
```



## 5 基于对象的跨表查询（正向反向）

```python
# 跨表查询有两种方式
   -基于对象的跨表查询：子查询
    -基于双下划线的跨表查询：关联查询，连表查询
    
    
# 基于对象的跨表查询
   -查询主键为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)

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


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

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


    # 多对多关系查询
    #梦梦梦所有作者的名字以及手机号
    # book=models.Book.objects.get(name='梦梦梦')
    # # 正向
    # authors=book.authors.all()
    # for author in authors:
    #     print(author.name)
    #     print(author.author_detail.phone)

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



## 6 基于双下划线的跨表查询 

```python
# 连表查询
   # 基于对象的跨表查询，先查对象，通过对象再去查另一个对象（正向：字段名，反向：表名小写/表名小写_set.all()）


    # 地址为山东的作者写的所有书
    # author_detail=models.AuthorDetail.objects.get(addr='山东')
    # author=author_detail.author
    # books=author.book_set.all()
    # print(books[0].name)

    # （作业）地址为山东的作者写的所有书的出版社名字


    ### 基于双下划线的跨表查之  一对多
    # 正向：字段名
    # 反向:表名小写
    # filter，values,values_list(写 __ 跨表)
    # 练习:  查询北京出版社出版过的所有书籍的名字与价格(一对多)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_publish` LEFT OUTER JOIN `app01_book` ON (`app01_publish`.`id` = `app01_book`.`publish_id`) WHERE `app01_publish`.`name` = '北京出版社' ;
    # res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    # print(res)
    #SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_book` INNER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_publish`.`name` = '北京出版社';

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


    ## 多对多
    # 练习: 查询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)
```



## 7 进阶连续跨表查询

```python
    # 连续跨表
    #查询北京出版社出版过的所有书籍的名字以及作者的姓名
    # 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)

    # SELECT `app01_book`.`name`, `app01_publish`.`name` FROM `app01_author` INNER JOIN `app01_authordetail` ON (`app01_author`.`author_detail_id` = `app01_authordetail`.`id`) LEFT OUTER JOIN `app01_book_authors` ON (`app01_author`.`id` = `app01_book_authors`.`author_id`) LEFT OUTER JOIN `app01_book` ON (`app01_book_authors`.`book_id` = `app01_book`.`id`) LEFT OUTER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_authordetail`.`phone` LIKE  '189%' ;
    res=models.Author.objects.filter(author_detail__phone__startswith='189').values('book__name','book__publish__name')
    print(res)
```

models.py

## 1 多表操作之模型创建

```python
1 图书表：book,作者表：author，作者详情表：authordetail，出版社表：publish,(第三张中间表)
2 作者跟作者详情：是一对一，关联字段写在哪一方都可以
3 图书跟出版社：是一对多，一对多关系一旦确立，关联字段写在多的一方
4 图书和作者：是多对多，多对多的关系需要建立第三张表（可以自动生成）

5 models.py中把关系建立出来
from django.db import models
### django:  1.11.1     2.0.7
# 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'跟哪个字段做关联
    # publish=models.CharField(max_length=32)
    # publish=models.ForeignKey(to='Publish',to_field='id')
    # publish = models.ForeignKey(to='Publish')  # 如果不写to_field，则默认跟主键做关联
    publish = models.ForeignKey(to=Publish)     # 如果Publish表写在Book表前，这里就可以不需加引号

    # 自动创建出第三张表(以下会自动创建第三张表)
    # 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()
    # 一对一的本质是  ForeignKey+unique
    author_detail=models.OneToOneField(to='AuthorDetail',to_field='id')
    # 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()
    
 
6 同步到mysql数据库
   -配置文件
    -pymysql.install_as_mysqldb()
      -公司可以用过的mysqlclient
    -两条命令
    
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 一对多添加记录

```python
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=数字


# 总结：
   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 多对多添加记录，修改，删除

```python
1 自动创建的表，表模型就拿不到，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)
    # book.authors.add(2,3) # 新增作者,通过id新增
    # # 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 = models.Book.objects.get(name='西游记')
    # book.authors.add(2, 3)
    # book.authors.clear()

    # set 先清空，再add,前提是不存在的作者
    book.authors.set([4, ])
    
    # add ,remove，set clear
```



## 4 多对对多其他api

```python
# add ,remove，set clear
```



## 5 基于对象的跨表查询（正向反向）

```python
# 跨表查询有两种方式
   -基于对象的跨表查询：子查询
    -基于双下划线的跨表查询：关联查询，连表查询
    
    
# 基于对象的跨表查询
   -查询主键为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)

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


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

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


    # 多对多关系查询
    #梦梦梦所有作者的名字以及手机号
    # book=models.Book.objects.get(name='梦梦梦')
    # # 正向
    # authors=book.authors.all()
    # for author in authors:
    #     print(author.name)
    #     print(author.author_detail.phone)

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



## 6 基于双下划线的跨表查询 

```python
# 连表查询
   # 基于对象的跨表查询，先查对象，通过对象再去查另一个对象（正向：字段名，反向：表名小写/表名小写_set.all()）


    # 地址为山东的作者写的所有书
    # author_detail=models.AuthorDetail.objects.get(addr='山东')
    # author=author_detail.author
    # books=author.book_set.all()
    # print(books[0].name)

    # （作业）地址为山东的作者写的所有书的出版社名字


    ### 基于双下划线的跨表查之  一对多
    # 正向：字段名
    # 反向:表名小写
    # filter，values,values_list(写 __ 跨表)
    # 练习:  查询北京出版社出版过的所有书籍的名字与价格(一对多)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_publish` LEFT OUTER JOIN `app01_book` ON (`app01_publish`.`id` = `app01_book`.`publish_id`) WHERE `app01_publish`.`name` = '北京出版社' ;
    # res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    # print(res)
    #SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_book` INNER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_publish`.`name` = '北京出版社';

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


    ## 多对多
    # 练习: 查询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)
```



## 7 进阶连续跨表查询

```python
    # 连续跨表
    #查询北京出版社出版过的所有书籍的名字以及作者的姓名
    # 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)

    # SELECT `app01_book`.`name`, `app01_publish`.`name` FROM `app01_author` INNER JOIN `app01_authordetail` ON (`app01_author`.`author_detail_id` = `app01_authordetail`.`id`) LEFT OUTER JOIN `app01_book_authors` ON (`app01_author`.`id` = `app01_book_authors`.`author_id`) LEFT OUTER JOIN `app01_book` ON (`app01_book_authors`.`book_id` = `app01_book`.`id`) LEFT OUTER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_authordetail`.`phone` LIKE  '189%' ;
    res=models.Author.objects.filter(author_detail__phone__startswith='189').values('book__name','book__publish__name')
    print(res)
```

s1.py

import os

if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'day68.settings')
    import django

    django.setup()

    from day68.day68.app01 import models

    # 一对多添加记录(出版社和图书)
    # 先新增出版社，再新增图书
    # 新增北京出版社
    # 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=数字

    # book=models.Book.objects.get(name='梦梦梦')
    # print(book.publish) # 出版社对象
    # print(book.publish.id) # 出版社对象id
    # print(book.publish_id) # 出版社id

    # 多对多，作者和书
    # 给西游记这本书新增两个作者lqz和egon
    # 去到西游记这本书
    # book=models.Book.objects.get(name='西游记')
    # 代指中间表book.authors
    # lqz=models.Author.objects.get(id=2)
    # egon=models.Author.objects.get(id=3)
    # book.authors.add(2,3) # 新增作者,通过id新增
    # # 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 = models.Book.objects.get(name='西游记')
    # # book.authors.add(2, 3)
    # # book.authors.clear()
    #
    # # set 先清空，再add,前提是不存在的作者
    # book.authors.set([4, ])
    #
    # # add ,remove，set clear

    # 基于对象的跨表查询（子查询）
    # 一对多
    # 查询主键为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)

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

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

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

    # 多对多关系查询
    # 梦梦梦所有作者的名字以及手机号
    # book=models.Book.objects.get(name='梦梦梦')
    # # 正向
    # authors=book.authors.all()
    # for author in authors:
    #     print(author.name)
    #     print(author.author_detail.phone)

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

    # 基于对象的跨表查询，先查对象，通过对象再去查另一个对象（正向：字段名，反向：表名小写/表名小写_set.all()）

    # 地址为山东的作者写的所有书
    # author_detail=models.AuthorDetail.objects.get(addr='山东')
    # author=author_detail.author
    # books=author.book_set.all()
    # print(books[0].name)

    # （作业）地址为山东的作者写的所有书的出版社名字

    ### 基于双下划线的跨表查之  一对多
    # 正向：字段名
    # 反向:表名小写
    # filter，values,values_list(写 __ 跨表)
    # 练习:  查询北京出版社出版过的所有书籍的名字与价格(一对多)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_publish` LEFT OUTER JOIN `app01_book` ON (`app01_publish`.`id` = `app01_book`.`publish_id`) WHERE `app01_publish`.`name` = '北京出版社' ;
    # res=models.Publish.objects.filter(name='北京出版社').values('book__name','book__price')
    # print(res)
    # SELECT `app01_book`.`name`, `app01_book`.`price` FROM `app01_book` INNER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_publish`.`name` = '北京出版社';

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

    ## 多对多
    # 练习: 查询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)

    # 连续跨表
    # 查询北京出版社出版过的所有书籍的名字以及作者的姓名
    # 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)

    # SELECT `app01_book`.`name`, `app01_publish`.`name` FROM `app01_author` INNER JOIN `app01_authordetail` ON (`app01_author`.`author_detail_id` = `app01_authordetail`.`id`) LEFT OUTER JOIN `app01_book_authors` ON (`app01_author`.`id` = `app01_book_authors`.`author_id`) LEFT OUTER JOIN `app01_book` ON (`app01_book_authors`.`book_id` = `app01_book`.`id`) LEFT OUTER JOIN `app01_publish` ON (`app01_book`.`publish_id` = `app01_publish`.`id`) WHERE `app01_authordetail`.`phone` LIKE  '189%' ;
    res = models.Author.objects.filter(author_detail__phone__startswith='189').values('book__name',
                                                                                      'book__publish__name')
    print(res)