Django-多表操作

一、创建对象模型

表和表之间的关系

　　　　一对一、多对一、多对多　，用book表和publish表自己来想想关系，想想里面的操作，加外键约束和不加外键约束的区别，一对一的外键约束是在一对多的约束上加上唯一约束。

　　实例：我们来假定下面这些概念，字段和关系

　　作者模型：一个作者有姓名和年龄。

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

　　出版社模型：出版社有名称，所在城市。

　　书籍模型： 书籍有书名和价钱，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);

　　　　　　　一本书只应该由一个出版社出版，所以出版社和书籍是一对多关联关系(one-to-many)。

模型建立：

# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # 与作者信息表建立一对一的关系
    authorDetail = models.OneToOneField(to="AuthorDetail")

# 作者的详细信息
class AuthorDetail(models.Model):
    birthday = models.DateField()
    telephone = models.BigIntegerField()
    addr = models.CharField(max_length=64)


# 出版社
class Publish(models.Model):
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)

# 书籍
class Book(models.Model):
    title = models.CharField( max_length=32)
    price=models.DecimalField(max_digits=5,decimal_places=2)
    # 与出版社建立一对多的关系
    publish = models.ForeignKey(to="Publish")
    # 与作者建立多对多的关系
    author = models.ManyToManyField(to="Author")

from django.db import models

# Create your models here.


class Author(models.Model): #比较常用的信息放到这个表里面
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()

    # 与AuthorDetail建立一对一的关系，一对一的这个关系字段写在两个表的任意一个表里面都可以
    authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) #就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为authorDetail_id

class AuthorDetail(models.Model):#不常用的放到这个表里面

    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)

class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()

#多对多的表关系，我们学mysql的时候是怎么建立的，是不是手动创建一个第三张表，然后写上两个字段，每个字段外键关联到另外两张多对多关系的表，orm的manytomany自动帮我们创建第三张表，两种方式建立关系都可以，以后的学习我们暂时用orm自动创建的第三张表，因为手动创建的第三张表我们进行orm操作的时候，很多关于多对多关系的表之间的orm语句方法无法使用
#如果你想删除某张表，你只需要将这个表注销掉，然后执行那两个数据库同步指令就可以了，自动就删除了。
class Book(models.Model):

    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)

    # 与Publish建立一对多的关系,外键字段建立在多的一方，字段publish如果是外键字段，那么它自动是int类型
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey里面可以加很多的参数，都是需要咱们学习的，慢慢来，to指向表，to_field指向你关联的字段，不写这个，默认会自动关联主键字段，on_delete级联删除
　　 字段名称不需要写成publish_id，orm在翻译foreignkey的时候会自动给你这个字段拼上一个_id,这个字段名称在数据库里面就自动变成了publish_id
    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且注意一点，你查看book表的时候，你看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个book类里面有authors这个字段属性
    authors=models.ManyToManyField(to='Author',) #注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面

写入数据顺序：

1、先将作者详细信息数据写入数据库

authorDetail表：

2、在写入作者信息并关联authorDetail表(一对一)：

author表:

3、写入出版社数据(因为书籍表需要关联出版社,所以先要写入出版社数据):

publish表:

4、写入书籍数据(并与出版社建立多对一的关系):

 

5、因为我们在创建book表时与author表建立了多对多的关系:

author = models.ManyToManyField(to="Author")

orm会自动帮我们创建第三张表:
表名:应用名_book_author
字段名:book_id   author_id

二、数据的增删改

多对一：

from app01 import models
def index(request):
    # 西瓜出版社出版了 天龙八部和倚天屠龙记这两本书
    # 分别用两种方法添加数据

    # 方法一   拿到出版社的model对象,作为值传给了publish,其实就是将publish字段自动变成了publish_id,然后将publish_obj取出来的结果赋给了变形后的publish也就是publish_id

    publish_obj = models.Publish.objects.get(name="西瓜出版社")
    book_obj = models.Book.objects.create(title="天龙八部",price=700,publish=publish_obj)

    # 方法二   直接指定出版社id
    book_obj = models.Book.objects.create(title="倚天屠龙记",price=700,publish_id=2)

    return HttpResponse("ok")

#删除记录和更新记录和单表都是一样的
models.Book.objects.filter(id=1).delete()
models.Book.objects.filter(id=2).update(price=998)

