ORM查询总结版

Posted abnerlc

tags:

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

目录

目录

概要

ORM常用字段

常用字段
            1   AutoFile( primary_key=Ture)
            
            2   Charfiled(max_length= 12)
            
            3   IntgerFile ()
            
            4   DateFile()
            
            5   DatetimeFlie
                

ROM 常用13个操作
     ( 1 ) 返回QuerySet对象的有
            1 all( )
            2 filter( )
            3 values( )
            4 values_list( )
            5 exclude( )
            6 order_by( )
            7 distinct( )
            8 reverse( )
     ( 2 ) 返回对象的有
            1 all( ).get( )
            2 all( ).first( )
            3 all( ).last( )
            
     ( 3 ) 返回布尔值的
            1 exists ( ) 
            
     ( 4 ) 返回具体数据的
            1 count( )

条件查询
            1 id__gt=                大于    id__lt( 小于)
            2 id__in=                在[1,2,21,12,221]
            
            3 id__contains="lc"      包含内容的
            4 id__startwith="钱"     以钱开头的
            5 id__endswitch= "娜"    ....
            6 date__year=2017        年份是2017的(day month)
            7 3 id__icontains="lc"   不区分大小写



跨表查询 
      ( 1 ) 基于对象查询
           book_obj = models.Book.object.get( id = 1) 
           name = book.pubilish.nam   

      ( 2 ) 基于双下划綫查找


聚合查询 avg   sum             

ORM基础

自定义一个插入类型,即固定长度

class FixedCharField(models.Field): #继承models.field
    """
    自定义的char类型的字段类
    """
    def __init__(self, max_length, *args, **kwargs):     #
        super().__init__(max_length=max_length, *args, **kwargs)  #继承父类的方法,长度为传进来的长度
        self.length = max_length

    def db_type(self, connection):    #定义函数返回类的方法
        """
        限定生成数据库表的字段类型为char,长度为length指定的值
        """
        return 'char(%s)' % self.length


class Class(models.Model):
    id = models.AutoField(primary_key=True)

    title = models.CharField(max_length=25)
    # 使用上面自定义的char类型的字段

    cname = FixedCharField(max_length=25)

创建类终极版

  • 注意多对多关系中的主表设置在正向查找比较多的表,如图书馆中一般通过书名查找比较多,因此主表就是书表,作者表就是外键表

# 自定义varchar类型数据
class FixedCharField(models.Field): #继承models.field
    """
    自定义的char类型的字段类
    """
    def __init__(self, max_length, *args, **kwargs):     #
        super().__init__(max_length=max_length, *args, **kwargs)  #继承父类的方法,长度为传进来的长度
        self.length = max_length

    def db_type(self, connection):    #定义函数返回类的方法
        """
        限定生成数据库表的字段类型为char,长度为length指定的值
        """
        return 'char(%s)' % self.length




class Class(models.Model):
    id = models.AutoField(primary_key=True)    # 主键可以不设置,系统自动添加
    
    title = models.CharField(max_length=40, unique=True, null=False)   # 不为空,必须有最大长度限制,想要有固定差高度,则需要自己自定义类
    
    author = models.ManyToManyField(to='Author',related_name="author")      # to_file表的某一个 字段
    
    num = models.IntegerField()                                             #int
    
    data=models.DateField(auto_now=datetime.datetime.now())    # 时间格式,自定义
    
    add=models.ForeignKey(to=Addr,on_delete=models.CASCADE)
    
    publish=models.ForeignKey(to='Publish',on_delete=models.CASCADE)

    detail= models.OneToOneField(to="Person_Detail",on_delete=models.CASCADE,related_name="Person")  # 一对一,给外键设定了唯一属性


    book = models.CharField(max_length=25)
    # 使用上面自定义的char类型的字段
    
    
    def __str__(self):
        return "<当提取该对象时,返回数去,如print(class时),显示的就是此里面的内容>"
        # 也可以理解为该对象的描述,默认返回的是对象的地址
     
     
        
    class Meta:   # 此类方法是设定该类查询的默认值,如排序的默认值

        ordering = ('title',)    # 以title的名字进行排序,注意这是一个元祖
        unique_together = ("author","add","data")       # 联合唯一设置
        db_table = "app"                                # 自定义命名
        
        



