一 创建模型

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这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面

class Book(models.Model):

    title = models.CharField(max_length=32, verbose_name="书名")

# 通过ORM自带的ManyToManyField自动创建第三张表

class Author(models.Model):

    name = models.CharField(max_length=32, verbose_name="作者姓名")

    books = models.ManyToManyField(to="Book", related_name="authors")

class Book(models.Model):

    title = models.CharField(max_length=32, verbose_name="书名")

# 自己创建第三张表，并通过ManyToManyField指定关联

class Author(models.Model):

    name = models.CharField(max_length=32, verbose_name="作者姓名")

    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))

    # through_fields接受一个2元组（'field1'，'field2'）：

    # 其中field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。

class Author2Book(models.Model):

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

    book = models.ForeignKey(to="Book")

    class Meta:

        unique_together = ("author", "book")

二 添加表记录

方式1:

   publish_obj=Publish.objects.get(nid=1) #拿到nid为1的出版社对象

   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish=publish_obj) #出版社对象作为值给publish，其实就是自动将publish字段变成publish_id,然后将publish_obj的id给取出来赋值给publish_id字段，注意你如果不是publish类的对象肯定会报错的，别乱昂

方式2:

   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish_id=1)　　#直接可以写id值，注意字段属性的写法和上面不同，这个是publish_id=xxx，上面是publish=xxx。

   方式一： 多对多一般在前端页面上使用的时候是多选下拉框的样子来给用户选择多个数据，这里可以让用户选择多个书籍，多个作者
　　# 当前生成的书籍对象

    book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)

    # 为书籍绑定的做作者对象

    yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录，注意取的是author的model对象

    egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录

　　#有人可能会说，我们可以直接给第三张表添加数据啊，这个自动生成的第三张表你能通过models获取到吗，是获取不到的，用不了的，当然如果你知道了这个表的名字，那么你通过原生sql语句可以进行书的添加，所以要通过orm间接的给第三张表添加数据，如果是你手动添加的第三张表你是可以直接给第三张表添加数据

    # 绑定多对多关系,即向关系表book_authors中添加纪录，给书添加两个作者，下面的语法就是告诉orm给第三张表添加两条数据

    book_obj.authors.add(yuan,egon)    #  将某些特定的 model 对象添加到被关联对象集合中。   =======    book_obj.authors.add(*[])
    #book_obj是书籍对象，authors是book表里面那个多对多的关系字段名称。
    #其实orm就是先通过book_obj的authors属性找到第三张表，然后将book_obj的id值和两个作者对象的id值组合成两条记录添加到第三张表里面去
　　方式二

　　　　book_obj.authors.add(1，2)

　　　　book_obj.authors.add(*[1，2]) #这种方式用的最多，因为一般是给用户来选择，用户选择是多选的，选完给你发送过来的就是一堆的id值

book_obj.authors.remove()      # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[1，2])，将多对多的关系数据删除

book_obj.authors.clear()       #清空被关联对象集合

book_obj.authors.set()         #先清空再设置　　 ===== 

   book_obj = models.Book.objects.filter(nid=4)[0]

    # book_obj.authors.remove(2) #将第三张表中的这个book_obj对象对应的那个作者id为2的那条记录删除

    # book_obj.authors.clear()

    # book_obj.authors.set('2') #先清除掉所有的关系数据，然后只给这个书对象绑定这个id为2的作者，所以只剩下一条记录  3---2，比如用户编辑数据的时候，选择作者发生了变化，那么需要重新选择，所以我们就可以先清空，然后再重新绑定关系数据,注意这里写的是字符串，数字类型不可以

    book_obj.authors.set(*['1',]) #这么写也可以，但是注意列表中的元素是字符串

三 基于对象的跨表查询

# 查询主键为1的书籍的出版社所在的城市

book_obj=Book.objects.filter(pk=1).first()

# book_obj.publish 是主键为1的书籍对象关联的出版社对象，book对象.外键字段名称

print(book_obj.publish.city) 　

publish=Publish.objects.get(name="苹果出版社")