一对一：

models.Author.objects.create(name="超",age=30,authorDetail_id=5)

注意：一对一添加的authorDetail_id,在author中是唯一的,

 

#更新和删除
models.Author.objects.filter(id=3).update(age=66)
models.Author.objects.filter(id=3).delete()

多对多：

方式一：

# 绑定多对多关系,即向关系表book_author中添加纪录,给id=8的书添加两个作者,下面的语法就是告诉orm给第三张表添加两条数据
book_obj = models.Book.objects.get(id=8)
# 列表中的是作者的id
book_obj.author.add(*[1,3])

方式二：

# 当前生成的书籍对象
 book_obj = models.Book.objects.get(id=3)

# 为书籍绑定的做作者对象,在Author表中主键为3/4的纪录，注意取的是author的model对象
 chao = models.Author.objects.filter(id=3).first()
 eva = models.Author.objects.filter(id=4).first()

# 将某些特定的 model 对象添加到被关联对象集合中
 book_obj.author.add(chao,eva)
# 其实orm就是先通过book_obj的authors属性找到第三张表，然后将book_obj的id值和两个作者对象的id值组合成两条记录添加到第三张表里面去

其他操作：

 # 当前生成的书籍对象,要给哪个书添加作者就查找哪个书
    book_obj = models.Book.objects.get(id=3)
    book_obj.author.remove(*[3,4])      # 删除不存在的关联也不会报错
    book_obj.authors.clear()            # 全部清除
    book_obj.author.set(['3','6'])      # 清空所有的book_id为3的第三张表里面的所有记录,再重新写上book_id为3的对应的author_id为3/6的关系记录

三、基于对象的跨表查询

正反查询：关联属性字段所在的表查询被关联表的记录就是正向查询，反之就是反向查询

一对多：

    # 正向查询, 查询book id为2的书籍的出版社所在的城市
    book_obj = models.Book.objects.get(id=2)
    # 直接通过点类属性找到第三张表 在点第三张表里的字段名
    ret = book_obj.publish.city
    print(ret)      # 沙河

    # 反向查询  红浪漫出版社出版过哪些书籍
    publish_obj =models.Publish.objects.filter(name="红浪漫出版社").first()
    # 小写的类名_set
    book_list = publish_obj.book_set.all() # 得到queryset对象
    print(book_list)                       # <QuerySet [<Book: c>, <Book: 倚天屠龙记>]>

一对一：

# 正向查询 wusir是哪个城市的,
    author_obj = models.Author.objects.get(name="wusir")
    ad = author_obj.authorDetail.addr
    print(ad)               # 沙河

# 反向查询 看看谁在于辛庄
    addr = models.AuthorDetail.objects.get(addr="于辛庄")
    # 一对一查询直接小写类名.属性
    name = addr.author.name
    print(name)

多对多：

# 正向查询的: python的作者是谁
    book_obj = models.Book.objects.filter(title="go")[0]
    author_obj = book_obj.author.all()
    for i in author_obj:
        print(i.name)

# 反向查询: wusir写了哪些书
    author_obj = models.Author.objects.filter(name="wusir")[0]
    book_list = author_obj.book_set.all()
    for i in book_list:
        print(i.title)

 小结：

# 正向查询都是通过点关系字段来查找到另一个表的
# 反向查询是通过点小写的类名_set,只有一对一才不用set,因为一对一查询只有一条数据
    
# 一对多和多对多          正向查询   对象.关系字段.all()或字段名
#                       反向查询   对象.小写类名_set.all()

# 一对一                正向查询   对象.关系字段.字段名
#                      反向查询   对象.关系字段.字段名

四、基于双下划线的跨表查询

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

'''
    基于双下划线的查询就一句话：正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表,一对一、一对多、多对多都是一个写法，注意，我们写orm查询的时候，哪个表在前哪个表在后都没问题，因为走的是join连表操作。
'''

一对一

# 一对一
    # 查看alex地址在哪
    # 正向查询
    ret = models.Author.objects.filter(name="alex").values("authorDetail__addr")      # <QuerySet [{'authorDetail__addr': '汇德商厦'}]>

    # 反向查询
    res = models.AuthorDetail.objects.filter(author__id=1).values("addr")
    # <QuerySet [{'addr': '汇德商厦'}]>
    print(ret)
    print(res)

