博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Django ORM相关的操作
阅读量:4984 次
发布时间:2019-06-12

本文共 15199 字,大约阅读时间需要 50 分钟。

Django ORM相关的操作

一般操作

必知必会的13条

1、 all():                 查询所有结果 2、 filter(**kwargs):      它包含了与所给筛选条件相匹配的对象 3、 get(**kwargs):         返回与所给筛选条件相匹配的对象,返回结果有且只有一个,如果符合筛选条件的对象超过一个或者没有都会抛出错误。 4、 exclude(**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

1. 返回QuerySet类型的都有哪一些

    1. all()
    2. filter()
    3. exclude()
    4. order_by()
    5. reverse()
    6. distinct()
    7. values()              #   返回一个可迭代的字典类型
    8. values_list()        #   返回一个可迭代的元组类型
2. 返回具体对象:
    1. get()
    2. first()
    3. last()
3. 返回具体数字:
    1. count()
4. 返回布尔值的:
    1. exists()

 

单表查询之双下划线

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的数据models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的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)

练习:

脚本运行Django 多用于测试import osif __name__ == '__main__':    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_demo.settings")    import django    django.setup()    # ORM查询操作    from app01 import models    # 查找所有书名里包含番茄的书    ret = models.Book.objects.filter(title__contains='番茄')    print(ret)    # 查找出版日期是2017年的书    ret = models.Book.objects.filter(publish_date__year=2017)    print(ret)    # 查找出版日期是2017年的书名    ret = models.Book.objects.filter(publish_date__year=2017).values("title")    print(ret)    # 查找价格大于10元的书    ret = models.Book.objects.filter(price__gt=10)    print(ret)    # 查找价格大于10元的书名和价格    ret = models.Book.objects.filter(price__gt=10).values("title", "price")    print(ret)    # 查找memo字段是空的书    ret = models.Book.objects.filter(memo__isnull=True)    print(ret)    # 查找在北京的出版社    ret = models.Publisher.objects.filter(city='北京')    print(ret)    # 查找名字以沙河开头的出版社    ret = models.Publisher.objects.filter(name__startswith="沙河")    print(ret)    # 查找作者名字里面带'小'字的作者    ret = models.Author.objects.filter(name__contains='小')    print(ret)    # 查找年龄大于30岁的作者    ret = models.Author.objects.filter(age__gt=30)    print(ret)    # 查找手机号是155开头的作者    ret = models.Author.objects.filter(phone__startswith='155')    print(ret)    # 查找手机号是155开头的作者的姓名和年龄    ret = models.Author.objects.filter(phone__startswith='155').values("name", "age")    print(ret)

 

ForeignKey操作

# 正向    # 基于对象的查找    # ret = models.Book.objects.first()    # print(first_book.publisher.name)    # 双下划线    # ret = models.Book.objects.filter(id=1).values('publisher__name')    # print(first_book)# 反向    # 双下划线    # ret = models.Publisher.objects.filter(id=1).values('book__title', 'name')    # print(ret)    # 对象    # ret = models.Publisher.objects.first()    # print(ret)    # ret2 = ret.book_set.all()    # print(ret2)

 

ManyToManyField

方法

多对多操作    # 1、 create      ==》创建一个新对象,保存对象,并将它添加到关联对象集之中    ret = models.Book.objects.first().author.create(        name='胡小',        age=18,        phone='1221212122',        detail_id=4    )    ret = models.Book.objects.first().author.all().values("id")    print(ret)    # 2、set          ==》更新model对象的关联对象    models.Book.objects.first().author.set([2, 14])    ret = models.Book.objects.first().author.all().values('id')    print(ret)    # 3、add          ==》添加对象    models.Book.objects.first().author.add(1)    ret = models.Book.objects.first().author.all().values('id')    print(ret)    # 4、remove       ==》删除指定对象    models.Book.objects.first().author.remove(1)    ret = models.Book.objects.first().author.all().values('id')    print(ret)    # 5、clear        ==》移除一切对象    models.Book.objects.first().author.clear()    ret = models.Book.objects.first().author.all().values('id')    print(ret)    # 6、all          ==》查找    ret = models.Book.objects.first().author.all()    print(ret)

注意:对于ForeignKey对象,clear()和remove()方法仅在null=True时存在

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

 

聚合查询和分组查询

聚合

aggregate()是QuerySet的一个终止子句,意思是说,它返回一个包含一些键值对的字典。

键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称

需要用到内置函数:

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

分组和聚合练习:

# 查询所有书的总价格     ret = models.Book.objects.aggregate(total_price=Sum('price'))     print(ret)# 求每一本书的作者个数     ret = models.Book.objects.annotate(c=Count('author')).values('title', 'c')     print(ret)# 统计出每个出版社买的最便宜的书的价格     ret = models.Publisher.objects.annotate(min_price=Min('book__title')).values('name', 'min_price')     print(ret)# 统计不止一个作者的图书     ret = models.Book.objects.annotate(c=Count('author')).filter(c__gt=1)     print(ret)# 根据一本图书作者数量的多少对查询集QuerySet进行排序     ret = models.Book.objects.annotate(c=Count('author')).order_by('c').values('title', 'c')     print(ret)# 查询各个作者出的书的总价格     ret = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')     print(ret)

 内容补充:

1、.update()与.save()的区别

publisher_obj = models.Publisher.objects.first()publisher_obj.name = "武汉出版社"publisher_obj.save()    #.save方法是把应该更新的字段和其他没有更新的字段全部更新models.Publisher.objects.filter(id=1).update(name="湖北武汉出版社")     # .update()方法是你更新了那个字段,那个字段就会更新,其他的字段不变

