ORM查询总结版

目录

• 概要
  • ORM常用字段
• ORM基础
  • 自定义一个插入类型,即固定长度
  • 创建类终极版
    • 多对多关系表创建
  • 常用几个代码
  • 参数
• ORM与数据库代码对应的关系
  • 外键使用分表很麻烦,要先删除主表后,再删除
  • 不常用的数据类型
  • 索引参数
• 进阶版
  • 根目录下运行脚本
  • queryset结果集和具体对象区别
    • 基于对象查询
    • 基于queryset查询
  • 常用的1个操作
    • 时间查询
    • 查询字段 values(字段名,字段名),返回数据类型==[{},{},{} ]==
    • values_list 返回的是==列表==,只拿到值[(字段值,),(字段值,)]
    • exclude(kwargs)相当于 not in kwargs
    • order_by(字段名字),排序(-num),则是倒序排序
    • reverse()和order_by结合实现倒序查询
    • distinct():去重
    • count(),first(),last()计数,第一
    • exists():判断表中有没有数据
    • 返回对象的是以下几种
  • filter条件查询(双下划綫匹配条件)
• 跨表查询(外键)
  • 正向查询(从主表查询外键表对应的属性)
  • 反向查,从外键表查对应的数据
  • 正向和反向查询注意点
  • 多对多相关方法
  • 对象操作
    • create()创建
    • add( )则是添加
    • set()更新
    • remove和clear
  • 组合查询(两个字段之间做比较)用F()和update(),对象字段更新
    • 字符串追加内容也用到update
    • filter(条件1,条件2) 其中都是表示并且的关系
  • Q查询即或关系查询
  • aggregate聚合查询sum,max min count,只计算一个字段所有值
  • annotate分组,分类 求该类中的相关的各类值
  • 锁
  • 原子性操作(事务)
• 一对一关联(外键字段有唯一关联)
• 其他方法
  • select_related和prefetch_related(面试常问),
  • get_or_create和update_or_create
  • 批量创建bulk_create,减少数据库的链接次数
  • in_bulk根据主键id查
• 在脚本中调用Django环境
• 练习
• distinct
• 自己写SQL语句查询
  • 子查询
  • 原生查询(在插入数据或者更新时效率高)

目录

概要

ORM常用字段