一对多

 # 多对一
    # 查看python是由哪个出版社出版的
    # 正向查询
    ret = models.Book.objects.filter(title="python").values("publish__name")  
    # <QuerySet [{'publish__name': '小苹果出版社'}]>
    print(ret)
    
    # 反向查询
    res = models.Publish.objects.filter(book__title="python").values("name") 
    # <QuerySet [{'name': '小苹果出版社'}]>
    print(res)
 # -----------------------------------------------------------------------------
 # 一对多
    # 老男孩出版社出了哪些书
    # 反向查询
    ret = models.Publish.objects.filter(name="老男孩出版社").values("book__title")        # <QuerySet [{'book__title': 'linux'}, {'book__title': 'go'}, {'book__title': 'java'}, {'book__title': '唐伯虎点秋香'}]>
    print(ret)
    
    # 正向查询
    res = models.Book.objects.filter(publish__name="老男孩出版社").values("title")      # <QuerySet [{'title': 'linux'}, {'title': 'go'}, {'title': 'java'}, {'title': '唐伯虎点秋香'}]>
    
    #通过__告诉orm将book表和publish表进行join，然后找到所有记录中publish.name='老男孩出版社'的记录（注意publish是属性名称），然后select book.title的字段值
    print(res)

多对多

# 多对多
    # wusir写了哪些书
    # 反向查询
    ret = models.Author.objects.filter(name="wusir").values("book__title")
    # <QuerySet [{'book__title': 'linux'}, {'book__title': 'c'}, {'book__title': 'java'}]>
    print(ret)
    
    # 正向查询
    res = models.Book.objects.filter(author__name="wusir").values("title")
    # <QuerySet [{'title': 'linux'}, {'title': 'c'}, {'title': 'java'}]>
    print(res)

 # 正向查询
    res = models.Book.objects.filter(publish__name="老男孩出版社").values("title") 	 
 # <QuerySet [{'title': 'linux'}, {'title': 'go'}, {'title': 'java'}, {'title': '唐伯虎点秋香'}]>
    
    # 通过__告诉orm将book表和publish表进行join，然后找到所有记录中publish.name='老男孩出版社'的记录（注意publish是属性名称），然后select book.title的字段值
    print(res)

双下划线跨表查询：

比如书和作者这种多对多的关系:

`wusir写了哪些书`

正向查询:

`res = models.Book.objects.filter(author__name="wusir").values("title")`

​	筛选条件：直接通过属性author__告诉orm将book表与author表连接到一起,然后找到所有记录中author.name="wusir"的记录, 最后查询select book.title的字段得到最后结果;
反向查找:

`ret = models.Author.objects.filter(name="wusir").values("book__title")`

​	筛选条件：先通过条件进行筛选,然后通过小写的表名__，将Author表与book表连接,最后通过连接后的表取book.title;正向查询按字段,反向查询按小写表名

连续跨表

# 连续跨表
    # 查询红浪漫出版社出版过的所有书籍的名字以及作者的姓名
    # 反向查询
    ret = models.Publish.objects.filter(name="红浪漫出版社").values("book__title","book__author__name")
    
    # <QuerySet [{'book__title': 'c', 'book__author__name': 'wusir'},
    # {'book__title': '倚天屠龙记', 'book__author__name': 'alex'},
    # {'book__title': '倚天屠龙记', 'book__author__name': 'chao'}]>
    # 倚天屠龙记是alex和chao一起写的
    print(ret)

    # 正向查询
    ret = models.Book.objects.filter(publish__name="红浪漫出版社").values("title","author__name")
    
    # <QuerySet [{'title': 'c', 'author__name': 'wusir'}, ]
    # {'title': '倚天屠龙记', 'author__name': 'alex'},
    # {'title': '倚天屠龙记', 'author__name': 'chao'}]>
    print(ret)

所有查询都要看给出的条件:

作者和书的关系|多对多

两张表book和author
关系字段在book表中,关联着author表

条件：chao写了哪些书？
分析：
如果我们从book表中开始查找：
因为chao不在Book表中,所以我们需要先连表后才能取到title,这里的author是存在Book表中属性,不是类名
res = models.Book.objects.filter(author__name="chao").values("title")