技术图片

多对多关系表创建

  • 自己指定第三张表多对多的关系
class Man(models.Model):
    name = models.CharField(max_length=40)
    phone = models.IntegerField(max_length=30)
    def __str__(self):
        return "name:,phone".format(self.name,self.phone)

    class Meta:
        ordering = ("id",)
        unique_together = ("name","phone",)

class Wonman(models.Model):
    name = models.CharField(max_length=40)
    phone = models.IntegerField(max_length=30)
    man = models.ManyToManyField(to='Man', related_name="wonman",through="Man_to_Wonman",through_fields=("woman","man"))
    def __str__(self):
        return "name:,phone".format(self.name,self.phone)

    class Meta:
        ordering = ("id",)
        unique_together = ("name","phone",)


class Man_to_Wonman(models.Model):
    addr = models.CharField(max_length=50)
    time_date = models.DateTimeField(auto_now_add=datetime.datetime.now())
    man = models.ForeignKey(to="Man",on_delete=models.CASCADE)
    woman= models.ForeignKey(to="Wonman",on_delete=models.CASCADE)
    def __str__(self):
        return
    class Meta:
        ordering = ("id",)

( 1 ) ORM自动帮我关联第三张表,

    author = models.ManyToManyField(to='Author',related_name="book")

( 2 ) 自己通过ForeignKey手动添加第三张表,不用 ManyToManyField

    publish=models.ForeignKey(to='Publish',on_delete=models.CASCADE,related_name="book")
    
    
    # 查询时只能在第三张表中查询出id,

( 3 ) 前面两种方法的结合,指定第三张表,并且指定关联第三张表那张数据,要想删除外键只能够通过第三张表删除

查找的方法还保留有ORM的方法

第三张表还可以记录其他信息,而不单单是只有主键和外键的id,因此删除修改数据则在第三张表进行删除   

第三张表.object.all( ).get(id=主键表_id,id = 外键表_id)     拿到对应行对象进行增删改

常用几个代码

  • 其是用来和数据库交互用的,进行数据的增删改查表,原名是Object Relational Mapping
  • 原理是把类映射成表,对象映射成数据行,属性映射成字段

技术图片

参数

官方网址 https://docs.djangoproject.com/en/2.0/ref/models/options/

ORM与数据库代码对应的关系

  • ORM代码与数据库的对应关系
 'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

外键使用分表很麻烦,要先删除主表后,再删除

不常用的数据类型

 AutoField(Field)
        - int自增列,必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列,必须填入参数 primary_key=True

        注:当model中如果没有自增列,则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ~ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ~ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ~ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ~ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数, max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField):
        - 字符串类型,Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数:
            protocol,用于指定Ipv4或Ipv6, 'both',"ipv4","ipv6"
            unpack_ipv4, 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启此功能,需要protocol="both"

    URLField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)

    CommaSeparatedIntegerField(CharField)
        - 字符串类型,格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数:
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名(字符串)
            height_field=None   上传图片的宽度保存的数据库字段名(字符串)

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数:
            max_digits,小数总长度
            decimal_places,小数位长度

    BinaryField(Field)
        - 二进制类型

索引参数

进阶版

根目录下运行脚本

项目根目录下调用并运行脚本的内的函数方法,需要特殊的方法,因为配置都在项目内,需要特别的方式,才能调用函数内的环境,一般用在调试上==即环境配置==

import os,django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_name.settings")# project_name 项目名称
django.setup()
 from app66 import models    # 一定要放在以上的后面,即django启动后才能够调用

# 以上代码必须放在头部, 

if __name__ == '__main__':

    # import app66.urls
   
    ret= models.Book.objects.all()
    

queryset结果集和具体对象区别

在views中取值方式不一样,==对象查找的是属性通过.来查询,而queryset则用values进行取值==

技术图片

在反向查询时也有所区别

技术图片

==在html中布局取值方式是一样的,计数用.all再进行计数==


反向计数
    article=models.Article.objects.get(pk=1)
    &ensp; article.comment_set.all.count 