常用字段1   AutoFile( primary_key=Ture)2   Charfiled(max_length= 12)   IntgerFile ()4   DateFile()5   DatetimeFlieROM 常用1个操作( 1 ) 返回QuerySet对象的有1 all( )2 filter( ) values( )4 values_list( )5 exclude( )6 order_by( )7 distinct( )8 reverse( )( 2 ) 返回对象的有1 all( ).get( )2 all( ).first( ) all( ).last( )(  ) 返回布尔值的1 exists ( ) ( 4 ) 返回具体数据的1 count( )条件查询1 id__gt=                大于    id__lt( 小于)2 id__in=                在[1,2,21,12,221] id__contains=lc      包含内容的4 id__startwith=钱     以钱开头的5 id__endswitch= 娜    ....6 date__year=2017        年份是2017的(day month)7  id__icontains=lc   不区分大小写跨表查询 ( 1 ) 基于对象查询book_obj = models.get( id = 1) name = book.   ( 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_lengthdef db_type(self, connection):    #定义函数返回类的方法限定生成数据库表的字段类型为char，长度为length指定的值return 	char(%s)	 % self.lengthclass 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_lengthdef db_type(self, connection):    #定义函数返回类的方法限定生成数据库表的字段类型为char，长度为length指定的值return 	char(%s)	 % self.lengthclass 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()                                             #intdata=models.DateField(auto_now=datetime.())    # 时间格式,自定义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=0)def __str__(self):return name:{},phone{}.format(,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=0)man = models.ManyToManyField(to=	Man	, related_name=wonman,through=Man_to_Wonman,through_fields=(woman,man))def __str__(self):return name:{},phone{}.format(,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.())man = models.ForeignKey(to=Man,on_delete=models.CASCADE)woman= models.ForeignKey(to=Wonman,on_delete=models.CASCADE)def __str__(self):returnclass 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,

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

查的方法还保留有ORM的方法第三张表还可以记录其他信息,而不单单是只有主键和外键的id,因此删除修改数据则在第三张表进行删除   第三张表.object.all( ).get(id=主键表_id,id = 外键表_id)     拿到对应行对象进行增删改

常用几个代码

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

参数

官方网址 .0/ref/models/opti/

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

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

 	AutoField	: 	integer AUTO_ICREMET	,	BigAutoField	: 	bigint AUTO_ICREMET	,	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(9)	,	ullBooleanField	: 	bool	,	OneToOneField	: 	integer	,	PositiveIntegerField	: 	integer USIGED	,	PositiveSmallIntegerField	: 	smallint USIGED	,	SlugField	: 	varchar(%(max_length)s)	,	SmallIntegerField	: 	smallint	,	TextField	: 	longtext	,	TimeField	: 	time	,	UUIDField	: 	char(2)	,

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

不常用的数据类型

 AutoField(Field)- int自增列，必须填入参数 primary_key=TrueBigAutoField(AutoField)- bigint自增列，必须填入参数 primary_key=True注：当model中如果没有自增列，则自动会创建一个列名为id的列from django.db import modelsclass UserInfo(models.Model):# 自动创建一个列名为id的且为自增的整数列username = models.CharField(max_length=2)class Group(models.Model):# 自定义自增列nid = models.AutoField(primary_key=True)name = models.CharField(max_length=2)SmallIntegerField(IntegerField):- 小整数 -2768 ～ 2767PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正小整数 0 ～ 2767IntegerField(Field)- 整数列(有符号的) -214748648 ～ 214748647PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正整数 0 ～ 214748647BigIntegerField(IntegerField):- 长整型(有符号的) -9227206854775808 ～ 9227206854775807BooleanField(Field)- 布尔值类型ullBooleanField(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,ipv6unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol=bothURLField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证 URLSlugField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）CommaSeparatedIntegerField(CharField)- 字符串类型，格式必须为逗号分割的数字UUIDField(Field)- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证FilePathField(Field)- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能- 参数：path,                      文件夹路径match=one,                正则匹配recursive=False,           递归下面的文件夹allow_files=True,          允许文件allow_folders=False,       允许文件夹FileField(Field)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to =       上传文件的保存路径storage = one      存储组件，默认files.storage.FileSystemStorageImageField(FileField)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to =       上传文件的保存路径storage = one      存储组件，默认files.storage.FileSystemStoragewidth_field=one,   上传图片的高度保存的数据库字段名（字符串）height_field=one   上传图片的宽度保存的数据库字段名（字符串）DateTimeField(DateField)- 日期时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]DateField(DateTimeCheckMixin, Field)- 日期格式      YYYY-MM-DDTimeField(DateTimeCheckMixin, Field)- 时间格式      HH:MM[:ss[.uuuuuu]]DurationField(Field)- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为类型FloatField(Field)- 浮点型DecimalField(Field)- 10进制小数- 参数：max_digits，小数总长度decimal_places，小数位长度BinaryField(Field)- 二进制类型

索引参数

进阶版

根目录下运行脚本

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

import os,django
setdefault(DJAGO_SETTIGS_MODULE, project_name.settings)# project_name 项目名称
django.setup()from app66 import models    # 一定要放在以上的后面,即django启动后才能够调用# 以上代码必须放在头部, if __name__ == 	__main__	:# import app66.urlsret= models.all()

queryset结果集和具体对象区别

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

在反向查询时也有所区别

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

反向计数article=models.get(pk=1) {{ articlement_set. }}反向取值(  详情表 onetoone 文章表)对象在HTML中取值        article= models.filter(pk=pk).first(){{ article. }}queryset在HTML中取值(要具体到兑现,否则取不到值)article= models.filter(pk=pk).first(){{ article.0. }}

查询方式不一样,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() AS avg1 ,SUM() as sum1  from score GROUP BY student_id) AS a LEFT JOI student  on student.sid=a.student_id ;