related_name

反向查询时，如果定义了related_name ，则用related_name替换 表名，例如：

publish = ForeignKey(Blog, related_name='bookList')

五、聚合查询、分组查询、F查询和Q查询

聚合

aggregate(*args, **kwargs)

# 计算所有图书的平均价格
    >>> from django.db.models import Avg
    >>> Book.objects.all().aggregate(Avg('price')) #或者给它起名字：aggretate(a=Avg('price'))
    {'price__avg': 34.35}

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}

如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

>>> from django.db.models import Avg, Max, Min
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))  #count('id'),count(1)也可以统计个数,Book.objects.all().aggregete和Book.objects.aggregate()，都可以
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

F查询和Q查询

导入模块：

from django.db.models import F,Q

F查询

在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？我们在book表里面加上两个字段：评论数：commentNum，收藏数：KeepNum

　　Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。

# 查询评论数大于收藏数的书籍
 
   from django.db.models import F
   Book.objects.filter(commentNum__lt=F('keepNum'))

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。

# 查询评论数大于收藏数2倍的书籍
    Book.objects.filter(commentNum__lt=F('keepNum')*2)

修改操作也可以使用F函数,比如将每一本书的价格提高30元：

Book.objects.all().update(price=F("price")+30)　

# 将价钱大于50的价格减去20
models.Book.objects.filter(price__gt=50).update(price = F("price")-20)

Q查询

 filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

from django.db.models import Q
Q(title__startswith='Py')          # title中以py开头的

Q 对象可以使用&(与) 、|（或）、~（非） 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))

等同于下面的SQL WHERE 子句：

WHERE name ="yuan" OR name ="egon"

你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：

# 价格等于50且评论数等于20
ret = models.Book.objects.filter(Q(price__gt=50)&Q(comment__gt=20))
# 价格大于50或评论数大于20
ret = models.Book.objects.filter(Q(price__gt=50)|Q(comment__gt=20))
# 价格大于50或评论数小于20
ret = models.Book.objects.filter(Q(price__gt=50)|~Q(comment__gt=20))

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：

bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
                              title__icontains="python"  #也是and的关系，但是Q必须写在前面
                             )

分组

查询条件中带每字的多数都需要分组

注意：values里的字段是分组依据,根据什么分组；annotate根据分组后进行统计；

annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数）。

跨表分组查询本质就是将关联表join成一张表，再按单表的思路进行分组查询,，既然是join连表，就可以使用咱们的双下划线进行连表了。　

注意：annotate里面必须写个聚合函数，不然没有意义，并且必须有个别名=，别名随便写，但是必须有，用哪个字段分组，values里面就写哪个字段,annotate其实就是对分组结果的统计，统计你需要什么。

单表分组

    from django.db.models import Min
    # 分组查询
    ret = models.Book.objects.values("title").annotate(c=Min("price"))
    """
    <QuerySet [{'title': 'python', 'c': Decimal('180.00')}, 
    {'title': 'linux', 'c': Decimal('32.00')}, 
    {'title': 'go', 'c': Decimal('50.00')}, 
    {'title': 'c', 'c': Decimal('3.00')},
     {'title': 'web', 'c': Decimal('40.00')}, 
     {'title': 'java', 'c': Decimal('9.00')}, 
     {'title': '倚天屠龙记', 'c': Decimal('680.00')}, 
     {'title': '唐伯虎点秋香', 'c': Decimal('313.00')}]>
    """
    # values中写分组的字段，annotate中写需要统计的字段(必须写个聚合函数),annotate根据values分组后进行统计
    print(ret)

多表分组