反向取值(  详情表 onetoone 文章表)
    对象在html中取值        
            article= models.Article.objects.filter(pk=pk).first()
             article.articledetail.content 
 
    
    queryset在HTML中取值(要具体到兑现,否则取不到值)
           article= models.Article.objects.filter(pk=pk).first()
            article.0.articledetail.content 

查询方式不一样,queryset用的是连表查询,而get则是基于子查询

select * from my_stu where class_id in (select id from my_class);


SELECT student_id,student.sname,avg1 as '平均分',sum1 as '总分' FROM
        (select score.student_id,avg(score.num) AS avg1 ,SUM(score.num) as sum1  from score GROUP BY student_id) AS a 
        LEFT JOIN student  on student.sid=a.student_id ;

细节比较

   try:
        ret = models.Book.objects.get(author=9)
        print("这是get查询结果".format(ret))
    except:
        pass
    ret1 = models.Book.objects.filter(author=9)

    print("这是filter查询结果".format(ret1))

filter能够查询多个,查找不到也不会报错,返回QuerySet<>空列表,取值必须用索引取值
返回的是列表,因此通过通过索引取值   ret[0]

即性能更好一些,默认一般情况下我们都是使用该方法,返回的是查询结果集
-------------------------------------
结果如下:QuerySet查询结果集

这是filter查询结果<QuerySet [<Book: Book object (132660)>, <Book: Book object (132664)>, <Book: Book object (132665)>, <Book: Book object (132666)>]>
  • 打印居中的方法
print( 1 ,center("*",100))
  • 数据更新和创建方式不一样
  • 技术图片

基于对象查询

也就是当查询结果可能是多个的时候就要用.all取所有结果,然后循环取值.

其基于子查询,即一张表的查询结果是下一个表查询条件,查询作者的名字叫钱学森的书籍

select title from Book where id in
    (select id from  author where name="钱学森")

ForeignKey外键查询

在forg外键查询时正向查询,只拿到一个对象,而反向查询,可能 拿到多个外键,好比班级学生表外键关联班主任,学生查找班主任 只可能找到一个班主任对象,班主任反向查找学生会拿到很多学生对象

student_obj=models.Student.object.filter(pk=1).first()
name = student_obj.teacher.name

也就是一对多查询时,用all

teacher_obj=models.Student.object.filter(pk=1).first()


teacher_obj.student_set.all()拿到的是一个列表集合,需要for循环才能够找到相应的属性

manytomany外键查询

好比作者和书籍之间的关系就是多对多关系

查询python这本书作者的年龄

book_obj=models.Book.object.filter(pk=1).first()




for i in book_obj.author.all()
   i.age

查询作者出版的所有书名

author_obj=models.Author.object.filter(pk=1).first()

for i in author_obj.author.all()
   i.title

一对一

文章表查询详情,因为只有一个结果,因此不需要用_set查询

article_obj=models.Article.object.filter(pk=1).first()

for i in article_obj.content.all()
   i.content

基于queryset查询

其是按照join查询

常用的13个操作

    models.Classname.objects.|前缀
<1> all():                 查询所有结果,

<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象,可以查找多个

<3> get(**kwargs):         只能返回一个结果,符合条件的有多个或者没有都会抛出异常。

<4> exclude(**kwargs):     反向查找(not in **kwargs),它包含了与所给筛选条件不匹配的对象,
 
<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列model的实例化对象,而是一个可迭代的字典序列
 
<6> values_list(*field):   它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列
 
<7> order_by(*field):      对查询结果排序
 
<8> reverse():             对查询结果反向排序,请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
 
<9> distinct():            从返回结果中剔除重复纪录(如果你查询跨越多个表,可能在计算QuerySet时得到重复的结果。此时可以使用distinct(),注意只有在PostgreSQL中支持按字段去重。)
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             如果QuerySet包含数据,就返回True,否则返回False

技术图片

时间查询

技术图片

data_form,对日期进行规范,mysql内置方法格式是

date_format(字段名,"%Y-%m")

查询字段 values(字段名,字段名),返回数据类型==[,, ]==

values_list 返回的是==列表==,只拿到值[(字段值,),(字段值,)]

ret1= models.Book.objects.values("id","title")[0:3]