细节比较

   try:ret = models.get(author=9)print(这是get查询结果{}.format(ret))except:passret1 = models.filter(author=9)print(这是filter查询结果{}.format(ret1))filter能够查询多个,查不到也不会报错,返回QuerySet<>空列表,取值必须用索引取值
返回的是列表,因此通过通过索引取值   ret[0]即性能更好一些,默认一般情况下我们都是使用该方法,返回的是查询结果集
-------------------------------------
结果如下:QuerySet查询结果集这是filter查询结果<QuerySet [<Book: Book object (12660)>, <Book: Book object (12664)>, <Book: Book object (12665)>, <Book: Book object (12666)>]>

• 打印居中的方法

print( 1 ,center(*,100))

• 数据更新和创建方式不一样

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

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

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

ForeignKey外键查询

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

student_obj=models.filter(pk=1).first()
name = student_

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

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

manytomany外键查询

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

查询python这本书作者的年龄

book_obj=models.filter(pk=1).first()for i in book_obj.author.all()i.age

查询作者出版的所有书名

author_obj=models.filter(pk=1).first()for i in author_obj.author.all()

一对一

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

article_obj=models.filter(pk=1).first()for i in article_all()

其是按照join查询

常用的1个操作

    models.|前缀
<1> all():                 查询所有结果,<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象,可以查多个<> 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():               返回最后一条记录<1> exists():             如果QuerySet包含数据，就返回True，否则返回False

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

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

ret1= models.values(id,title)[0:]ret =models.values_list(id,title)[0:]-----------------------------------
<QuerySet [(12654, 	了凡四训	), (12655, 	论语	), (12656, 	史记	)]>
<QuerySet [{	id	: 12654, 	title	: 	了凡四训	}, {	id	: 12655, 	title	: 	论语	}, {	id	: 12656, 	title	: 	史记	}]>

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

• 必须是有序的数字,否则反转不成功
• 方法一:在创建时定义排列方式

    class Meta:ordering = (id,)     #切记一定是元祖类型,后面需要添加,

• 方法二 用order_by进行排序,再进行反转

 ret1 = models.filter(author=9).reverse()

在查询结果中添加,可以去重,倒序  如果字段是int 类型的,可以用order_by(-price)

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

• ==双下划綫表示跨一张表==
• 前面都是字段名字前缀,id_lt,即表的id起始值,另外括号里面的数据都要用双引号引起来

models.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值   可以分开写models.filter(id__in=[11, 22, ])   # 获取id等于11、22、的数据 where id in [ ]models.exclude(id__in=[11, 22, ])  # not inmodels.filter(name__contains=ven)  # 获取name字段包含ven的  where name like lc%#在2.0中自动添加那个属性,自己选择那张表或者字段进行帅选models.filter(name__icontains=ven) # icontains大小写不敏感,不区分大小写查询,查英文用的models.filter(id__range=[1, ])      # id范围是1到的，等价于SQL的bettwen and类似的还有：startswith，istartswith, endswith, iendswith　date字段还可以：查询某年某月某日
models.filter(first_day__year=2017)   

跨表查询(外键)

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

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

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

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

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

    p_obj = models.first()p_obj_name = p_obj.book.all()p_obj_name=p_obj_name.values_list(title)print(p_obj_name)还有一种是跨表查询 p_obj1 = models.filter(id=1).values_list(book__title)

正向和反向查询注意点

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

多对多相关方法

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

对象操作

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

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

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

