zoukankan      html  css  js  c++  java
  • day 71

    多表操作:

    创建模型

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

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

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

    出版商模型:出版商有名称,所在城市以及email。

    书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many)。

    模型建立如下:

    复制代码

    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",on_delete=models.CASCADE)
    
    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()
    
    
    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=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE)
        # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个,自动创建第三张表
        authors=models.ManyToManyField(to='Author',

     生成表如下:

    注意事项:

    •  表的名称myapp_modelName,是根据 模型中的元数据自动生成的,也可以覆写为别的名称  
    •  id 字段是自动添加的
    •  对于外键字段,Django 会在字段名上添加"_id" 来创建数据库中的列名
    •  这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式,要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
    •  定义好模型之后,你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置,在其中添加models.py所在应用的名称。
    • 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL),你可以赋给它空值 None 。

    添加表操作:

      (1)一对多:

     方法一: publish_obj = Publish.objects.get(nid = 1)

         book_obj = Book.objects.create(title = '西游记',publish_date = '2012-10-12',price = 100,publish = publish_obj)

    方法二:book_obj = Book.objects.create(title = '西游记',publish_date = '2012-10-19',price = 100,publishi_id = 1)

       (2) 多对多:

      #当前生成的书籍对象

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

       #为书籍绑定作者

        yuan = Author.objects.filter(name = 'yuan').first()

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

      #绑定多对多关系 (即向book_authors表插入记录)

      普通方法(绑定作者的对象):  book.authors.add(egon,yuan)

         也可以:                book.authors.add(*[egon,yuan])   # * 代表打散

     也可以绑定作者的id: book.authors.add(1,2,。。。)

          也可以                          book.authors.add(*[1,2,。。。])

    宽展(重点):

        book_obj.authors.remove()                     #将某个特定的对象从被关联对象集合中去除

        book_obj.authors.clear()                         #清空绑定对象

          book_obj.authors.set()                             #重置绑定对象(先清空,后绑定)

    基于对象的跨表查询:

    一对多查询:

        (1)正向查询(按字段):

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

        Book.objects.filter(id = 1).first().publish.city()

        (2)  反向查询(按表明小写:book_set):

        publish_obj = Publish.objects.get(name = '苹果出版社')

        book_list = publish_obj.book_set().all()

        for book_obj in book_list:

          pirnt(book_obj.title)

     

    一对一查询:

      (1)正向查询(按字段):

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

        print(egon.AuthorDetail.telephone)

      (2) 反向查询按表明(author):

        author_list = AuthorDetail.objects.filter(add = '北京')

        for obj in author_list:

          print(obj.author.name)

    多对多查询:

     (1)正向查询(按字段AuthorDetail):

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

      print(egon.authorDetail.telephone)

      (2) 反向查询(按表明:author)

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

      author_listh = Author.objects.filter(add = '北京')

    多对多查询 (Author 与 Book)

    正向查询(按字段:authors):

    1
    2
    3
    4
    5
    6
    # 金瓶眉所有作者的名字以及手机号
     
    book_obj=Book.objects.filter(title="金瓶眉").first()
    authors=book_obj.authors.all()
    for author_obj in authors:
         print(author_obj.name,author_obj.authorDetail.telephone)

    反向查询(按表名:book_set):

    1
    2
    3
    4
    5
    6
    # 查询egon出过的所有书籍的名字
     
        author_obj=Author.objects.get(name="egon")
        book_list=author_obj.book_set.all()        #与egon作者相关的所有书籍
        for book_obj in book_list:
            print(book_obj.title)

    注意:

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

    1
    publish = ForeignKey(Book, related_name='bookList')

    那么接下来就会如我们看到这般:

    1
    2
    3
    4
    # 查询 人民出版社出版过的所有书籍
     
    publish=Publish.objects.get(name="人民出版社")
    book_list=publish.bookList.all()  # 与人民出版社关联的所有书籍对象集合

     

     

    基于双下划线的跨表查询 

    口诀:            正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
    一对多查询:
    查询苹果出版社出版过的所有书籍的名字和价格(一对多)

    正向查询(按字段)(publish)
    queryResutl = Book.objecs.filter(publish__name = '苹果出版社').values_list('title','price')

    反向查询(按表明):book
    queryResult = Publish.objects.filter(name = '苹果出版社').values(‘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")
    复制代码

    related_name

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

    1
    publish = ForeignKey(Blog, related_name='bookList')
    复制代码
    # 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)

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

    queryResult=Publish.objects               .filter(name="人民出版社")               .values_list("bookList__title","bookList__price")
    复制代码

    聚合查询与分组查询

    聚合

    aggregate(*args, **kwargs)

    1
    2
    3
    4
    # 计算所有图书的平均价格
        >>> from django.db.models import Avg
        >>> Book.objects.all().aggregate(Avg('price'))
        {'price__avg'34.35}

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

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

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

    1
    2
    3
    >>> from django.db.models import Avg, MaxMin
    >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
    {'price__avg'34.35'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

    分组

    复制代码
    ###################################--单表分组查询--#######################################################
    
    查询每一个部门名称以及对应的员工数
    
    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")
    复制代码
     View Code

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

    总结 :跨表分组查询本质就是将关联表join成一张表,再按单表的思路进行分组查询。 

    查询练习

    (1) 练习:统计每一个出版社的最便宜的书

    1
    2
    3
    publishList=Publish.objects.annotate(MinPrice=Min("book__price"))
    for publish_obj in publishList:
        print(publish_obj.name,publish_obj.MinPrice)

    annotate的返回值是querySet,如果不想遍历对象,可以用上valuelist:

    queryResult= Publish.objects
                .annotate(MinPrice=Min("book__price"))
                .values_list("name","MinPrice")
    print(queryResult)
     View Code

    (2) 练习:统计每一本书的作者个数

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

    (3) 统计每一本以py开头的书籍的作者个数:

     queryResult=Book.objects
               .filter(title__startswith="Py")
               .annotate(num_authors=Count('authors'))

    (4) 统计不止一个作者的图书:

    queryResult=Book.objects
              .annotate(num_authors=Count('authors'))
              .filter(num_authors__gt=1)

    (5) 根据一本图书作者数量的多少对查询集 QuerySet进行排序:

    1
    Book.objects.annotate(num_authors=Count('authors')).order_by('num_authors')

    (6) 查询各个作者出的书的总价格:

    #   按author表的所有字段 group by
        queryResult=Author.objects
                  .annotate(SumPrice=Sum("book__price"))
                  .values_list("name","SumPrice") print(queryResult)

    F查询与Q查询

    F查询

    在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?

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

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

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

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

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

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

    Q查询

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

    1
    2
    from django.db.models import Q
    Q(title__startswith='Py')

    Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。

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

    等同于下面的SQL WHERE 子句:

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

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

    1
    bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title")

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

    1
    2
    3
    bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),
                                  title__icontains="python"
                                 )

      

  • 相关阅读:
    DDOS和cc攻击的防御
    shell脚本基础知识
    MySQL常用的查询命令
    shell常见脚本30例
    shell中的函数
    shell中的数字
    shell中的ps3为何物以及select循环
    FPGA设计经验谈 —— 10年FPGA开发经验的工程师肺腑之言
    FPAG结构 组成 工作原理 开发流程(转)
    modelsim仿真中 do文件的写法技巧
  • 原文地址:https://www.cnblogs.com/zsdbk/p/9240902.html
Copyright © 2011-2022 走看看