Django单表，连表查询

今日内容：
 模型层（orm模型表）
 数据库
 记录
 
 
 1，在djang中新增测试脚本
  1，可以在根目录下新建一个py文件。列如test.py文件
  2，在文件中写入以下代码即可
  
  #!/usr/bin/env python
  import os
  import sys

  if __name__ == "__main__":
   os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day55.settings")
   import django
   django.setup()
 2，单表操作
  1，表的字段增删改查
  2，记录的增删改查
  
  
 3,神奇的双下滑查询
   """
   查看orm内部sql语句的方法有哪些
    1.如果是queryset对象 那么可以点query直接查看该queryset的内部sql语句
    2.在django项目的配置文件中 配置一下参数即可实现所有的orm在查询的时候自动打印对应的sql语句
    LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'handlers': {
      'console':{
       'level':'DEBUG',
       'class':'logging.StreamHandler',
      },
     },
     'loggers': {
      'django.db.backends': {
       'handlers': ['console'],
       'propagate': True,
       'level':'DEBUG',
      },
     }
    }
   """
  
  
  
  
  
  4连表查询：
   1，一对多字段的增删改查
    增
     
     1，传数字，
      用外键关联字段时，直接传数字，即关联的id值就可以 例如 publish_id=1
      models.Book.objects.create(title='三国演义',price=899.99,publish_id=1)
     
     2，传对象，
      当不是外键字段时，如果用publish= 这时候传的是对象
      是去找与之关联表中的虚拟字段查找对象，然后把对象当做参数传
     
         # publish_obj = models.Publish.objects.filter(pk=2).first()
      # book_obj = models.Book.objects.create(title='西游记',price=666.99,publish=publish_obj)
        #改
      *************
      同增原理一样：如果是实际的字段就传数字
          如果是虚拟的字段就传对象
         
      #传数字
      # models.Book.objects.filter(pk=5).update(publish_id=3)
      #传对象
      publish_obj = models.Publish.objects.filter(pk=2).first()
      models.Book.objects.filter(pk=7).update(publish=publish_obj)
    
     #删
      #在django的orm中默认的是级联更新，级联删除，
      # 关联表中增加数据，删除数据，被关联表也会随之发送改变
      
      models.Publish.objects.filter(pk=2).delete()
    
   2，多对多字段的增删改查
     add()       增    传数字，对象
     set()        改   传数字，对象  ，必须是可迭代对象
     remove()     删    传数字，对象
        以上可以传多个
     clear()      删所有   括号内不要传参数
   
     # 增
      add（）
      1，add括号中传数字
      
      
          # 主键为6的书籍增加一个作者
        book_obj = models.Book.objects.filter(pk=6).first()
        print(book_obj.authors) 此时为None,就是跳到了第三张表
        
        #对象点击多对多虚拟字段时，会直接多对多的第三张表
        #此时book_obj.authors就是直接跨到第三张表
        book_obj.authors.add(1)  # 此时就是给id为6的书籍添加一个作者
        book_obj.authors.add(2,3)
        # add括号中既可以传一个数字，又可以传多个数字
        # 括号中一个数字，此时就是给id为6的书籍添加一个作者，
        # 所以括号中有几个数字，就是添加几个作者，数字表示的是作者的id号
      
      2，add括号中传对象
        增加一条
            book_obj = models.Book.objects.filter(pk=4).first()
         aut_obj = models.Author.objects.filter(pk=3).first()
         book_obj.authors.add(aut_obj)
        
        增加多条
        
         book_obj = models.Book.objects.filter(pk=5).first()
         book_obj1= models.Book.objects.filter(pk=5).first()
         
         aut_obj = models.Author.objects.filter(pk=2).first()
         aut_obj1= models.Author.objects.filter(pk=1).first()
         aut_obj2 = models.Author.objects.filter(pk=9).first()
         
         book_obj.authors.add(aut_obj,aut_obj1,aut_obj2)
         book_obj1.authors.add(aut_obj1)
        总结：
        add是给书籍添加作者 括号内既可以传数字也可以传作者对象
        并且支持一次性传多个 逗号隔开就可以
        注意 ：对象点虚拟字段就是跳到了第三张表
        
        
     改：
      将主键为5的书籍对象 作者修改为2，3
      set（）
       括号中以列表的形式，是可迭代对象才可以传一个参数也要以列表的形式
       1，传数字，
       
           book_obj = models.Book.objects.filter(pk=5).first()
        book_obj.authors.set([5,])   传一个参数
        book_obj.authors.set([2,3])  传多个参数
         本质就是修改，有点类似于删除，把不要的删除，把要的留下来
      
       2，传作者对象
       
         aut_obj = models.Author.objects.filter(pk=2).first()
         aut_obj1= models.Author.objects.filter(pk=1).first()
         aut_obj2 = models.Author.objects.filter(pk=9).first()
         
         book_obj.authors.set([aut_obj,aut_obj1,aut_obj2])
   
      总结：
       set（）括号内 需要传一个可迭代对象
       可迭代对象  可以是多个数字组合
       也可以是多个对象组合
       但是不能混在一起使用，即不能既有数字，又有对象！！！
       要么纯数字，要么纯对象
       
       
       
     删：
      remove（）
       1，传数字
       
          book_obj = models.Book.objects.filter(pk=5).first()
  
       book_obj.authors.remove(3)
       
       2，传对象
       
        aut_obj = models.Author.objects.filter(pk=2).first()
        aut_obj1= models.Author.objects.filter(pk=1).first()
        aut_obj2 = models.Author.objects.filter(pk=9).first()
        
        book_obj.authors.remove(aut_obj)
        book_obj.authors.remove(aut_obj,aut_obj1,aut_obj2)
      总结：
       remove（）括号内既可以传数字 也可以传对象
       并且支持传多个，逗号隔开即可
       
       将某本书和作者的关系全部清空，用clear（）
       即清空当前这个作者与书籍的关系
       
       book_obj = models.Book.objects.filter(pk=5).first()
       book_obj.authors.clear()
       
       
    跨表查询：
            正向与反向的概念
   
       # 一对一
       # 正向：author---关联字段在author表里--->authordetail  按字段
       # 反向：authordetail---关联字段在author表里--->author  按表名小写
       
        
       # 一对多
       # 正向：book---关联字段在book表里--->publish  按字段
       # 反向：publish---关联字段在book表里--->book  按表名小写_set.all() 因为一个出版社对应着多个图书
       
       # 多对多
       # 正向：book---关联字段在book表里--->author  按字段
       # 反向：author---关联字段在book表里--->book  按表名小写_set.all() 因为一个作者对应着多个图书
       
       
       正向查询按外键字段
       反向查询按表名小写
       
       基于对象的跨表查询(子查询:将一张表的查询结果当做另外一个查询语句的条件)
       
       强调:在书写orm语句的时候 跟写sql语句一样
       不要尝试着 一次性写完  应该做到写一点看一点再一点
   1，如果外键字段在你当前这张表中，那么如果由你当前这张表向另一张表查询就是正向

    关系字段在你当前这张表，由你这张表去查，正向
    关系字段不在你当前这张表，由你这张表去查，反向
    
    正向查询按外键字段
    反向查询按表名小写
    
    
    # 基于对象的跨表查询（子查询:将一张表的查询结果当做另外一个查询语句的条件）
     #查询书籍为4的出版社名称
     book_obj = models.Book.objects.filter(pk=4).first()
     print(book_obj.publish.name)
     print(book_obj.publish.addr)
     # 查询书籍id是5的作者姓名
     book_obj = models.Book.objects.filter(pk=5).first()
     
     print(book_obj.authors)   # app01.Author.None
     #书籍有多个作者，所以拿到为None
     print(book_obj.authors.all()) 拿到的是对象，
     
     当你外键字段对应的值有多个的时候就用all(),为一个的时候就不用all()
       
        # 查询作者是jason的家庭住址
      auth_obj = models.Author.objects.filter(name='jason').first()
      print(auth_obj.author_detail.addr)
     
      
     反向查询：
          # 查询出版社是东方出版社出版的书籍
       publish_obj = models.Publish.objects.filter(name='东方出版社').first()
       print(publish_obj.book_set.all())
       # 查询作者是jason写过的所有书籍
       # auth_obj = models.Author.objects.filter(name='jason').first()
       # print(auth_obj.book_set)
       # print(auth_obj.book_set.all())
       
       # 查询作者号码是120的作者姓名
       auth_obj = models.AuthorDetail.objects.filter(phone=120).first()
       print(auth_obj.author.name)
       print(auth_obj.author.age)
       
     总结：
      反向查询，当你反向查询的结果是多个的时候就需要加 _set
              当你反向查询的结果是一个时就不需要加_set
        即表名小写即可
       跨表查询：可以连续的查询
       
       
  # 基于双下划线的跨表查询（其实就是连表操作）
     # 查询jason作者的手机号
     res = models.Author.objects.filter(name='jason').values('author_detail__phone')
     #点values就是拿某张表中的某个字段，在判断是正向还是反向，正向放字段，
     # 此时就是跨到了此表中，然后查此表字段就用__加字段名
     
         # 反向
      # res1 = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__age')
      # print(res1)