book_obj = models.first()
book_obj.author.add(*[1,2,6])                          # 列表前面加*表示把列表打散开author_objs = models.filter(id__lt=)  # 通过查询到相应的对象,也是可以插入的
models.first().authors.add(*author_objs)  # 用 * 表示把数据打散成单个数据

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

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

book_obj = models.first()
book_obj.authors.remove()book_obj.()

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

• 字段对比

from django. import F
models.filter(字段名__gt=F(	字段名	))        # gt表示大于

• 字段更新,注意update只能在QuerySet结果集中调用,返回的是具体对象调用不了

models.all().update(price=F(price)0)  #注意update只有返回的是结果集的时候才能够用返回某一个对象则用  对象.属性名= XX  对象名.save()  进行修改ret= models.filter(add__id__gt=F(num)*)   # 地址的id大于num字段*的数值,注意加减乘除要在F()之后

from django..functi import Concat    #对字符串拼接,
from django. import Value               # 对值进行转换,像时间转化后才能进行加减ret= models.filter(add__id__gt=F(num)*).update(title=Concat(F(title),Value((),Value(第一版),Value())))
value 可以有多个值,最后拼接成  book(第一版)

Q查询即或关系查询

models.filter(    Q(authors__name=小仙女)   |   Q(authors__name=小魔女),title__id__gt=5   )注意,表示且的关系,此外Q条件,必须放在最前面

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

from django. import Avg, Sum, Max, Min, Countmodels.all().aggregate(Avg(price))models.aggregate(average_price=Avg(	price	))  # 对结果重新起名字models.all().aggregate(  Avg(price)   ,    Max(price))   可以查询多个和Value插入类似

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

• ,并对该组进行数据处理,

from django. import Avgbook_list = models.all().annotate(author_num=Count(author)).values_list(author_num)
# 本表的author为依据进行组合,并把结果拼接到最后# 分组用annotate,而聚合aggregatebook_list = models.all().annotate(author_num=Count(组合字段名字))   # 通过某字段组合,拿到的是一个重新组合表,中所有对象结果集
for obj in book_list:
...     print(obj.author_num)

• 对组合依据是a列,而计数的且是b列,则用外键表进行组合即可

 book_list = models.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.all()因此需要对某一个字段进行组合,取字段即可select count( a ) from table_name  group_by  models.values(author)count(a)就会对组合类进行计算,而其他项无法取舍,但是要是是数据则可以进行加减,情平均值终极例子book_list = models.values(组合字段名).annotate(author_num=Count(book__title)).values_list(name,author_num)

• ==外键组合,和上面用法一样,想要去外键表值,则通过双下划綫取值即可==
  

book_list = models.values(外键字段名).annotate(author_num=Count(任意字段)).values_list(外键__想要去的字段,author_num)

• 博客项目中应用

