model多表操作

from django.db import models

# Create your models here.

#比较常用的作者信息放到这个表里面
class Author(models.Model): 

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

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

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

class Publish(models.Model):
    id = 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):

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

参数:

    1. 一对一(OneToOneField):
    
    to
        设置要关联的表。
    to_field
        设置要关联的字段。
    on_delete
        同ForeignKey字段。
        
    2. 一对多(ForeignKey):
    to
        设置要关联的表
    to_field
        设置要关联的表的字段
    related_name
        反向操作时，使用的字段名，用于代替原反向查询时的‘表名_set‘。
    related_query_name
        反向查询操作时，使用的连接前缀，用于替换表名。
    on_delete
    当删除关联表中的数据时，当前表与其关联的行的行为。
    
    3. 多对多(ManyToManyField):
    to
        设置要关联的表
    related_name
        同ForeignKey字段。
    related_query_name
        同ForeignKey字段。
    through
        在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系。
        但我们也可以手动创建第三张表来管理多对多关系，此时就需要通过through来指定第三张表的表名。
    through_fields
        设置关联的字段。
    db_table
        默认创建第三张表时，数据库中表的名称。   

元信息

    ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:
    
    class Author2Book(models.Model):
        author = models.ForeignKey(to="Author")
        book = models.ForeignKey(to="Book")
        class Meta:
            unique_together = ("author", "book")

    db_table
        ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。
    index_together
        联合索引。
    unique_together
        联合唯一索引。
    ordering
        指定默认按什么字段排序。只有设置了该属性，我们查询到的结果才可以被reverse()。    

on_delete
    当删除关联表中的数据时，当前表与其关联的行的行为。

models.CASCADE
    删除关联数据，与之关联也删除

models.DO_NOTHING
    删除关联数据，引发错误IntegrityError

models.PROTECT
    删除关联数据，引发错误ProtectedError

models.SET_NULL
    删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）

models.SET_DEFAULT
    删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）

models.SET
    删除关联数据，
    a. 与之关联的值设置为指定值，设置：models.SET(值)
    b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

方式1:
   publish_obj = models.Publish.objects.get(id=1)
   book_obj = models.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 = models.Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish_id=1)　　#直接可以写id值，注意字段属性的写法和上面不同，这个是publish_id=xxx，上面是publish=xxx。

方式一： 
    多对多一般在前端页面上使用的时候是多选下拉框的样子来给用户选择多个数据，这里可以让用户选择多个书籍，多个作者
　　# 当前生成的书籍对象
    book_obj=models.Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)
    # 为书籍绑定的作者对象
    yuan=models.Author.objects.filter(name="yuan").first() 
    egon=models.Author.objects.filter(name="alex").first() 
    
　　                            
    # 绑定多对多关系,即向关系表book_authors中添加纪录，给书添加两个作者，下面的语法就是告诉orm给第三张表添加两条数据
    book_obj.authors.add(yuan,egon)    
    #  将某些特定的 model 对象添加到被关联对象集合中。 book_obj.authors.add(*[])
    #有人可能会说，我们可以直接给第三张表添加数据啊，这个自动生成的第三张表你能通过models获取到吗，是获取不到的，用不了的，当然如果你知道了这个表的名字，那么你通过原生sql语句可以进行书的添加，所以要通过orm间接的给第三张表添加数据，如果是你手动添加的第三张表你是可以直接给第三张表添加数据
    #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(id=4)[0]
    
    
    
    book_obj.authors.remove(2) 
        #将第三张表中的这个book_obj对象对应的那个作者id为2的那条记录删除
    
    book_obj.authors.set(‘2‘) 
        #先清除掉所有的关系数据，然后只给这个书对象绑定这个id为2的作者，所以只剩下一条记录3---2，比如用户编辑数据的时候，选择作者发生了变化，那么需要重新选择，所以我们就可以先清空，然后再重新绑定关系数据,注意这里写的是字符串，数字类型不可以
    
    book_obj.authors.set([‘1‘,])
        #这么写也可以，但是注意列表中的元素是字符串
    
更新：
    book_obj = models.Book.objects.get(id=1) #获取一个书籍对象
    data = {‘title‘:‘xxx‘,‘price‘:100} #这个书籍对象更新后的数据
    models.Book.objects.filter(id=n).update(**data) #将新数据更新到原来的记录中
    book_obj.authors.set(author_list) #将数据和作者的多对多关系加上

删除：
    models.Book.objects.filter(id=1).delete()

1. 一对一查询(Author -- AuthorDetail) 