#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合，写法：小写的表名_set.all()，得到queryset类型数据

book_list=publish.book_set.all()

for book_obj in book_list:

       print(book_obj.title)

egon=Author.objects.filter(name="egon").first()

print(egon.authorDetail.telephone) egon.authorDeail就拿到了这个对象，因为一对一找到的就是一条记录，注意写法：作者对象.字段名,就拿到了那个关联对象

# 查询所有住址在北京的作者的姓名

authorDet=AuthorDetail.objects.filter(addr="beijing")[0]

authorDet.author.name

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

'''

    正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表

'''

# 练习:  查询苹果出版社出版过的所有书籍的名字与价格(一对多)

    # 正向查询 按字段:publish

    queryResult=Book.objects

　　　　　　　　　　　　.filter(publish__name="苹果出版社")

　　　　　　　　　　　　.values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="苹果出版社")

　　　　　　　　　　　　　　.values_list("book__title","book__price")

# 练习: 查询alex出过的所有书籍的名字(多对多)

    # 正向查询 按字段:authors:

    queryResult=Book.objects

　　　　　　　　　　　　.filter(authors__name="yuan")

　　　　　　　　　　　　.values_list("title")

    # 反向查询 按表名:book

    queryResult=Author.objects

　　　　　　　　　　　　　　.filter(name="yuan")

　　　　　　　　　　　　　　.values_list("book__title","book__price")

    # 查询alex的手机号

    # 正向查询

    ret=Author.objects.filter(name="alex").values("authordetail__telephone")

    # 反向查询

    ret=AuthorDetail.objects.filter(author__name="alex").values("telephone")

# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名

    # 正向查询

    queryResult=Book.objects

　　　　　　　　　　　　.filter(publish__name="人民出版社")

　　　　　　　　　　　　.values_list("title","authors__name")

    # 反向查询

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="人民出版社")

　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")

# 练习: 手机号以151开头的作者出版过的所有书籍名称以及出版社名称

    # 方式1:

    queryResult=Book.objects

　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="151")

　　　　　　　　　　　　.values_list("title","publish__name")

    # 方式2:

    ret=Author.objects

              .filter(authordetail__telephone__startswith="151")

              .values("book__title","book__publish__name")

# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)

# 反向查询 不再按表名:book,而是related_name:bookList

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="人民出版社")

　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price") 

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

###################################－－单表分组查询－－#######################################################

查询每一个部门名称以及对应的员工数

emp:

id  name age   salary    dep

1   alex  12   2000     销售部

2   egon  22   3000     人事部

3   wen   22   5000     人事部

sql语句:

select dep,Count(*) from emp group by dep;

ORM:

emp.objects.values("dep").annotate(c=Count("id")

###################################－－多表分组查询－－###########################

多表分组查询：

查询每一个部门名称以及对应的员工数

emp:

id  name age   salary   dep_id

1   alex  12   2000       1

2   egon  22   3000       2

3   wen   22   5000       2

dep

id   name

1    销售部

2    人事部

emp－dep:

id  name age   salary   dep_id   id   name

1   alex  12   2000       1      1    销售部

2   egon  22   3000       2      2    人事部

3   wen   22   5000       2      2    人事部

sql语句:

select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id

ORM:

dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")

queryResult= Publish.objects

　　　　　　　　　　　　.annotate(MinPrice=Min("book__price"))

　　　　　　　　　　　　.values_list("name","MinPrice")

print(queryResult)

ret=Book.objects.annotate(authorsNum=Count('authors__name'))

 queryResult=Book.objects

　　　　　　　　　　 .filter(title__startswith="Py")

　　　　　　　　　 　.annotate(num_authors=Count('authors'))

queryResult=Book.objects

　　　　　　　　　　.annotate(num_authors=Count('authors'))

　　　　　　　　　　.filter(num_authors__gt=1)

#   按author表的所有字段 group by

    queryResult=Author.objects
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("book__price"))
　　　　　　　　　　　　　　.values_list("name","SumPrice")

    print(queryResult)

六 xxx

七 xxx

八 xxx