个人文章user1= models.filter(username=user).first()if not user1:   #如果用户不存在则,---HttpRespe(用户不存在)# 如果用户存在就给页面返回一个blog对象user_blog=user1.blog#个人文章article_list=models.filter(user__username=user)   #作者所有文章个人文章分类 category = models.filter(user__username=user).values(category).annotate(count=Count(category)).values_list(count,category__title)# 注意在跨表查询时,计算那个字段就用那个字段查询,否则数据出错tag=models.filter(blog=user_blog).annotate(count=Count(article)).values_list(title,count)# 注意前面是以谁为判断依据,后面是计算谁,不能够用1 代替,否则结果不准,在跨表计算时,时间取值需要先格式化后再进行组合time= models.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 = 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 osif __name__ == 	__main__	:setdefault(DJAGO_SETTIGS_MODULE, BMS.settings)import djangodjango.setup()import datetimefrom app01 import modelstry:from django.db import transactionwith transaction.atomic():                # with 里面代码都是原子性操作new_publisher = models.(name=火星出版社)models.create(title=橘子物语, publish_date=datetime.(), publisher_id=10)  # 指定一个不存在的出版社idexcept 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)# 条件查询# 条件可以是：参数，字典，Qdef exclude(self, *args, **kwargs)# 条件查询# 条件可以是：参数，字典，Qdef distinct(self, *field_names)# 用于distinct去重models.values(	nid	).distinct()# select distinct nid from userinfo注：只有在PostgreSQL中才能使用distinct进行去重def order_by(self, *field_names)# 用于排序models.all().order_by(	-id	,	age	)def extra(self, select=one, where=one, params=one, tables=one, order_by=one, select_params=one)# 构造额外的查询条件或者映射，如：子查询extra(select={	new_id	: select col from sometable where othercol > %s}, select_params=(1,))extra(where=[	headline=%s	], params=[	Lennon	])extra(where=[foo=	a	 OR bar = 	a	, baz = 	a	])extra(select={	new_id	: select id from tb where id > %s}, select_params=(1,), order_by=[	-nid	])def reverse(self):# 倒序models.all().order_by(	-nid	).reverse()# 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序def defer(self, *fields):models.defer(	username	,	id	)或models.filter(...).defer(	username	,	id	)#映射中排除某列数据def only(self, *fields):#仅取某个表中的数据models.only(	username	,	id	)或models.filter(...).only(	username	,	id	)def using(self, alias):指定使用的数据库，参数为别名（setting中的设置）##################################################
# PUBLIC METHODS THAT RETUR A QUERYSET SUBCLASS #
##################################################def raw(self, raw_query, params=one, translati=one, using=one):# 执行原生SQLmodels.raw(	select * from userinfo	)# 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名models.raw(	select id as nid from 其他表	)# 为原生SQL设置参数models.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	}raw(	SELECT * FROM some_other_table	, translati=name_map)# 指定数据库models.raw(	select * from userinfo	, using=default)################### 原生SQL ###################from django.db import connection, connecticursor = ()  # cursor = connecti[	default	].cursor()(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.dates(	ctime	,	day	,	DESC	)def datetimes(self, field_name, kind, order=	ASC	, tzinfo=one):# 根据时间进行某一部分进行去重查并截取指定内容，将时间转换为指定时区时间# kind只能是 year, month, day, hour, minute, second# order只能是：ASC  DESC# tzinfo时区对象models.datetimes(	ctime	,	hour	,tzinfo=pytz.UTC)models.datetimes(	ctime	,	hour	,tzinfo=(	Asia/Shanghai	))pip install pytzimport pytzpytz.all_timezones(‘Asia/Shanghai’)def none(self):# 空QuerySet对象####################################
# METHODS THAT DO DATABASE QUERIES #
####################################def aggregate(self, *args, **kwargs):# 聚合函数，获取字典类型聚合结果from django. import Count, Avg, Max, Min, Sumresult = models.aggregate(k=Count(	u_id	, distinct=True), n=Count(	nid	))===> {	k	: , 	n	: 4}def count(self):# 获取个数def get(self, *args, **kwargs):# 获取单个对象def create(self, **kwargs):# 创建对象def bulk_create(self, objs, batch_size=one):# 批量插入# batch_size表示一次插入的个数objs = [models.DDD(name=	r11	),models.DDD(name=	r22	)]models.bulk_create(objs, 10)def first(self):# 获取第一个def last(self):# 获取最后一个def in_bulk(self, id_list=one):# 根据主键ID进行查id_list = [11,21,1]models.in_bulk(id_list)def delete(self):# 删除def update(self, **kwargs):# 更新def exists(self):# 是否有结果

select_related和prefetch_related(面试常问),

• 把数据也加载到对象中,制作一次查询,和all的 用法一样