ret =models.Book.objects.values_list("id","title")[0:3]
  
-----------------------------------
<QuerySet [(132654, '了凡四训'), (132655, '论语'), (132656, '史记')]>
<QuerySet ['id': 132654, 'title': '了凡四训', 'id': 132655, 'title': '论语', 'id': 132656, 'title': '史记']>
    

exclude(kwargs)相当于 not in kwargs

books = BookInfo.objects.exclude(id = 3)  # 与filter函数作用相反。 返回QuerySet查询集(可以遍历)

order_by(字段名字),排序(-num),则是倒序排序

reverse()和order_by结合实现倒序查询

  • 必须是有序的数字,否则反转不成功
  • 方法一:在创建时定义排列方式
    class Meta:
        ordering = ("id",)     #切记一定是元祖类型,后面需要添加,
  • 方法二 用order_by进行排序,再进行反转
 ret1 = models.Book.objects.filter(author=9).reverse()

distinct():去重

在查询结果中添加,可以去重,

倒序  如果字段是int 类型的,可以用order_by("-price")

count(),first(),last()计数,第一

exists():判断表中有没有数据

返回对象的是以下几种

技术图片

filter条件查询(双下划綫匹配条件)

  • ==双下划綫表示跨一张表==
  • 前面都是字段名字前缀,id_lt,即表的id起始值,另外括号里面的数据都要用双引号引起来
models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值   可以分开写
 
models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据 where id in [ ]

models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 



models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的  where name like "lc%"
     #在2.0中自动添加那个属性,自己选择那张表或者字段进行帅选

models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感,不区分大小写查询,查找英文用的
 
 
 
models.Tb1.objects.filter(id__range=[1, 3])      # id范围是1到3的,等价于SQL的bettwen and
 
 
类似的还有:startswith,istartswith, endswith, iendswith 




date字段还可以:查询某年某月某日
models.Class.objects.filter(first_day__year=2017)   

跨表查询(外键)

valuses跨表取值,必须确定是某一个对象才可以

正向查询(从主表查询外键表对应的属性)

  • **由书查询到外键对象的具体值,在后面直接添加values(字段名称__字段名称对应的属性)**
  • 技术图片



 ret2=models.Book.objects.filter(author__name__contains="钱").values("title") # 一共有四个,在多对多情况下  #条件查询可能有多个,因此要for循环,而,字段里面也可能有多个值,还需要字段,因此就有双重for循环
 
 
 
 print(models.Book.objects.filter(author__name__contains="钱").values("publish__id"))
     #直接跟人家的方法,方便,省代码

反向查找,从外键表查找对应的数据

    p_obj = models.Publish.objects.first()
    p_obj_name = p_obj.book.all()
    p_obj_name=p_obj_name.values_list("title")
    print(p_obj_name)
    

    还有一种是跨表查询 
      p_obj1 = models.Publish.objects.filter(id=1).values_list("book__title")

技术图片

正向和反向查询注意点

p_obj = models.Publish.objects.first()      all.get() #拿到的是一个具体的对象后面加点要么表示对象内的方法或者属性,没有就报错
AttributeError: 'Publish' object has no attribute 'values'

filter .all  拿到的是封装的结果集,可以调用values的方法

多对多相关方法

??表格数据可以其他表复制粘贴数据,前提是复制有多少行数据,粘贴表也要有几行空数据

对象操作

??对于所有类型的关联字段,add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说,在关联的任何一端,都不需要再调用save()方法。

create()创建

??如作者是书外键,可以通过书的某个对象通过create方法创建一个作者,并关联上通过主表添加外键和书籍,括号内填属性等于即可,即关键字传参

book_obj = models.Book.objects.first()    # 找到第一个数据对象
book_obj.author.create(name="李世光",id=12)  # 添加一个关联数据,没有就创建,   

add( )则是添加

book_obj = models.Book.objects.first()
book_obj.author.add(*[1,2,6])                          # 列表前面加*表示把列表打散开



author_objs = models.Author.objects.filter(id__lt=3)  # 通过查询找到相应的对象,也是可以插入的
models.Book.objects.first().authors.add(*author_objs)  # 用 * 表示把数据打散成单个数据

set()更新