# 查询出版社的名称,和每个出版社出版的书的最高价格
    from django.db.models import Max,Min
    # 正向查询：根据出版社的名字进行分组,因为出版社的名字的字段不在Book里所以需要先连表
    ret = models.Book.objects.values("publish__name").annotate(a = Max("price"))
    """
    <QuerySet [{'publish__name': '老男孩出版社', 'a': Decimal('313.00')}, 
    {'publish__name': '红浪漫出版社', 'a': Decimal('680.00')}, 
    {'publish__name': '小苹果出版社', 'a': Decimal('180.00')}, 
    {'publish__name': '西瓜出版社', 'a': Decimal('40.00')}]>
    """
    print(ret)
    
     # 反向查询:根据出版社的名字进行分组,因为出版社的名字的字段在publish里,所以直接通过名字进行分组,分组后在连表在book里取price字段的值
    ret = models.Publish.objects.values("name").annotate(a = Max("book__price"))
    """
    <QuerySet [{'publish__name': '老男孩出版社', 'a': Decimal('313.00')}, 
    {'publish__name': '红浪漫出版社', 'a': Decimal('680.00')}, 
    {'publish__name': '小苹果出版社', 'a': Decimal('180.00')}, 
    {'publish__name': '西瓜出版社', 'a': Decimal('40.00')}]>
    """
    print(ret)

特殊分组不带values：

# 特殊分组
    # 统计出每一个出版社最贵的书
    ret = models.Publish.objects.annotate(p=Max("book__price")).values("name","p")
    print(ret)
    # 先将publish和book连接起来然后根据publish的主键进行分组,分组后进行统计;取值取的是统计后的值
    """
    <QuerySet [{'name': '老男孩出版社', 'p': Decimal('313.00')}, 
    {'name': '红浪漫出版社', 'p': Decimal('680.00')}, 
    {'name': '小苹果出版社', 'p': Decimal('180.00')}, 
    {'name': '西瓜出版社', 'p': Decimal('40.00')}]>
    """

 凡是遇到表名__都是先连表后操作：

六、ORM执行原生SQL语句的两种方法

在模型查询API不够用的情况下，我们还可以使用原始的SQL语句进行查询。

Django 提供两种方法使用原始SQL进行查询：一种是使用raw()方法，进行原始SQL查询并返回模型实例；另一种是完全避开模型层，直接执行自定义的SQL语句。

执行原生查询-----都是在views中执行

　　raw()管理器方法用于原始的SQL查询，并返回模型的实例：

　　注意：raw()语法查询必须包含主键。

　　这个方法执行原始的SQL查询，并返回一个django.db.models.query.RawQuerySet 实例。 这个RawQuerySet 实例可以像一般的QuerySet那样，通过迭代来提供对象实例。

举个例子：

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

　　可以像下面这样执行原生SQL语句

>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
...     print(p)

　　raw()查询可以查询其他表的数据。

　　　　举个例子：

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

　　raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

　　原生SQL还可以使用参数，注意不要自己使用字符串格式化拼接SQL语句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

直接执行自定义SQL

　  有时候raw()方法并不十分好用，很多情况下我们不需要将查询结果映射成模型，或者我们需要执行DELETE、 INSERT以及UPDATE操作。在这些情况下，我们可以直接访问数据库，完全避开模型层。

　  我们可以直接从django提供的接口中获取数据库连接，然后像使用pymysql模块一样操作数据库。

 from django.db import connection
    cursor = connection.cursor()
    sql = "select title from app01_book;"
    cursor.execute(sql)
    ret = cursor.fetchall()
    print(ret)
    # (('python',), ('linux',), ('go',), ('c',), ('web',), ('java',), ('倚天屠龙记',), ('唐伯虎点秋香',))

七、Python脚本中调用Django环境(django外部脚本使用models)

如果你想通过自己创建的python文件在django项目中使用django的models，那么就需要调用django的环境：

import os

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

    from app01 import models  #引入也要写在上面三句之后

    books = models.Book.objects.all()
    print(books)

 注意重点记：

查询：每个作者出版的所有书最高价格的那本书的名称

如果先分组,在取值,我们取的名字永远都是组内名字的第一个名字

连表后：
我们需要先按照价格从大到小进行排序,然后在分组取值,
因为排序后每个组内的价格最高的都是在第一位,这样在我们取值时即使取到的组内的第一位,也是分组内最大的值

先连表根据book_price进行从大到小排序：

select * from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc;

取出我们想要的内容：

select app01_author.id,app01_book.title,app01_book.price from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc;

最后进行分组取出最高价格那本书的名称

select title,price from (select app01_author.id,app01_book.title,app01_book.price from app01_author INNER JOIN app01_book_author on app01_author.id = app01_book_author.author_id INNER JOIN app01_book on app01_book.id=app01_book_author.book_id ORDER BY app01_book.price desc) as b  GROUP BY id;