2、查询书籍名称和出版时间(年月)

ret = models.Book.objects.all().extra(select={
"zhangzhao": "DATE_FORMAT(publish_date, '%%Y-%%m')"}).values("title", "zhangzhao") # print(ret)from django.db.models import Count# 将 书籍 按 年月 归档 最后2018-06:2ret = models.Book.objects.extra(select={
"zhangzhao": "DATE_FORMAT(publish_date, '%%Y-%%m')"}).values("zhangzhao").annotate(num=Count("id")).values("zhangzhao", "num") # print(ret)

 

F查询

如果我们要对两个字段的值作比较,该怎么做?

Django提供F()来做这种比较,F()的实例可以在查询中引用字段,来比较一个model实例中两个不同字段的值

示例:

表结构from django.db import models# Create your models here.class Product(models.Model):    name = models.CharField(max_length=32)    price = models.DecimalField(max_digits=6, decimal_places=2)    # 库存数    kucun = models.IntegerField()    # 卖出数    maichu = models.IntegerField()    def __str__(self):        return  "{}:{}:{}:{}".format(self.name, self.price, self.kucun, self.maichu)class Order(models.Model):    num = models.CharField(max_length=64)    product = models.ForeignKey(to="Product")    count = models.IntegerField()
import osif __name__ == '__main__':    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")    import django    django.setup()    from app01 import models    # F查询    from django.db.models import F     models.Product.objects.filter(maichu__gt=10)  # 卖出数大于10    # 查询出卖出数大于库存数的商品     ret = models.Product.objects.filter(maichu__gt=F("kucun"))     print(ret)    # 将每个商品的价格提高50块     models.Product.objects.update(price=F("price")+50)    # 将所有商品的名称后面加一个 '新款'     from django.db.models.functions import Concat     from django.db.models import Value     models.Product.objects.update(name=Concat(F("name"), Value("新款")))    # 卖出数大于100 并且 价格小于100块的     models.Product.objects.filter(maichu__gt=100, price__lt=100)

Q查询

1. 多个查询条件做 交集 并集 取反操作时

2. 如果Q查询和关键字查询同时存在时,Q查询要放在关键字查询的前面!!!

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR语句),你可以使用Q对象

from django.db.models import Q# 查询 卖出数大于100 或者 价格小于100块的    ret = models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))    print(ret)# 查询 库存数是100 并且 卖出数不是0 的产品     ret = models.Product.objects.filter(Q(kucun=100) & ~Q(maichu=0))  # ~取反     print(ret)    # 查询产品名包含新款, 并且库存数大于60的     ret = models.Product.objects.filter(Q(kucun__gt=60), name__contains="新款")     print(ret)

 

事务

# 买一本 ‘天下无敌’ 的书# 在数据库要做的事  # 1、创建一条订单数据  # 2、去产品表  将卖出数+1, 库存数-1from django.db.models import Ffrom django.db import transaction# 捕捉异常try:      # 开启事务      with transaction.atomic():    # with运行完,这个事务就结束了           # 创建一条数据           models.Order.objects.create(num='123',product_id=1,count=1)           # 去产品表,将卖出数+1,库存数-1           models.Product.objects.filter(id=1).update(kucun=F('kucun')-1, maichu=F('maichu')+1)except Exception as e:      print(e)

 

QuerySet方法大全

################################################################### PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET ###################################################################def all(self)    # 获取所有的数据对象def filter(self, *args, **kwargs)    # 条件查询    # 条件可以是:参数,字典,Qdef exclude(self, *args, **kwargs)    # 条件查询    # 条件可以是:参数,字典,Qdef 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) > 1def 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 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})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): # 是否有结果QuerySet方法大全
QuerySet方法大全

 

Django终端打印SQL语句

在Django项目的settings.py文件中,在最后复制粘贴下面的代码

LOGGING = {    'version': 1,    'disable_existing_loggers': False,    'handlers': {        'console':{            'level':'DEBUG',            'class':'logging.StreamHandler',        },    },    'loggers': {        'django.db.backends': {            'handlers': ['console'],            'propagate': True,            'level':'DEBUG',        },    }}

即为你的Django项目配置上一个名为django.db.backemds的 logger实例,即可以查看翻译后的SQL语句。

在Python脚本中调用Django环境

import osif __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)

 

转载于:https://www.cnblogs.com/gaobei/articles/9215060.html

你可能感兴趣的文章
常用的监控系统资源的工具
查看>>
08ssm三大框架整合以前步骤
查看>>
R语言学习笔记之八
查看>>
正则表达式语法(msdn)
查看>>
oralce使用INSERT语句向表中插入数据
查看>>
MySQL 数据类型 详解 (转载)
查看>>
干净win7要做几步才能运行第一个Spring MVC 写的动态web程序
查看>>
Maven学习笔记(一)
查看>>
分割线
查看>>
xls的读写
查看>>
用函数创建子进程
查看>>
Myeclipse配置插件
查看>>
gitlab配置通过smtp发送邮件(QQ exmail腾讯企业为例)
查看>>
蓝桥杯之入学考试
查看>>
新公司java的注解以及springboot的相关注解
查看>>
Unity脚本的生命周期中几个重要的方法
查看>>
poj1552
查看>>
Thinkphp中文水印和图片水印合体集成插件
查看>>
FLASK安装--兼收EZ_INSTALL及PIP
查看>>
C++静态成员变量和静态成员函数小结
查看>>