book_obj = models.Book.objects.first()
book_obj.authors.set([2, 3])

remove和clear

对于ForeignKey对象,clear()和remove()方法仅在null=True时存在。某字段为空删除后会报错

book_obj = models.Book.objects.first()
book_obj.authors.remove(3)

book_obj.authors.clear()

组合查询(两个字段之间做比较)用F()和update(),对象字段更新

  • 字段对比
from django.db.models import F
models.Book.objects.filter(字段名__gt=F('字段名'))        # gt表示大于
  • 字段更新,注意update只能在QuerySet结果集中调用,返回的是具体对象调用不了
models.Book.objects.all().update(price=F("price")+30)  #注意update只有返回的是结果集的时候才能够用返回某一个对象则用  对象.属性名= XX  对象名.save()  进行修改



ret= models.Book.objects.filter(add__id__gt=F("num")*3)   # 地址的id大于num字段*3的数值,注意加减乘除要在F()之后

字符串追加内容也用到update

from django.db.models.functions import Concat    #对字符串拼接,
from django.db.models import Value               # 对值进行转换,像时间转化后才能进行加减


ret= models.Book.objects.filter(add__id__gt=F("num")*3).update(title=Concat(F("title"),
                                                                                Value("("),
                                                                                Value("第一版"),
                                                                                Value(")")))
value 可以有多个值,最后拼接成  book(第一版)

filter(条件1,条件2) 其中都是表示并且的关系

Q查询即或关系查询

models.Book.objects.filter(    Q(authors__name="小仙女")   |   Q(authors__name="小魔女"),title__id__gt=5   )

注意,表示且的关系,此外Q条件,必须放在最前面

aggregate聚合查询sum,max min count,只计算一个字段所有值

from django.db.models import Avg, Sum, Max, Min, Count

models.Book.objects.all().aggregate(Avg("price"))

models.Book.objects.aggregate(average_price=Avg('price'))  # 对结果重新起名字

 models.Book.objects.all().aggregate(  Avg("price")   ,    Max("price"))   可以查询多个和Value插入类似

annotate分组,分类 求该类中的相关的各类值

  • ,并对该组进行数据处理,
from django.db.models import Avg

book_list = models.Book.objects.all().annotate(author_num=Count("author")).values_list("author_num")
# 本表的author为依据进行组合,并把结果拼接到最后


# 分组用annotate,而聚合aggregate


book_list = models.Book.objects.all().annotate(author_num=Count("组合字段名字"))   # 通过某字段组合,拿到的是一个重新组合表,中所有对象结果集
for obj in book_list:
...     print(obj.author_num)
  • 对组合依据是a列,而计数的且是b列,则用外键表进行组合即可
 book_list = models.Author.objects.all().annotate(author_num=Count("book__title")).values_list("name","author_num")
 
 # 当是外键时就相当于以author为组合依据,计算他重复的个数,另外一张表的任意字段都可以
  • 注意.annotate前面拿到的数据是组合依据,annotate内知识组合取值,==这是同表==
.annotate 括号参数相当于
    select count( a ) from ---------------

而.annotate之前相当于
    select count( a ) from table_name  group_by  models.Author.objects.all()

因此需要对某一个字段进行组合,取字段即可
    select count( a ) from table_name  group_by  models.Author.objects.values(author)

count(a)就会对组合类进行计算,而其他项无法取舍,但是要是是数据则可以进行加减,情平均值

终极例子
    book_list = models.Author.objects.values("组合字段名").annotate(author_num=Count("book__title")).values_list("name","author_num")
  • ==外键组合,和上面用法一样,想要去外键表值,则通过双下划綫取值即可==
    技术图片
book_list = models.book.objects.values("外键字段名").annotate(author_num=Count("任意字段")).values_list("外键__想要去的字段","author_num")
  • 博客项目中应用
  • 技术图片
个人文章
    user1= models.UserInfo.objects.filter(username=user).first()
    if not user1:   #如果用户不存在则,---
        HttpResponse("用户不存在")
    # 如果用户存在就给页面返回一个blog对象
    user_blog=user1.blog

    #个人文章
    article_list=models.Article.objects.filter(user__username=user)   #作者所有文章
   