book = select_related(	person	).filter(pk=1)   #select_related(字段名字)# 假设Person模型中有另外一个外键city,可作如下查询
book = 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的JOI语句进行优化，通过减少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. import Count, Avg, Max, Min, Sumv = models.values(	u_id	).annotate(uid=Count(	u_id	))# SELECT u_id, COUT(ui) AS `uid` FROM UserInfo GROUP BY u_idv = models.values(	u_id	).annotate(uid=Count(	u_id	)).filter(uid__gt=1)# SELECT u_id, COUT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1v = models.values(	u_id	).annotate(uid=Count(	u_id	,distinct=True)).filter(uid__gt=1)# SELECT u_id, COUT( DISTICT 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=one, **kwargs):# 如果存在，则获取，否则，创建# defaults 指定创建时，其他字段的值obj, created = models.get_or_create(username=	root1	, defaults={	email	: 	1111111	,	u_id	: 2, 	t_id	: 2})def update_or_create(self, defaults=one, **kwargs):# 如果存在，则更新，否则，创建# defaults 指定创建时或更新时的其他字段obj, created = models.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 = 20i,publish_date=2017-12-8,memo=上海{}街.format(i)) for i in range(20)]models.bulk_create(obj,10)     # 10  一次性插入10次

in_bulk根据主键id查

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

在脚本中调用Django环境

import os
setdefault(DJAGO_SETTIGS_MODULE, BMS.settings)
import django
django.setup()
from app01 import models    # 注意一定要导入django环境后才能导入项目里面的模块,否则会报错if __name__ == 	__main__	:books = models.all()print(books)

练习

# 书
class Book(models.Model):title = models.CharField(max_length=2)publish_date = models.DateField(auto_now_add=True)price = models.DecimalField(max_digits=5, decimal_places=2)memo = models.TextField(null=True)# 创建外键，关联publishpublisher = models.ForeignKey(to=Publisher)# 创建多对多关联authorauthor = models.ManyToManyField(to=Author)def __str__(self):return # 出版社
class Publisher(models.Model):name = models.CharField(max_length=2)city = models.CharField(max_length=2)def __str__(self):return # 作者
class Author(models.Model):name = models.CharField(max_length=2)age = models.IntegerField()phone = models.CharField(max_length=11)detail = models.OneToOneField(to=AuthorDetail)def __str__(self):return # 作者详情
class AuthorDetail(models.Model):addr = models.CharField(max_length=64)email = models.EmailField()

查所有书名里包含番茄的书
查出版日期是2017年的书
查出版日期是2017年的书名
查价格大于10元的书
查价格大于10元的书名和价格
查memo字段是空的书查在北京的出版社
查名字以沙河开头的出版社查作者名字里面带“小”字的作者
查年龄大于0岁的作者
查手机号是155开头的作者
查手机号是155开头的作者的姓名和年龄查书名是“番茄物语”的书的出版社
查书名是“番茄物语”的书的出版社所在的城市
查书名是“番茄物语”的书的出版社的名称查书名是“番茄物语”的书的所有作者
查书名是“番茄物语”的书的作者的年龄
查书名是“番茄物语”的书的作者的手机号码查书名是“番茄物语”的书的作者的地址
查书名是“番茄物语”的书的作者的邮箱

 print(models.filter(publish_date__year=2020))
print(models.filter(publish_date__year=2020).values_list(title)[0])
print(models.filter(publisher__book__price__gt=60))
print(models.filter(memo=))
print(models.filter(publisher__city=北京))
print(models.filter(publisher__name__startswith=广西))
print(models.filter(name__contains=三))
print(models.filter(age__gt=5))
print(models.filter(phone__startswith=15))
print(models.filter(phone__startswith=15).values_list(name,age))
print(models.filter(phone__startswith=15).values_list(name,age))
print(models.filter(title=西游记).values(publisher))
print(models.filter(book__title=韩非子).values(city))
print(models.filter(book__title=韩非子).values(name))

distinct

在查询结果中添加,可以去重,倒序  如果字段是int 类型的,可以用order_by(-price)

自己写SQL语句查询

子查询

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

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

对时间格式化后分组

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

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

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

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

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

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

转载于:.html