Django的ORM表查询

Posted ygzico

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Django的ORM表查询相关的知识,希望对你有一定的参考价值。

Django的ORM表查询

先创建一个数据库,做前期准备

为了方便测试,不再进行urls对应关系和views的书写,直接测试的单个文件

那么如何只单独测试Django中的某个py文件,有以下方法

  • 在任意一个py文件中书写以下代码

    • 可以在应用app的目录下的tests.py中书写
    • 也可以自己建立一个py文件书写
    import os
    
    if __name__ == "__main__":
        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test53.settings")
        import django
        django.setup()
    • 到manage.py文件中拷贝即可

单表查询

通过models.py创建一个表

from django.db import models

class Movie(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_time = models.DateField()

导入tests.py文件

from app01 import models
models.Movie.objects.all()
必知必会16条
"""
    必知必会16条
        1.create()
        2.all()
        3.filter()
        4.update()
        5.delete()
        6.first()
        7.last()
        8.get()
        9.values()
        10.values_list()
        11.order_by()
        12.count()
        13.exclude()
        14.exists()
        15.reverse()
        16.distinct()
    """
  1. create()
# creat()   返回值就是当前被创建数据的对象本身
    models.Movie.objects.create(title='三国演义', price=199.99, publish_time='2010-1-1')
    # 直接传日期对象也可以
    from datetime import date
    ctime = date.today()
    models.Movie.objects.create(title='西游记', price=88.88, publish_time=ctime)
  1. all()
# all() 返回queryset对象
    res = models.Movie.objects.all()
    print(res)
  1. filter()
# 3.filter()    返回queryset对象
res = models.Movie.objects.filter(pk=1) # pk就是主键
res = models.Movie.objects.filter(pk=1, title='三国演义')
print(res)
  1. get()---> 不推荐使用,因为当查询条件不存在的时候直接报错
# 4. get()  直接获取对象本身
res = models.Movie.objects.get(pk=2)
print(res.title, res.price, res.publish_time)
  1. values() 获取指定字段对的数据
# 5.values()    返回queryset对象[{},{}] 
res = models.Movie.objects.values('title', 'price')
print(res)
  1. values_list() 获取指定字段对的数据
# 6. values_list()  返回queryset对象[(),()] 
res = models.Movie.objects.values_list('title', 'price')
print(res)
  1. first() 获取第一个元素对象
# 7.first() 返回数据对象
res = models.Movie.objects.filter().first()
print(res)
  1. last() 获取最后一个元素对象
# 8.last()  返回数据对象
res = models.Movie.objects.filter().last()
print(res)
  1. update() 更新数据
# 9.update()    返回受影响的行数
res = models.Movie.objects.filter(pk=1).update(title='水浒传', price=77.77)
print(res)
  1. delete() 删除数据
# 10.delete()   返回受影响的表及行数
res = models.Movie.objects.filter(pk=1).delete()
print(res)  # (1, {'app01.Movie': 1})
  1. count() 统计数据条数
# 11.count()    返回数据条数
res = models.Movie.objects.count()
print(res)  # 1
  1. order_by() 按照指定字段排序
# 12.order_by() 默认是升序, -号就是降序
# res = models.Movie.objects.order_by('price')
res = models.Movie.objects.order_by('-price')
print(res)
  1. exclude() 排除什么之外
# 13.exclude()
res = models.Movie.objects.exclude(pk=2)
print(res)
  1. exists() 判断是否有数据
# 14.exists()
res = models.Movie.objects.filter(pk=999).exists()
print(res)  # False
  1. reverse() 反转
# 15.reverse()
res = models.Movie.objects.order_by('price').reverse()
print(res)
  1. distinct() 去重:前提是必须是有完全一样的数据才可以
# 16.distinct()
res = models.Movie.objects.values('title', 'price').distinct()
print(res)

双下划线查询

例题

  1. 查询价格大于70的电影
res = models.Movie.objects.filter(price__gt=70)
print(res)
  1. 查询价格小于80的电影
res = models.Movie.objects.filter(price__lt=80)
print(res)
  1. 查询价格大于等于88.88的电影
res = models.Movie.objects.filter(price__gte=88.88)
print(res)
  1. 查询价格小于等于77.77的电影
res = models.Movie.objects.filter(price__lte=77.77)
print(res)
  1. 查询价格是66或77或88
res = models.Movie.objects.filter(price__in=[66, 77, 88])
print(res)
  1. 查询价格在77-99之间的电影
res = models.Movie.objects.filter(price__range=(77,99))
print(res)          # 这里的range顾头也顾尾
  1. 查询电影名字中包含字母DDY的电影
res = models.Movie.objects.filter(title__contains='DDY')
# 默认区分大小写
res = models.Movie.objects.filter(title__icontains='DDY')   # i 忽略大小写
print(res)
  1. 查询2010年出版的电影
res = models.Movie.objects.filter(publish_time__year=2010)
print(res)
  1. 查询是1月份出版的电影
res = models.Movie.objects.filter(publish_time__month=1)
print(res)

多表查询

先在models.py中创建几张表,作为前期准备

外键字段在

  • 1.X版本中默认就是级联更新级联删除的
  • 2.X版本中 则需要你自己手动指定
class Book(models.Model):
    title = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_time = models.DateField(auto_now_add=True)  # 该字段新增数据时会自动添加

    # 出版社   一对多,外键字段建在多的一方
    publish = models.ForeignKey(to='Publish')
    # 作者    多对多,外键字段建在任意一方,推荐查询频率高的一方
    authors = models.ManyToManyField(to='Author')
    # 库存数
    kucun = models.BigIntegerField(default=1000)
    # 售出数
    maichu = models.BigIntegerField(default=500)

class Publish(models.Model):
    name = models.CharField(max_length=64)
    addr = models.CharField(max_length=64)


class Author(models.Model):
    name = models.CharField(max_length=64)
    age = models.IntegerField()

    # 作者详情  一对一,外键字段建在任意一方,推荐查询频率高的一方
    author_detail = models.OneToOneField(to='AuthorDetail')


class AuthorDetail(models.Model):
    phone = models.BigIntegerField()
    addr = models.CharField(max_length=64)
外键字段的增删改查
  • 一对多表关系

# 1.增 直接写实际的表字段,publish_id
models.Book.objects.create(title='三国演义', price=199, publish_id=2)
# 2.增 虚拟字段 直接给对象
publish_obj = models.Publish.objects.get(pk=1)
models.Book.objects.create(title='水浒传', price=188, publish=publish_obj)

# 1.改   同上
models.Book.objects.filter(pk=1).update(publish_id=3)
# 2.改
publish_obj = models.Publish.objects.get(pk=4)
models.Book.objects.filter(pk=1).update(publish=publish_obj)
  • 多对多表关系
  1. 给书籍绑定作者关系(add)
book_obj = models.Book.objects.filter(pk=1).first()
# 书籍和作者的关系是第三张表决定的
# print(book_obj.authors) # 书籍对象.虚拟字段authors就类似于已经跨到书籍和作者的第三张表了
book_obj.authors.add(1) # 给书籍绑定一个主键为1的作者
book_obj.authors.add(2, 3) # 给书籍绑定一个主键为2,3的作者

add是专门给第三张关系表添加数据,括号内即可传入数字,也可传入对象,支持传入多个

  1. 移除书籍与作者的绑定关系(remove)
book_obj = models.Book.objects.filter(pk=1).first()
# book_obj.authors.remove(2)
book_obj.authors.remove(1, 3)
author_obj = models.Author.objects.get(pk=2)
book_obj.authors.remove(author_obj)

remove是专门给第三张关系表移除数据,括号内即可传入数字,也可传入对象,支持传入多个

  1. 修改书籍与作者的关系(set)
book_obj = models.Book.objects.filter(pk=2).first()
book_obj.authors.set((2,))
book_obj.authors.set((2, 3))

set 修改书籍与作者的关系,括号内支持传数字和对象 但是需要是可迭代对象

  1. 清空书籍与作者关系(clear)
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.clear()

clear() 清空关系,不需要任何的参数


跨表查询

跨表查询的方式

  • 子查询:将一张表的查询结果当做另外一张表的查询条件
    • 分步操作
  • 链表查询
    • inner join
    • left join
    • right join
    • union

正反向的概念

  • 正向
    • 跨表查询的时候,外键字段是否在当前数据对象中,如果在,查询另外一张关系表,叫做正向
  • 反向
    • 跨表查询的时候,外键字段是否在当前数据对象中,如果不在,查询另外一张关系表,叫做反向

这里有个口诀

  • 正向查询按外键字段,反向查询按表名小写,__set

基于对象的跨表查询(子查询)

  1. 查询书籍pk为1的出版社的名称
book_obj = models.Book.objects.filter(pk=1).first()
print(book_obj.publish.name)    # 北方出版社
print(book_obj.publish.addr)    # 北京
  1. 查询书籍pk为2的所有作者的姓名
book_obj = models.Book.objects.filter(pk=2).first()
print(book_obj.authors) # app01.Author.None
author_list = book_obj.authors.all()
for author_obj in author_list:
    print(author_obj.name)
  1. 查询作者pk为1的电话号码
author_obj = models.Author.objects.filter(pk=1).first()
print(author_obj.author_detail.phone)

注意:以上为正向查询,当外键字段对应的数据可以有多个的时候,需要加.all(),否则点外键字典即可获取到对应的数据对象

  1. 查询出版社名称为东方出版社出版过的书籍
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
print(publish_obj.book_set) # app01.Book.None
book_list = publish_obj.book_set.all()
for book_obj in book_list:
    print(book_obj.title)
  1. 查询作者为jason写过的书
author_obj = models.Author.objects.filter(name='jason').first()
book_list = author_obj.book_set.all()
for book_obj in book_list:
    print(book_obj.title)
  1. 查询手机号为120的作者姓名
author_detail_obj = models.AuthorDetail.objects.filter(phone=120).first()
print(author_detail_obj.author.name)

注意:基于对象的反向查询,表名小写是否需要加_set.all()
一对多和多对多的时候需要添加,一对一不需要添加


基于双下划线跨表查询(链表查询)

  1. 查询书籍pk为1的出版社名称
# 正向:
    res = models.Book.objects.filter(pk=1).values('publish__name')
    print(res)
# 反向:
    res = models.Publish.objects.filter(book__pk=1).values('name')
    print(res)
  1. 查询书籍pk为1的作者姓名和年龄
# 正向
    res = models.Book.objects.filter(pk=1).values('authors__name', 'authors__age', 'title')
    print(res)
# 反向
    res = models.Author.objects.filter(book__pk=1).values('name', 'age', 'book__title')
    print(res)
  1. 查询作者是jason的年龄和手机号
# 正向
    res = models.Author.objects.filter(name='jason').values('age', 'author_detail__phone')
    print(res)
# 反向
    res = models.AuthorDetail.objects.filter(author__name='jason').values('author__age', 'phone')
    print(res)
  1. 查询书籍pk为1的作者的手机号
# 正向
    res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    print(res)
# 反向
    res = models.AuthorDetail.objects.filter(author__book__pk=1).values('phone')
    print(res)

注意:只要表与表之间有关系,就可以通过正向的外键字段或者反向的表名小写连续跨表操作


聚合查询

关键字是 aggregate

聚合查询需要导入几个功能

from django.db.models import Max, Min, Avg, Sum, Count
  1. 查询所有书的平均价格
res = models.Book.objects.aggregate(avg_price=Avg('price'))
    print(res)
  1. 查询价格最贵的书
res = models.Book.objects.aggregate(max_price=Max('price'))
    print(res)
  1. 全部使用
res = models.Book.objects.aggregate(Avg('price'), Max('price'), Min('price'), Sum('price'), Count('price'))
print(res)

分组查询

关键字是 annotate

  1. 统计每一本书的作者个数
res = models.Book.objects.annotate(author_num=Count('authors')).values('title', 'author_num')
    print(res)
  1. 统计出每个出版社卖的最便宜的书
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
    print(res)
  1. 统计不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title')
    print(res)
  1. 查询各个作者出的书的总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
    print(res)

如何按照表中的某一个指定字段分组

model.Book.objects.values('price').annotate()
# 这样就是以书表中价格分组

F与Q查询

需要导入

from django.db.models import F, Q

F:

  1. 查询库存数大于卖出数的书籍
book_list = models.Book.objects.filter(kucun__gt=F('maichu'))
    for book_obj in book_list:
        print(book_obj.title)
  1. 将所有书的价格提高100
res = models.Book.objects.update(price=F('price')+100)
    print(res)  # 5 返回影响的数据条数

F可以帮我们获取表中某个字段对应的值

Q:

Q可以改变查询的条件关系 与或非 (and、or、not)

  1. 查询书的名字是三国演义或者价格是400的书籍
res = models.Book.objects.filter(Q(title='三国演义'), Q(price=400)) # 逗号,是and关系
res1 = models.Book.objects.filter(Q(title='三国演义')|Q(price=400)) # | 管道符是 or关系
res2 = models.Book.objects.filter(~Q(title='三国演义')|Q(price=400))    # ~是not关系

Q的用法:想要

res = models.Book.objects.filter(‘title‘=‘三国演义‘)

title和三国演义都可以成为字符串,这样可以让用户自己选择想要的条件

q = Q()默
    q.connector = 'or'  # q对象认也是and关系,可以通过connector改变or
    q.children.append(('title', '三国演义'))
    q.children.append(('price', 1000))
    res = models.Book.objects.filter(q)
    print(res)

以上是关于Django的ORM表查询的主要内容,如果未能解决你的问题,请参考以下文章

django-模型层(ORM语法)

django-模型层(ORM语法)

[Django框架之ORM操作:多表查询,聚合查询分组查询F查询Q查询choices参数]

(Django)气流中的 ORM - 有可能吗?

Django-ORM-多表操作

Django框架05 /orm单表操作