Django之ORM操作进阶
一 、 必知必会的13条
1在项目中创建一个orm_test文件夹创建一个py文件
此时就可以在这个py文件中进行sql模型的查询修改了，不用开启项目可网页了
创建数据库的表
from django.db import models class MyCharField(models.Field): """自定义char类型的字段类""" def __init__(self, max_length, *args, **kwargs): self.max_length = max_length super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs) def db_type(self, connection): """限定生成数据库表的字段类型为char，长度为max_length指定的值""" return 'char(%s)' % self.max_length class Person(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=32, db_column='myname', verbose_name='姓名') age = models.IntegerField(null=True, blank=True) birth = models.DateField(auto_now=True) phone = MyCharField(max_length=11) sex = models.CharField(max_length=32, choices=((1, '男'), (2, '女'))) def __str__(self): return 'Person %s %s' % (self.id, self.name) class Meta: ordering = ('id',) db_table = 'person' # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名 verbose_name = '个人信息' # admin中显示的表名称 verbose_name_plural = '所有用户信息' # 相当于verbose_name加s # # 联合索引 # index_together = [ # ("pub_date", "deadline"), # 应为两个存在的字段 # ] # # # 联合唯一索引 # unique_together = (("driver", "restaurant"),) # 应为两个存在的字段 # 出版社 class Publisher(models.Model): name = models.CharField(max_length=32) # 出版社名称 def __str__(self): return '<Publisher %s-%s>' % (self.id, self.name) # 书 class Book(models.Model): title = models.CharField(max_length=30) # 书名 price = models.IntegerField() # 价格 publisher = models.ForeignKey(to='Publisher',related_name='books',null=True) def __str__(self): return '<Book %s-%s>' % (self.id, self.title) # 作者 class Author(models.Model): name = models.CharField(max_length=32) # 作者名字 books = models.ManyToManyField(to='Book',related_name='authors') # 只是ORM层面建立的一个多对多关系，不是作者表的一个字段 def __str__(self): return self.name
<1> all(): 查询所有结果 <2> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。 <3> filter(**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
进行操作测试
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_练习.settings")
import django
django.setup()
from app01 import models
ret = models.Person.objects.all()
# ==》对象列表 所有Person的对象
ret = models.Person.objects.get(id=2)
# ==》返回一个对象，有且只有一个，查询不到或者获取多个都会报错
ret = models.Person.objects.filter(sex='1')
# ==》返回一个对象列表，查询满足条件的对象（不会报错）
ret = models.Person.objects.exclude(age='20')
# ==》返回一个对象列表，查询不满足条件的对象（不会报错）
ret = models.Person.objects.all().values('id', 'name', 'age')
# for i in ret:
# print(i, type(i))
# ==》字典序列 ，元素是{'id':1,'name':mjj,'age':20}
# 没有指定参数 获取所有的字段数据
# 指定参数 获取指定字段数据
ret = models.Person.objects.all().values_list('name', 'id')
# for i in ret:
# print(i, type(i))
# ==》元祖序列 ，元素是('mjj', 1) <class 'tuple'>
# 没有指定参数 获取所有的字段数据
# 指定参数 获取指定字段数据
ret = models.Person.objects.all().order_by('age','-id',)
# order_by 排序 可以指定多个字段
ret =models.Person.objects.all().reverse()
#获得对象列表，按照获取的结果顺序翻转
ret = models.Person.objects.all().distinct()
# distinct 得到对象列表，并且去重
ret = models.Person.objects.all().count()
# count 计数 返回的是个数字
#
ret = models.Person.objects.filter(id=100).first()
#取筛选后的第一个对象，如果没有就是None
ret = models.Person.objects.filter(id=100).last()
#取筛选后的最后一个对象，如果没有就是None
ret = models.Person.objects.all().exists()
#判断是否有值， 返回一个布尔值
print(ret)
1.返回QuerySet对象的方法有
all()
filter()
exclude()
order_by()
reverse()
distinct()
2.特殊的QuerySet
values() 返回一个可迭代的字典序列
values_list() 返回一个可迭代的元祖序列
3.返回具体对象的
get()
first()
last()
4.返回布尔值的方法有：
exists()
5.返回数字的方法有
count()
单表查询之神奇的双下划线
import os if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_练习.settings") import django django.setup() from app01 import models ret = models.Person.objects.filter(id__gt=1) # greater than 大于 ret = models.Person.objects.filter(id__lt=3) # less than 小于 ret = models.Person.objects.filter(id__gte=3) # greater than equal 大于等于 ret = models.Person.objects.filter(id__lte=1) # less than equal 小于等于 # ret = models.Person.objects.filter(id__in=[1,3]) #在这个[1,3]列表中， # ret = models.Person.objects.filter(id__gte=1, id__lte=3) #大于等于1 和小于等于3的 ret = models.Person.objects.filter(id__range=[0,3]) # id 在这个0-3的值中 # ret = models.Person.objects.filter(name__contains='e') # 名字中带有'e'的 ret = models.Person.objects.filter(name__icontains='e') # 名字中带'e'的 不分大小写 # ret = models.Person.objects.filter(name__startswith='e') #开头是'e'的 ret = models.Person.objects.filter(name__istartswith='e') # 开头是'e'的 不分大小写 # ret = models.Person.objects.filter(name__endswith='x') # 结尾是'e'的 ret = models.Person.objects.filter(name__iendswith='x') #结尾是'e'的 不分大小写 # ret = models.Person.objects.filter(birth__year=2018) # 筛选断 是2018年的 ret = models.Person.objects.filter(birth__month=9) # 筛选 是9月的 print(ret)
ForeignKey操作
正向查找
一 、对象查找（跨表）
语法：
对象.关联字段.字段
示例：
book_obj = models.Book.objects.first() # 第一本书对象 print(book_obj.publisher) # 得到这本书关联的出版社对象 print(book_obj.publisher.name) # 得到出版社对象的名称
二 、字段查找（跨表）
语法：
关联字段__字段
示例：
print(models.Book.objects.values_list("publisher__name"))
反向操作
一 、对象查找
语法：
obj.表名_set
示例：
publisher_obj = models.Publisher.objects.first() # 找到第一个出版社对象
books = publisher_obj.book_set.all() # 找到第一个出版社出版的所有书
titles = books.values_list("title") # 找到第一个出版社出版的所有书的书名
二 、字段查找
语法：
表名__字段
示例：
titles = models.Publisher.objects.values_list("book__title")
练习
import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_练习.settings") import django django.setup() from app01 import models # 基于对象查询 # 正向查询 (外键在book中) ，用book对象查询就是正向 book_obj = models.Book.objects.get(id=2) # print(book_obj.price) # 获得数的价格 # print(book_obj.title) # 获得书的名字 # print(book_obj.publisher_id) # 获得外键出版社的对应ID # # print(book_obj.publisher) # 或的id 为 1 的出版社对象 ==》相当于models.Publisher.objects.get(id=1) obj = models.Book.objects.filter(publisher_id=models.Publisher.objects.get(name='沙河出版社').id) # 括号得到是 （publisher_id = 出版社名字叫做'沙河出版社'的id） # obj得到一个书籍对象的列表 obj = models.Book.objects.filter(publisher__name='沙河出版社') # 按照出版社名字是'沙河出版社' 查找书籍对象 （和上一条结果一样，过程不一样） obj = models.Book.objects.all().values('title', 'publisher__name') # 书籍所有的对象的 （书籍名称 和 出版社名称） 的 对象序列 # 反向查询 用出版社查询就是反向 obj = models.Publisher.objects.get(id=1).books.all() # 出版社id为1 的出版社对象 通过books（django第三方对象）（对应Publisher_id） # 获得 书籍对象 obj = models.Publisher.objects.filter(id=models.Book.objects.get(title='自动化').publisher_id) # 括号里 通过正向查找 找到出版社的id # 然后通过出版社 找到出版社对象 obj = models.Publisher.objects.filter(books__title='python') obj = models.Publisher.objects.filter(books__id=2) # 括号里 通过 表名__字段 第三方对象 获取 对应的出版社 obj = models.Publisher.objects.get(id=1) # obj.books.set(models.Book.objects.filter(id__in=[4,5])) # # 注意 覆盖修改 书籍 id 为 4 和 5 的 Publisher_id 为 1 # # 此时 书籍 id 为 1- 3 的 Publisher_id 为 null了 # # obj.books.add(*models.Book.objects.filter(id__in=[4,5])) # # 添加修改 书籍id为 4 和 5 的 Publisher_id为1 obj.books.remove(*models.Book.objects.filter(id__in=[2, 3])) # 删除 书籍id为2和3 的Publisher_id 断开和出版社的外键关系
ManyToManyField
class RelatedManager
"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。
它存在于下面两种情况：
- 外键关系的反向查询
- 多对多关联关系
简单来说就是当 点后面的对象 可能存在多个的时候就可以使用以下的方法。
方法
1.create()
创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。
>>> import datetime >>> models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())
2.add()
把指定的model对象添加到关联对象集中。
添加对象
>>> author_objs = models.Author.objects.filter(id__lt=3) >>> models.Book.objects.first().authors.add(*author_objs)
添加id
>>> models.Book.objects.first().authors.add(*[1, 2])
3.set()
更新model对象的关联对象。
>>> book_obj = models.Book.objects.first() >>> book_obj.authors.set([2, 3])
4.remove()
从关联对象集中移除执行的model对象
>>> book_obj = models.Book.objects.first() >>> book_obj.authors.remove(3)
5.clear()
从关联对象集中移除一切对象。
>>> book_obj = models.Book.objects.first() >>> book_obj.authors.clear()
注意：
对于ForeignKey对象，clear()和remove()方法仅在null=True时存在。
举个例子：
ForeignKey字段没设置null=True时，
class Book(models.Model):
title = models.CharField(max_length=32)
publisher = models.ForeignKey(to=Publisher)
没有clear()和remove()方法：
>>> models.Publisher.objects.first().book_set.clear() Traceback (most recent call last): File "<input>", line 1, in <module> AttributeError: 'RelatedManager' object has no attribute 'clear'
当ForeignKey字段设置null=True时，
class Book(models.Model):
name = models.CharField(max_length=32)
publisher = models.ForeignKey(to=Class, null=True)
此时就有clear()和remove()方法：
>>> models.Publisher.objects.first().book_set.clear()
注意：
- 对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。
聚合查询和分组查询
聚合
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。
键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
用到的内置函数：
from django.db.models import Avg, Sum, Max, Min, Count
示例：
ret= models.Book.objects.aggregate(Avg('price'))
print(ret) # ==>{'price__avg': 13.233333}
如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
ret = models.Book.objects.aggregate(平均价格=Avg('price'))
print(ret) # ==>{'average_price': 13.233333}
如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
ret = models.Book.objects.all().aggregate(平均价格 = Avg("price"), 最大价格= Max("price"),最小价格 = Min("price"))
print(ret) # ==>{'平均价格': 15.97, '最大价格': Decimal('39.99'), '最小价格': Decimal('1.00')}
.values 的特殊之处
ret = models.Book.objects.annotate(作者数量=Count('author')).values()
for i in ret:
print(i)
#结果如下 ：count被命名后加进去了 可以作为字段去做条件了
{'id': 1, 'title': '跟金老板学开车', 'publish_date': datetime.date(2018, 8, 3), 'price': Decimal('12.90'), 'memo': '1', 'publisher_id': 1, '作者数量': 2}
{'id': 2, 'title': '跟金老板学开潜艇', 'publish_date': datetime.date(2017, 8, 10), 'price': Decimal('9.99'), 'memo': None, 'publisher_id': 1, '作者数量': 2}
{'id': 3, 'title': '跟老男孩学思想', 'publish_date': datetime.date(2018, 9, 3), 'price': Decimal('39.99'), 'memo': None, 'publisher_id': 2, '作者数量': 1}
{'id': 4, 'title': '跟egon学喊麦', 'publish_date': datetime.date(2018, 6, 12), 'price': Decimal('1.00'), 'memo': None, 'publisher_id': 4, '作者数量': 1}
分组
我们在这里先复习一下SQL语句的分组。
假设现在有一张公司职员表：
我们使用原生SQL语句，按照部门分组求平均工资：
select dept,AVG(salary) from employee group by dept;
ORM查询:
from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values("dept", "avg")
连表查询的分组：
SQL查询：
select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;
ORM查询：
from django.db.models import Avg
models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")
更多示例：
示例1：统计每一本书的作者个数
ret = models.Book.objects.all().annotate(作者个数 = Count('author'))
for i in ret:
print(i.作者个数)
#结果如下
2
2
1
1
示例2：统计出每个出版社买的最便宜的书的价格
ret = models.Publisher.objects.all().annotate(最便宜的书 = Min('book__price'))
for i in ret:
print(i.最便宜的书)
#得到
9.99
39.99
1.00
None
方法二：
ret = models.Book.objects.values('publisher__name').annotate(price_min = Min('price'))
print(ret)
<QuerySet [{'publisher__name': '沙河出版社', 'price_min': Decimal('1.00')}, {'publisher__name': '西二旗出版社', 'price_min': Decimal('39.99')}]>
示例3：统计不止一个作者的图书
ret = models.Book.objects.all().annotate(author_count = Count('author')).filter(author_count__gt=1).values() #返回的是一个字典
# for i in ret:
# print(i['author_count'])
ret = models.Book.objects.all().annotate(author_count=Count('author')).filter(author_count__gt=1) # 返回来的是一个QuerySet对象
for i in ret:
print(i.author_count)
# 结果一样 都是
2
2
示例4：根据一本图书作者数量的多少对查询集 QuerySet进行排序
ret = models.Book.objects.all().annotate(count=Count('author')).order_by('count')
print(ret)
ret = models.Book.objects.annotate(count=Count('author')).order_by('count')
print(ret)
#结果一样
<QuerySet [<Book: <Book object: 3 跟老男孩学思想>>, <Book: <Book object: 4 跟egon学喊麦>>, <Book: <Book object: 1 跟金老板学开车>>, <Book: <Book object: 2 跟金老板学开潜艇>>]>
示例5：查询各个作者出的书的总价格
#ret = models.Author.objects.annotate(sum_price=Sum("书__价格")).values('名字字段','Sun的命名')
# 分析： 获得作者对象 分组 书的总价格 为了得到的 作者名字 和作者书籍的总价格
ret = models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
print(ret)
# ==》 <QuerySet [{'name': '金老板', 'sum_price': Decimal('22.89')},
# {'name': '小哪吒', 'sum_price': Decimal('22.89')},
# {'name': 'Alex', 'sum_price': Decimal('40.99')}]>
for i in ret:
print(i['name'],i['sum_price'])
# ==》金老板 22.89
# 小哪吒 22.89
# Alex 40.99
F查询和Q查询
F查询
在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？
Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
示例1：
查询售出数大于库存数的书籍
from django.db.models import F
ret = models.Book.objects.filter(sale__gt=F('kucun')) #（售出数量>库存数量）可通过F动态获取 同一个model实例中 两个不同字段
for i in ret:
print(i.title,i.sale,i.kucun) # 查看书籍名称 ，售出数量， 售出
Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
#查询库存量的小于 售出量*2 的书籍
ret = models.Book.objects.filter(kucun__lt=F('sale') * 2)
print(ret) # ==》<QuerySet [<Book: <Book object: 3 跟老男孩学思想>>, <Book: <Book object: 4 跟egon学喊麦>>]>
修改操作中有一个update方法
# ret = models.Book.objects.filter(id=2).update(sale=100) #这个不用保存 直接改库 # obj = models.Book.objects.get(id=2) # obj.sale='1000' # obj.save()
修改操作也可以使用F函数,比如将每一本书的价格提高30元
ret = models.Book.objects.all().update(sale=F('sale') + 30)
引申：
如果要修改char字段咋办？
如：把所有书名后面加上(第一版)
>>> from django.db.models.functions import Concat
>>> from django.db.models import Value
>>> models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("第一版"), Value(")")))
Q查询
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。
示例1：
查询书籍id大于2和小于10的书籍
ret = models.Book.objects.filter(id__gt=2, id__lt=10)
print(ret) # ==><QuerySet [<Book: <Book object: 4 跟egon学喊麦>>]>
你可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询。
例如：查询id不为3的书籍
ret = models.Book.objects.filter(~Q(id=3)) # ~ 是取反的意思
#如果查询 小于2或者大于3的书籍呢（~ ：取反的意思）（__get：大于等于，__lte：小于等于）
ret = models.Book.objects.filter(~Q(id__gte=2)|~Q(id__lte=3))
print(ret) # ==》<QuerySet [<Book: <Book object: 1 跟金老板学开车>>, <Book: <Book object: 4 跟egon学喊麦>>]>
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。
例如：查询出版年份是2017或2018，书名中带物语的所有书。
混合使用
例子：
# 1 .查询价格大于10，并且销售量大于30的
ret = models.Book.objects.filter(~Q(price__gte=10) & Q(sale__gte=30)).values('id','price','sale')
print(ret) # <QuerySet [{'id': 2, 'price': Decimal('9.99'), 'sale': 150}, {'id': 4, 'price': Decimal('1.00'), 'sale': 175}]>
# 2.查询出版时间是2018年或者2017年的，书名称带‘金老板’的书籍
ret = models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="金老板")
print(ret) # <QuerySet [<Book: <Book object: 1 跟金老板学开车>>, <Book: <Book object: 2 跟金老板学开潜艇>>]>
事务
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_练习.settings")
import django
import datetime
django.setup()
from app01 import models
try:
# from django.db import transaction
from django.db import transaction
with transaction.atomic():
# 给数据中出版社表 创建 几个新的的出版社
models.Publisher.objects.create(name="深圳出版社")
models.Publisher.objects.create(name="深圳出版社1")
# int(asd) # 如果取消注释 就会报错 那么这4各出版社创建都不会成功 （如果注释那么这四个出版社创建（事务）就算成功了）
models.Publisher.objects.create(name="深圳出版社2")
models.Publisher.objects.create(name="深圳出版社3")
# 这4个新创建的出版社就是事务
except Exception as e:
print(str(e))
其他鲜为人知的操作（有个印象即可）
Django ORM执行原生SQL
# extra # 在QuerySet的基础上继续执行子语句 # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # select和select_params是一组，where和params是一组，tables用来设置from哪个表 # 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']) 举个例子： models.UserInfo.objects.extra( select={'newid':'select count(1) from app01_usertype where id>%s'}, select_params=[1,], where = ['age>%s'], params=[18,], order_by=['-age'], tables=['app01_usertype'] ) """ select app01_userinfo.id, (select count(1) from app01_usertype where id>1) as newid from app01_userinfo,app01_usertype where app01_userinfo.age > 18 order by app01_userinfo.age desc """ # 执行原生SQL # 更高灵活度的方式执行原生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()
QuerySet方法大全
################################################################## # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET # ################################################################## def all(self) # 获取所有的数据对象 def filter(self, *args, **kwargs) # 条件查询 # 条件可以是：参数，字典，Q def exclude(self, *args, **kwargs) # 条件查询 # 条件可以是：参数，字典，Q 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 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 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): # 是否有结果
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.backends的logger实例即可查看翻译后的SQL语句。
在Python脚本中调用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)
