Django之ORM表操纵
ORM表操纵1.ORM单表操纵
首先想操纵表的增删改查，必要先导入这个表,以之前创建的UserInfo表为例,在app下的views.py中导入
from app import models
def query(request):
new_obj = models.UserInfo(
id=1,
name='北北',
bday='2019-09-27',
checked=1,
)
new_obj.save()
return HttpResponse('ok')
如许就创建了一条记载
增加
方式1:
obj = models.UserInfo(
id = 2,
name = '京京',
bday = '2019-9-27',
checked = '1',
)
obj.save()
方式2:
ret = models.UserInfo.objects.create(
name = '欢欢',
bady = '2019-9-27',
checked = 0,
)
print(ret)#UserInfo object
#ret 是创建的新的记录的model对象
ps:批量插入(bulk_create)
obj_list= []
for i in range(20):
obj = models.Book(
title=f"西游记{i}",
price=20+i,
publish_date=f"2019-09-{i+1}",
publisher="人民出版社"
)
obj_list.append(obj)
models.Book.objects.bulk_create(obj_list)#批量创建
从前端页面获取到的数据即:request.POST得到的是querydict类型
data = request.POST.dict() --能够将querydict转换成普通的字典
创建数据时可以:
models.Book.objects.create(**data)
删除
首先要通过简单查询:filter()-- 查询结果是queryset类型的数据,里面是一个个的model对象,此数据类型类似于列表
方式1:
models.UserInfo.objects.filter(id = 3).delete()
#通过queryset对象删除
方式2:
models.UserInfo.objects.filter(id = 3).delete()
#通过model对象删除
修改
方式1:
models.UserInfo.objects.filter(id = 2).update(
name = '英英',
checked = 0,
)
#通过queryset对象进行修改,而model对象不能调用update方法
方式2:
ret = models.UserInfo.objects.filter(id = 2)
ret.name = '英英'
ret.checked = 0
ret.save()
查找
查询API
1.all() 查询所有结果,得到的是queryset类型
ret = models.UserInfo.objects.all()
2.filter(**kwargs)它包含了与所给筛选条件相匹配的对象,结果也是queryset类型
ret = models.UserInfo.objects.filter(name='英英' checked=0)
#and多条件查询
#查询条件不能匹配到数据时,不会报错,会返回一个空的query(<QuerySet []>),如果没有写查询条件会获取所有数据,queryset类型的数据还能继续调用filter方法
3.get(**kwargs)
ret = models.UserInfo.objects.get(name='英英')
#得到的是一个model对象(行记录对象),有且只能有一个
#1.查不到数据会报错:UserInfo matching query does noe exist.
#2.超过一个也会报错:returned more than one UserInfo
4.exclude(**kwargs) 排除,它包含了与所给筛选条件不匹配的对象,返回的时queryset类型
ret = models.UserInfo.objects.exclude(name='英英')
#1.object能够调用models.UserInfo.objects.exclude(name__startswith=='贝贝')
#2.queryset类型数据能够调用models.UserInfo.objects.all().exclude(name__startswith=='贝贝')
5.order_by(*filed)queryset类型的数据来调用，对查询结果排序,默认是按照id来升序排列的，返回值还是queryset类型
ret = models.UserInfo.objects.all().order_by('-grade','id')
#按成绩降序排列,成绩相同的按id升序排列
6.reverse()queryset类型的数据来调用,对查询结果反向排序,返回值还是queryset类型
ret = models.UserInfo.objects.all().order_by().reverse()
#数据排序后才能进行反装
7.count() queryset类型的数据来调用，返回数据库中匹配查询(QuerySet)的对象数量。
ret = models.UserInfo.objects.all().count()
8.first() queryset类型的数据来调用,返回第一条记录
ret = models.UserInfo.objects.all().first()
9.last() queryset类型的数据来调用,返回最后一条记录
ret = models.UserInfo.objects.all().last()
10.exists() queryset类型的数据来调用,如果queryset包含数据,就返回True,否则返回False
ret = models.UserInfo.objects.filter(id=9).exists()
#判断返回结果集是不是有数据
11.values(*filed)
#queryset类型的数据来调用，返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列,只要是返回的queryset类型，就可以继续链式调用queryset类型的其他的查找方法，其他方法也是一样的。
ret=models.UserInfo.objects.filter(id=2).values('name','bday')
12.values_list(*filed)
#它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
ret=models.UserInfo.objects.all().values_list('name','bday')
#调用values或者values_list的是objects控制器,那么返回所有数据
# ret = models.Book.objects.all().values()
# ret = models.Book.objects.values()
13.distinct() #values和values_list得到的queryset类型的数据来调用，从返回结果中剔除重复记录
ret = models.UserInfo.objects.all().values('checked').distinct()
基于双下划线的含糊查询
ret = models.Book.objects.filter(price__gt=35)#大于
ret = models.Book.objects.filter(price__gte=35) # 大于等于
ret = models.Book.objects.filter(price__lt=35) # 小于等于
ret = models.Book.objects.filter(price__lte=35) # 小于等于
ret = models.Book.objects.filter(price__range=)
# 大于等35,小于等于38 where price between 35 and 38
ret = models.Book.objects.filter(price__in=)
# price值等于这三个值里面的任意一个的对象 or
ret = models.Book.objects.filter(title__contains='西游记')
# 字段数据中包含这个字符串的数据都要
ret = models.Book.objects.filter(title__icontains="python") # 不区分大小写
ret = models.Book.objects.filter(title__startswith="py")
# 以什么开头，istartswith不区分大小写
ret = models.Book.objects.filter(publish_date='2019-09-15')
#按照日期查询
查询某年某月某日:
ret = models.Book.objects.filter(publish_date__year='2018')
#2018写数字也可以
ret = models.Book.objects.filter(publish_date__year__gt='2018')
#查询出版日期大于2018年的
ret = models.Book.objects.filter(publish_date__year='2019',publish_date__month='8',publish_date__day='1')
#查询出版日期为2019-8-1的
找字段数据为空的双下滑线
ret = models.Book.objects.filter(publish_date__isnull=True) #这个字段值为空的那些数据
插入时间问题
在表的结构里新增列来显示时间
class UserInfo(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=10)
bday = models.DateField()
checked = models.BooleanField()
# now = models.DateTimeField(null=True)
now = models.DateTimeField(auto_now_add=True,null=True)
#自动插入时间
now2 = models.DateTimeField(auto_now=True,null=True)
# 更新记录时,自动添加更新时的时间,创建新纪录时也会帮你自动添加创建时的时间
在提交后进行新增记录:
import datetime
current_date = datetime.datetime.now()
models.UserInfo.objects.create(
name='妮妮',
bday=current_date,
now=current_date,# 自己手动直接插入时间没有时区问题
checked=0
)
#但是如果让这个字段自动来插入时间,就会有时区的问题,auto_now_add创建记录时自动添加当前创建记录时的时间,存在时区问题
now = models.DateTimeField(auto_now_add=True,null=True)
解决方法:
settings配置文件中将USE_TZ的值改为False
USE_TZ = False
# 告诉mysql存储时间时按照当地时间来寸,不要用utc时间
使用pycharm的数据库客户端的时候,时区问题要注意
更新时的auto_now参数
# 更新记录时,自动更新时间,创建新纪录时也会帮你自动添加创建时的时间,但是在更新时只有使用save方法的model对象的形式更新才能自动更新时间,有缺陷,放弃
now2 = models.DateTimeField(auto_now=True,null=True)
2.ORM多表操纵
创建模型
表和表之间的关系
一对一、多对一、多对多 ，用book表和publish表自己来想想关系，想想内里的操纵，加外键束缚和不加外键束缚的区别，一对一的外键束缚是在一对多的束缚上加上唯一束缚。
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名和年事。
作者具体模型：把作者的详情放到详情表，包罗生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）
出版商模型：出版商有名称，地点城市以及email。
书籍模型： 书籍有书名和出版日期，一本书大概会有多个作者，一个作者也可以写多本书，以是作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，以是出版商和书籍是一对多关联关系(one-to-many)。
模型建立如下：
from django.db import models
# Create your models here.
class Author(models.Model):
'''
作者表
'''
name=models.CharField(max_length=32)
age=models.IntegerField()
au=models.OneToOneField('AuthorDetail',on_delete=models.CASCADE)
#就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为authorDetail_id
# 与AuthorDetail建立一对一的关系，一对一的这个关系字段写在两个表的任意一个表里面都可以
class AuthorDetail(models.Model):
'''
作者详细信息表
'''
birthday=models.DateField()
telephone=models.BigIntegerField()
addr=models.CharField( max_length=64)
class Publish(models.Model):
'''
出版社表
'''
name=models.CharField( max_length=32)
city=models.CharField( max_length=32)
#class Meta:
#db_table='authordetail'--指定表名
#ordering=['id'] --指定排序方式
#多对多的表关系，手动创建一个第三张表，然后写上两个字段，每个字段外键关联到另外两张多对多关系的表，orm的manytomany自动帮我们创建第三张表，两种方式建立关系都可以，手动创建的第三张表进行orm操作的时候，很多关于多对多关系的表之间的orm语句方法无法使用,如果想删除某张表，只需要将这个表注销掉，然后执行那两个数据库同步指令就可以了，自动就删除了。
class Book(models.Model):
'''
书籍表
'''
title = models.CharField( max_length=32)
publishDate=models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2)
publishs=models.ForeignKey(to='Publish',on_delete=models.CASCADE)
authors=models.ManyToManyFiled('Author',)
# foreignkey里面可以加很多的参数，to指向表，to_field指向你关联的字段，不写默认会自动关联主键字段，on_delete级联删除 字段名称不需要写成publish_id，orm在翻译foreignkey的时候会自动给你这个字段拼上一个_id,这个字段名称在数据库里面就自动变成了publish_id
# 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且查看book表的时候，看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个book类里面有authors这个字段属性
# 与Publish建立一对多的关系,外键字段建立在多的一方，字段publish如果是外键字段，那么它自动是int类型
#注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面
增加
通过两种方式
一对一:
au_obj = models.AuthorDetail.objects.get(id = 4)
models.Author.objects.create(
name = '韩寒',
age = 32,
#方式1:将对象作为值给au,也就是自动将au_obj的id赋值给au_id
au = au_obj,
#方式2:直接写id值
#au_id = 4,
)
一对多:
pub_obj = models.Publish.objects.get(id = 3)
models.Book.objects.create(
title = '红楼梦',
price = 160.00,
publishDate = '2011-11-12',
#方式1:类属性作为关键字段时,值为model对象
publishs = pub_obj,
#方式2:如果关键字为数据库字段名称,那么值为关联数据的值
#publish_id = 3
)
多对多:
new_obj = models.Book.objects.create(
title = '红楼梦',
price = 180.00,
publishDate = '2010-08-13',
publishs_id = 2,
)
#方式1:
new_obj.authors.add(3,5)
# new_obj.authors.add(*)利用打散的方式,等同于上面的方式
#方式2:
obj1 = models.Author.objects.get(id=3)
obj2 = models.Author.objects.get(id=5)
new_obj.authors.add(obj1,obj2)
删除
一对一:
models.AuthorDetail.objects.filter(id=3).delete()
models.Author.objects.filter(id=3).delete()
一对多:
models.Publish.objects.filter(id=3).delete()
models.Book.objects.filter(id=4).delete()
多对多:
book_obj = models.Book.objects.get(id=2)
book_obj.authors.remove(1) #指定删除
book_obj.authors.clear() #清空
book_obj.authors.set(['1','2'])#先清除在添加,相当于修改
修改
修改的方法与添加雷同
ret = models.Publish.objects.get(id=2)
models.Book.objects.filter(id=5).update(
title = '活着',
#方式1:
publishs = ret,
#方式2:
#publishs_id = 1,
)
查询
基于对象的跨表查询
一对一查询(Author与AuthorDetail)
https://i-blog.csdnimg.cn/img_convert/a314f3e668ae259d6008869bcf3f4270.png
关系属性写在表1,关联到表2,那么通过表1的数据去找表2的数据,叫做正向查询,返过来就是反向查询
# 正向查询对象.属性
# 例:查询一下韩寒的电话号码
obj = models.Author.objects.filter(name='韩寒').first()
ph = obj.au.telephone
print(ph)
# 反向查询对象.小写的表名
# 例:查一下电话号码为120的作者姓名
obj = models.AuthorDetail.objects.filter(telephone=120).first()
ret = obj.author.name
print(ret)
一对多查询(Publish与Book)
https://i-blog.csdnimg.cn/img_convert/b2e13d7c44030365e30129048f5269d6.png
#正向查询
# 查询一下红楼梦这本书是哪个出版社出版的
obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
ret = obj.publishs.name
print(ret)
#反向查询
# 查询一下 人民出版社出版过哪些书
obj = models.Publish.objects.filter(name='人民出版社').first()
ret = obj.book_set.all()
for i in ret:
print(i.title)
多对多查询(Author与Book)
https://i-blog.csdnimg.cn/img_convert/8590a8ebe35894151055d3f1ffb86000.png
# 正向查询
# 查询一下红楼梦是哪些作者写的
obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
ret = obj.authors.all()
for i in ret:
print(i.name)
# 反向查询
# 查询一下韩寒写了哪些书
obj = models.Author.objects.filter(name='韩寒').first()
ret = obj.book_set.all()
for i in ret:
print(i.title)
#print(i.publishs.name) --查询这些书的出版社名称
3.基于双下划线的跨表查询(基于join实现的)
Django还提供了一种直观而且高效的方式在查询(lookups)中表示关联关系,它能自动确认SQL JOIN联系.要做跨关系查询,就利用双下划线来连接模型(model)间关联字段的名称,直到最终连接到必要的model
基于双下划线的查询:正向查询按字段,反向查询按表名小写来告诉orm引擎join哪张表,一对一,一对多,多对多都是一个写法(在写orm查询的时间,哪张表在前哪张表在后都没问题,因为是join连表操纵)
一对一查询
查询韩寒的手机号
正向查询
ret = models.Author.objects.filter(name='韩寒').values('au__telephone')
反向查询
ret = models.AuthorDetail.objects.filter(author__name = '韩寒').values('telephone')
一对多查询
红楼梦是哪个出版社出版的
正向查询
ret = models.Book.objects.filter(title='红楼梦').values('publishs__name')
反向查询
ret = models.Publish.objects.filter(book__title='红楼梦').values('name')
查询一下人民出版社出版了哪些书
正向查询
ret = models.Book.objects.filter(publishs__name='人民出版社').values('title')
反向查询
ret = models.Publish.objects.filter(name='人民出版社').values('book_title')
多对多查询
查询一下红楼梦是哪些作者写的
正向查询
ret = models.Book.objects.filter(title='红楼梦').values('authors__name')
反向查询
ret = models.Author.objects.filter(book__title='红楼梦').values('name')
related_name
反向查询时,如果定义了related_name,则用related_name替换表名,比如
publish = ForeignKey(to='publisher',related_name = 'booklist')
查询人民出版社出版过哪些书
反向查询 不再按表名:book,而是related_name:booklist
ret = models.Publish.objects.filter(name='人民出版社').values('booklist__title')
4.聚合查询和分组查询
聚合查询
aggregate(*args,**kwargs)
计算所有图书的平均价格
from django.db.models import Avg
ret = models.Book.objects.all().aggregate(Avg('price'))
#或者给它起名字:aggretate(a=Avg('price'))
print(ret)
#{'price__avg':34.35}
aggregate()是QuerySet的一个停止语句,意思是说,它返回一个包罗一些键值对的字典.键的名称是聚合值的标识符,值是计算出来的聚合值,键的名称是按照字段和聚合函数的名称自动生成出来的.如果你想为聚合值指定一个名称,可以向聚合子句提供它.
ret = models.Book.objects.aggregate(a=Avg('price'))
print(ret)
#{'a':34.35}
如果盼望生成不止一个聚合,可以向aggregate()子句中添加另一个参数,以是,可以如许查询
from django.db.models import Avg,Max,Min,Count
ret = models.Book.objects.aggregate(Avg('price'),Max('price'),Min('price'))
print(ret)
#{'price__avg':34.35,'price__max':Decimal('81.20'),'price__min':Decimal('12.99')}
分组查询
annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)
跨表分组查询的本质就是将关联表join成一张表,再按单表的思路举行分组查询
查询每个出版社出版的书的平均价格
#用publish表的id字段进行分组
ret = models.Book.objects.values('publish__id').annotate(a=Avg('price'))
#用book表的publish_id字段进行分组
ret = models.Book.objects.values('publishs_id').annotate(a=Avg('price'))
ret = models.Publish.objects.annotate(a=Avg('book__price')).values('a')
F查询与Q查询
F查询
假设在book表中加入两个字段:批评数:comment,收藏数:keep
Django提供F()来做如许的比力,F()的实例可以在查询中引用字段,来比力同一个model实例中两个不同字段的值
查询评论数大于收藏数的书籍
from django.db.models import F
ret = models.Book.objects.filter(comment__gt=F('keep'))
Django支持F()对象之间以及F()对象和常数之间的加减乘除和取模的操纵
查询评论数大于收藏数两倍的书籍
ret = models.Book.objects.filter(comment__gt=F('keep')*2)
修改操纵也可以利用F函数,比如将每一本书的价格提高30元
models.Book.objects.all().update(price=F('price')+30)
Q查询
filter()等方法中的关键字参数查询都是一起举行'AND'的,如果必要执行更复杂的查询(比方OR语句),可以利用Q对象
Q对象可以利用&(与), |(或) , ~(非) 操纵符组合起来.当一个操纵符在两个Q对象利用时,它产生一个新的Q对象
from django.db.models import Q
ret = models.Book.objects.filter(Q(authors__name='韩寒')|Q(authors__name='余华'))
等同于下面的SQL where子句
where name = '韩寒' or name = '余华'
可以组合利用& 和 | 操纵符以及利用括号举行分组来编写恣意复杂的Q对象.同时,Q对象可以利用 ~ 操纵符取反,允许组合正常的查询和取反 (not)查询
ret = models.Book.objects.filter(Q(authors__name='韩寒')&~Q(publishdate__year=2017)).values_list('title')
ret = models.Book.objects.filter(Q(Q(authors__name='韩寒')&~Q(publishdate__year=2017))&Q(id__gt=6)).values_list('title')
#可以使用Q嵌套,多层Q嵌套等
查询函数可以混合利用Q对象和关键字参数 .全部提供给查询函数的参数(关键字参数或Q对象)都将'AND'在一起,但是,如果出现Q对象,它必须位于全部关键字参数的前面,比方
ret = models.Book.objects.filter(
Q(publishdate__year=2016) | Q(publishdate__year=2017),
title='python' #也是and的关系,但是Q必须写在前面
)
5.ORM执行原生SQL语句
在模型查询API不敷用的情况下，我们还可以利用原始的SQL语句举行查询。
Django 提供两种方法利用原始SQL举行查询：一种是利用raw()方法，举行原始SQL查询并返回模型实例；另一种是完全避开模型层，直接执行自定义的SQL语句。
执行原生查询
raw()管理器方法用于原始的SQL查询，并返回模型的实例：
注意：raw()语法查询必须包罗主键。
这个方法执行原始的SQL查询，并返回一个django.db.models.query.RawQuerySet 实例。 这个RawQuerySet 实例可以像一般的QuerySet那样，通过迭代来提供对象实例。
举个例子：
class Person(models.Model):
first_name = models.CharField(...)
last_name = models.CharField(...)
birth_date = models.DateField(...)
可以像下面如许执行原生sql语句
for p in Person.objects.raw('SELECT * FROM myapp_person'): print(p)
raw()查询可以查询其他表的数据
举例:
ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
for i in ret:
print(i.id, i.hehe)
raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典
d = {'tname': 'haha'}
ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
for i in ret:
print(i.id, i.sname, i.haha)
原生SQL还可以利用参数，注意不要自己利用字符串格式化拼接SQL语句，防止SQL注入！
d = {'tname': 'haha'}
ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=)
for i in ret:
print(i.id, i.sname, i.haha)
直接执行自定义SQL
我们可以直接从django提供的接口中获取数据库连接，然后像利用pymysql模块一样操纵数据库。
from django.db import connection, connections
cursor = connection.cursor()
# cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", )
ret = cursor.fetchone()
6.python脚本中调用django环境(django外部脚本利用models)
如果想通过自己创建的python文件在django项目中利用django的models，那么就必要调用django的环境：
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()
from app01 import models#引入也要写在上面三句之后
books = models.Book.objects.all()
print(books)
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]