个人文章分类 
    category = models.Article.objects.filter(user__username=user).values("category").annotate(count=Count("category")).values_list("count","category__title")
    # 注意在跨表查询时,计算那个字段就用那个字段查询,否则数据出错
    
    tag=models.Tag.objects.filter(blog=user_blog).annotate(count=Count("article")).values_list("title","count")
    # 注意前面是以谁为判断依据,后面是计算谁,不能够用1 代替,否则结果不准,在跨表计算时,
    
    
时间取值需要先格式化后再进行组合
    time= models.Article.objects.extra(
        select="c":"date_format(create_time,'%%Y-%%m')"
    ).values("c").annotate(count=Count('title')).values_list("c","count")



select_for_update(nowait=False, skip_locked=False)

返回一个锁住行直到事务结束的查询集,如果数据库支持,它将生成一个 SELECT ... FOR UPDATE 语句。

举个例子:

entries = Entry.objects.select_for_update().filter(author=request.user)
所有匹配的行将被锁定,直到事务结束。这意味着可以通过锁防止数据被其它事务修改。

一般情况下如果其他事务锁定了相关行,那么本查询将被阻塞,直到锁被释放。 如果这不想要使查询阻塞的话,使用select_for_update(nowait=True)。 如果其它事务持有冲突的锁, 那么查询将引发 DatabaseError 异常。你也可以使用select_for_update(skip_locked=True)忽略锁定的行。 nowait和skip_locked是互斥的,同时设置会导致ValueError。

目前,postgresql,oracle和mysql数据库后端支持select_for_update()。 但是,MySQL不支持nowait和skip_locked参数。

使用不支持这些选项的数据库后端(如MySQL)将nowait=True或skip_locked=True转换为select_for_update()将导致抛出DatabaseError异常,这可以防止代码意外终止。


原子性操作(事务)

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    import datetime
    from app01 import models

    try:
        from django.db import transaction
        with transaction.atomic():                # with 里面代码都是原子性操作
            new_publisher = models.Publisher.objects.create(name="火星出版社")
            models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社id
    except Exception as e:
        print(str(e))

一对一关联(外键字段有唯一关联)

  • 使用场景

( 1 )  即本来应该就可以放在一张表的信息,现在放在两张表如不常用的消息放在一张表中,而常用的也放在一张表,比如qq中的基本信息和详细信息时分开的,当第三方工具想要提取时,就把基本信息发送即可

 detail= models.OneToOneField(to="Person_Detail",on_delete=models.CASCADE,related_name="Person")

( 2 )  保证搜索引擎的快速性,因为不需要提取全部信息

  • 查询和 外键查询是一样的

其他方法

def all(self)
    # 获取所有的数据对象

def filter(self, *args, **kwargs)
    # 条件查询
    # 条件可以是:参数,字典,Q

def exclude(self, *args, **kwargs)
    # 条件查询
    # 条件可以是:参数,字典,Q




def distinct(self, *field_names)
    # 用于distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注:只有在PostgreSQL中才能使用distinct进行去重