　　正向查询(按字段：authorDetail)：

    查询egon的电话号码
    
    tel = models.Author.objects.filter(name="egon").first().authorDetail.tel
    # egon.authorDeail就拿到了这个对象，因为一对一找到的就是一条记录，注意写法：作者对象.字段名,就拿到了那个关联对象
　　　　
    反向查询(按表名：author)：不需要_set，因为一对一正向反向都是找到一条记录

    查询住址在北京的作者的姓名
 
    authorr_name = models.AuthorDetail.objects.filter(addr="beijing")[0].author.name
    

2. 一对多查询（Book -- Publish）
　　　　
　　正向查询(按字段：publish)：关联属性字段所在的表查询被关联表的记录就是正向查询，反之就是反向查询

    查询id为1的书籍的出版社所在的城市
    
    city = models.Book.objects.filter(pk=1).first().publish.city
    # book_obj.publish 是id为1的书籍对象关联的出版社对象，book对象.外键字段名称
　　　　
    反向查询(按表名：book_set,因为加上_set是因为反向查询的时候，你查询出来的可能是多条记录的集合)：

    查询苹果出版社出版的所有图书的名字
    
    book_list = models.Publish.objects.get(name="苹果出版社").book_set.all()
    #publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合，写法：小写的表名_set.all()，得到queryset类型数据
    
    for book_obj in book_list:
       print(book_obj.title)
 　　
3. 多对多查询(Book -- Author)
　　
　　正向查询(按字段：authors)：

    金瓶眉所有作者的名字以及手机号
     
    authors = models.Book.objects.filter(title="金瓶眉").first().authors.all()
    
    for author_obj in authors:
         print(author_obj.name,author_obj.authorDetail.tel)
    　　　　
    反向查询(按表名：book_set)：

    查询egon出过的所有书籍的名字
 
    book_list = models.Author.objects.get(name="egon").book_set.all()
    
    for book_obj in book_list:
        print(book_obj.title)
　　　　
    注意：

　　你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Article model 中做更改：

    publish = ForeignKey(Book, related_name=‘bookList‘)
　　
    那么接下来就会如我们看到这般：

    查询人民出版社出版过的所有书籍
 
    book_list = models.Publish.objects.get(name="人民出版社").bookList.all()
    
    在这里我们补充一点，因为你很快就要接触到了，那就是form表单里面的button按钮和form表单外面的button按钮的区别，form表单里面的button按钮其实和input type=‘submit‘的标签是有同样的效果的，都能够提交form表单的数据，但是如果放在form表单外面的button按钮，那就只是个普通的按钮了。<button>提交</button>，还有一点，input type=‘submit‘按钮放到form表单外面那就成了一个普通的按钮。

1. 一对一查询(Author -- AuthorDetail)

查询yuan的手机号
    
    正向查询 按字段:
     
    tel = models.Author.objects.filter(name="yuan").values("authorDetail__telephone")

    反向查询 按表名:author
    
    ret = models.AuthorDetail.objects.filter(author__name="yuan").values("telephone")

2. 一对多查询(Book -- Publish):

查询苹果出版社出版过的所有书籍的名字与价格

    正向查询 按字段:publish

    queryResult = models.Book.objects.filter(publish__name="苹果出版社").values_list("title","price")  
        #values或者values_list
        #通过__告诉orm将book表和publish表进行join，然后找到所有记录中publish.name=‘苹果出版社‘的记录（注意publish是属性名称），然后select book.title,book.price的字段值
　　　　　　　　　　　　 
    反向查询 按表名:book

    queryResult = models.Publish.objects.filter(name="苹果出版社").values_list("book__title","book__price")

3. 多对多查询(Book -- Author):

查询yuan出过的所有书籍的名字

    正向查询 按字段:authors:
    
    queryResult = models.Book.objects.filter(authors__name="yuan").values_list("title")

    反向查询 按表名:book
    
    queryResult = models.Author.objects.filter(name="yuan").values_list("book__title","book__price")

4. 进阶练习(连续跨表)

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

    正向查询
    
    queryResult = models.Book.objects.filter(publish__name="人民出版社").values_list("title","authors__name")
    
    反向查询
    
    queryResult = models.Publish.objects.filter(name="人民出版社").values_list("book__title","book__authors__name")

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

    正向查询
    
    queryResult = models.Book.objects.filter(authors__authorDetail__tel__regex="^151").values_list("title","publish__name")
    
    反向查询  
    
    ret = models.Author.objects.filter(authordetail__telephone__startswith="151").values("book__title","book__publish__name")
      
5. related_name

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

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

    查询人民出版社出版过的所有书籍的名字与价格

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

    queryResult = models.Publish.objects.filter(name="人民出版社").values_list("bookList__title","bookList__price")