Django ORM 多表操做

时间 2020-05-29

标签 django orm 栏目 Python 繁體版

原文原文链接

建立模型

<1> null ： 数据库中字段是否能够为空

    <2> blank： django的 Admin 中添加数据时是否可容许空值

    <3> default：设定缺省值

    <4> editable：若是为假，admin模式下将不能改写。缺省为真

    <5> primary_key：设置主键，若是没有设置django建立表时会自动加上：
        id = meta.AutoField('ID', primary_key=True)
        primary_key=True implies blank=False, null=False and unique=True. Only one
        primary key is allowed on an object.

    <6> unique：数据惟一

    <7> verbose_name　　Admin中字段的显示名称

    <8> validator_list：有效性检查。非有效产生 django.core.validators.ValidationError 错误


    <9> db_column，db_index 若是为真将为此字段建立索引

    <10>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
                如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
                gender = models.CharField(max_length=2,choices = SEX_CHOICES)

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

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

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

出版商模型：出版商有名称，所在城市以及email。sql

书籍模型：书籍有书名和出版日期，一本书可能会有多个做者，一个做者也能够写多本书，因此做者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，因此出版商和书籍是一对多关联关系(one-to-many)。数据库

模型创建以下：django

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',)

生成表以下：app

注意事项：ide

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

添加表纪录

操做前先简单的录入一些数据：函数

publish表：spa

author表：

authordetail表:

一对多

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         方式 
         1 
         : 
        
         publish_obj 
         = 
         Publish.objects.get(nid 
         = 
         1 
         ) 
        
         book_obj 
         = 
         Book.objects.create(title 
         = 
         "金瓶眉" 
         ,publishDate 
         = 
         "2012-12-12" 
         ,price 
         = 
         100 
         ,publish 
         = 
         publish_obj) 
        
         方式 
         2 
         : 
        
         book_obj 
         = 
         Book.objects.create(title 
         = 
         "金瓶眉" 
         ,publishDate 
         = 
         "2012-12-12" 
         ,price 
         = 
         100 
         ,publish_id 
         = 
         1 
         )

核心：book_obj.publish与book_obj.publish_id是什么？

多对多

# 当前生成的书籍对象
    book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)
    # 为书籍绑定的作做者对象
    yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录
    egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录

    # 绑定多对多关系,即向关系表book_authors中添加纪录
    book_obj.authors.add(yuan,egon)    #  将某些特定的 model 对象添加到被关联对象集合中。   =======    book_obj.authors.add(*[])

数据库表纪录生成以下：

book表

book_authors表

核心:book_obj.authors.all()是什么？

多对多关系其它经常使用API：

 
         1 
       
         2 
       
         3 
       
         book_obj.authors.remove()       
         # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[]) 
        
         book_obj.authors.clear()        
         #清空被关联对象集合 
        
         book_obj.authors. 
         set 
         ()          
         #先清空再设置

一对多查询（Publish 与 Book）

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         # 查询主键为1的书籍的出版社所在的城市 
        
         book_obj 
         = 
         Book.objects. 
         filter 
         (pk 
         = 
         1 
         ).first() 
        
         # book_obj.publish 是主键为1的书籍对象关联的出版社对象 
        
         print 
         (book_obj.publish.city)

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

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         publish 
         = 
         Publish.objects.get(name 
         = 
         "苹果出版社" 
         ) 
        
         #publish.book_set.all() : 与苹果出版社关联的全部书籍对象集合 
        
         book_list 
         = 
         publish.book_set. 
         all 
         ()     
        
         for  
         book_obj  
         in  
         book_list: 
        
         print 
         (book_obj.title)

一对一查询(Author 与 AuthorDetail)

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

 
         1 
       
         2 
       
         egon 
         = 
         Author.objects. 
         filter 
         (name 
         = 
         "egon" 
         ).first() 
        
         print 
         (egon.authorDetail.telephone)

反向查询(按表名：author)：

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         # 查询全部住址在北京的做者的姓名 
        
         authorDetail_list 
         = 
         AuthorDetail.objects. 
         filter 
         (addr 
         = 
         "beijing" 
         ) 
        
         for  
         obj  
         in  
         authorDetail_list: 
        
         print 
         (obj.author.name)

多对多查询 (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 
         ()   
         # 与人民出版社关联的全部书籍对象集合

基于双下划线的跨表查询

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

'''
    正向查询按字段,反向查询按表名小写用来告诉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")

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,  
         Max 
         ,  
         Min 
        
 
         >>> 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)

'''


SELECT "app01_publish"."name", MIN("app01_book"."price")  AS "MinPrice" FROM "app01_publish" 
LEFT  JOIN "app01_book" ON ("app01_publish"."nid" = "app01_book"."publish_id") 
GROUP BY "app01_publish"."nid", "app01_publish"."name", "app01_publish"."city", "app01_publish"."email" 

'''

(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 语句），你可使用Q 对象。

 
         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" 
        
         )

Django ORM 多表操做

建立模型

添加表纪录

一对多

多对多

基于对象的跨表查询

一对多查询（Publish 与 Book）

一对一查询(Author 与 AuthorDetail)

多对多查询 (Author 与 Book)

基于双下划线的跨表查询

一对多查询

多对多查询

一对一查询

进阶练习(连续跨表)

related_name

聚合查询与分组查询

聚合

分组

查询练习

F查询与Q查询

F查询

Q查询

多对多查询　　