def order_by(self, *field_names)
    # 用于排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 构造额外的查询条件或者映射,如:子查询

    Entry.objects.extra(select='new_id': "select col from sometable where othercol > %s", select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select='new_id': "select id from tb where id > %s", select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注:如果存在order_by,reverse则是倒序,如果多个排序则一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列数据

 def only(self, *fields):
    #仅取某个表中的数据
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的数据库,参数为别名(setting中的设置)


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 执行原生SQL
    models.UserInfo.objects.raw('select * from userinfo')

    # 如果SQL是其他表时,必须将名字设置为当前UserInfo对象的主键列名
    models.UserInfo.objects.raw('select id as nid from 其他表')

    # 为原生SQL设置参数
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 将获取的到列名转换为指定列名
    name_map = 'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定数据库
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 获取每行数据为字典格式

def values_list(self, *fields, **kwargs):
    # 获取每行数据为元祖

def dates(self, field_name, kind, order='ASC'):
    # 根据时间进行某一部分进行去重查找并截取指定内容
    # kind只能是:"year"(年), "month"(年-月), "day"(年-月-日)
    # order只能是:"ASC"  "DESC"
    # 并获取转换后的时间
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根据时间进行某一部分进行去重查找并截取指定内容,将时间转换为指定时区时间
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是:"ASC"  "DESC"
    # tzinfo时区对象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet对象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函数,获取字典类型聚合结果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
   ===> 'k': 3, 'n': 4

def count(self):
   # 获取个数

def get(self, *args, **kwargs):
   # 获取单个对象

def create(self, **kwargs):
   # 创建对象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的个数
    objs = [
        models.DDD(name='r11'),
        models.DDD(name='r22')
    ]
    models.DDD.objects.bulk_create(objs, 10)


def first(self):
   # 获取第一个

def last(self):
   # 获取最后一个

def in_bulk(self, id_list=None):
   # 根据主键ID进行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 删除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有结果

select_related和prefetch_related(面试常问),

  • 把数据也加载到对象中,制作一次查询,和all的 用法一样
book = Book.objects.select_related('person').filter(pk=1)   #select_related("字段名字")

# 假设Person模型中有另外一个外键city,可作如下查询
book = Book.objects.select_related('person__city').filter(pk=1)
  • 两者作用是:

??在Django中,所有的Queryset都是惰性的,意思是当创建一个查询集的时候,并没有跟数据库发生任何交互。因此我们可以对查询集进行级联的filter等操作,只有在访问Queryset的内容的时候,Django才会真正进行数据库的访问。而多频率、复杂的数据库查询往往是性能问题最大的根源。
??当我们通过外键获取一个关联对象的时候,实际上默认获取的是关联对象的ID。如果按照默认的查询方式去遍历取值,那么会造成多次的数据库查询,效率可想而知。

  • 查找方式

( 1 )??select_related:用的是连表查询方式,进而减少查询次数,最终达到优化和提高性能效果
( 2 )??prefetch_related:用分表查询方式,把查询结果进行一定逻辑处理,克服了多对多连表导致表臃肿过长,增加运行时间和内存占用.

  • 应用场景

( 1 )??select_related主要针一对一和多对一关系进行优化。即对外键一对一和foreignkey的正向查询使用
( 2 )??** prefetch_related()的优化方式是分别查询每个表,然后用Python处理他们之间的关系,可以理解为用在反向查询比较多**

def select_related(self, *fields)
    性能相关:表之间进行join连表操作,一次性获取关联的数据。

    总结:
    1. select_related主要针一对一和多对一关系进行优化。
    2. select_related使用SQL的JOIN语句进行优化,通过减少SQL查询的次数来进行优化、提高性能。



def prefetch_related(self, *lookups)
    性能相关:多表连表操作时速度会慢,使用其执行多次SQL查询在Python代码中实现连表操作。

    总结:
    1. 对于多对多字段(ManyToManyField)和一对多字段,可以使用prefetch_related()来进行优化。
    2. prefetch_related()的优化方式是分别查询每个表,然后用Python处理他们之间的关系。

def annotate(self, *args, **kwargs)
    # 用于实现聚合group by查询

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

get_or_create和update_or_create

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在,则获取,否则,创建
    # defaults 指定创建时,其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults='email': '1111111','u_id': 2, 't_id': 2)

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在,则更新,否则,创建
    # defaults 指定创建时或更新时的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults='email': '1111111','u_id': 2, 't_id': 1)

批量创建bulk_create,减少数据库的链接次数

 obj=[models.Book(                                       [print(i) for i in range(10) ]     类似 语句for循环
         title="韩非子第部".format(i),
         price=i,publisher_id=1,
         id = 20+i,publish_date=2017-12-8,
         memo="上海街".format(i)) 
 for i in range(20)]
 
 models.Book.objects.bulk_create(obj,10)     # 10  一次性插入10次

in_bulk根据主键id查找

   # 根据主键ID进行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

在脚本中调用Django环境

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()
from app01 import models    # 注意一定要导入django环境后才能导入项目里面的模块,否则会报错


if __name__ == '__main__':

    

    books = models.Book.objects.all()
    print(books)

练习

# 书
class Book(models.Model):
    title = models.CharField(max_length=32)
    publish_date = models.DateField(auto_now_add=True)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    memo = models.TextField(null=True)
    # 创建外键,关联publish
    publisher = models.ForeignKey(to="Publisher")
    # 创建多对多关联author
    author = models.ManyToManyField(to="Author")

    def __str__(self):
        return self.title


# 出版社
class Publisher(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)

    def __str__(self):
        return self.name


# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    phone = models.CharField(max_length=11)
    detail = models.OneToOneField(to="AuthorDetail")

    def __str__(self):
        return self.name


# 作者详情
class AuthorDetail(models.Model):
    addr = models.CharField(max_length=64)
    email = models.EmailField()
查找所有书名里包含番茄的书
查找出版日期是2017年的书
查找出版日期是2017年的书名
查找价格大于10元的书
查找价格大于10元的书名和价格
查找memo字段是空的书

查找在北京的出版社
查找名字以沙河开头的出版社

查找作者名字里面带“小”字的作者
查找年龄大于30岁的作者
查找手机号是155开头的作者
查找手机号是155开头的作者的姓名和年龄

查找书名是“番茄物语”的书的出版社
查找书名是“番茄物语”的书的出版社所在的城市
查找书名是“番茄物语”的书的出版社的名称

查找书名是“番茄物语”的书的所有作者
查找书名是“番茄物语”的书的作者的年龄
查找书名是“番茄物语”的书的作者的手机号码

查找书名是“番茄物语”的书的作者的地址
查找书名是“番茄物语”的书的作者的邮箱
 print(models.Book.objects.filter(publish_date__year=2020))
print(models.Book.objects.filter(publish_date__year=2020).values_list("title")[0])
print(models.Book.objects.filter(publisher__book__price__gt=60))
print(models.Book.objects.filter(memo=""))
print(models.Book.objects.filter(publisher__city="北京"))
print(models.Book.objects.filter(publisher__name__startswith="广西"))
print(models.Author.objects.filter(name__contains="三"))
print(models.Author.objects.filter(age__gt=53))
print(models.Author.objects.filter(phone__startswith="15"))
print(models.Author.objects.filter(phone__startswith="15").values_list("name","age"))
print(models.Author.objects.filter(phone__startswith="15").values_list("name","age"))
print(models.Book.objects.filter(title="西游记").values("publisher"))
print(models.Publisher.objects.filter(book__title="韩非子").values("city"))
print(models.Publisher.objects.filter(book__title="韩非子").values("name"))

技术图片

distinct

在查询结果中添加,可以去重,

倒序  如果字段是int 类型的,可以用order_by("-price")

自己写SQL语句查询

子查询

也就是给表添加一个字段,查询工资大于0,一般用在增加字段后查询,组合

查询大于某数的
    Book.objects.all().extra(
            "gt":"salary > 2000" 
    )
    select (salary > 2000) as "gt",id--- from Book     # 相当于多加一个字段,并返回0或者1

对时间格式化后分组

格式化时间
    ret =models.Article.objects.extra(
            select="c":"date_format(create_time,'%%Y-%%m')"
        ).

格式化时间再进行组合
     ret =models.Article.objects.extra(
            select="c":"date_format(create_time,'%%Y-%%m')"
        ).values("c").annotate(count=Count('title')).values_list("c","count")

注意date_format()中的字段参数是没有括号的,组合前面查询出来的字段就是组合依据,查询表就是返回对象


Book.objects.extra(select='new_id': "select col from sometable where othercol > %s", select_params=(1,))
    
    
    
    
    
Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
Entry.objects.extra(select='new_id': "select id from tb where id > %s", select_params=(1,), order_by=['-nid'])

原生查询(在插入数据或者更新时效率高)

有时候raw()方法并不十分好用,很多情况下我们不需要将查询结果映射成模型,或者我们需要执行DELETE、 INSERT以及UPDATE操作。在这些情况下,我们可以直接访问数据库,完全避开模型层。

# 直接导入connection,不用自己连接,其他方法都是一样的
from django.db import connection, connections
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()

技术图片

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

ORM版,单表查询

Django ORM查询总结

Django-ORM-多表操作

Django_ORM数据表查询总结

django orm总结--解决查询结果不区分大小写问题

ORM 查询