一、外键自关联(一对多) 1、建表 # 评论表 class Comment(models.Model): id = models.AutoField(primary_key=True) content = models.CharField(max_length=255) push_time = models.DateTimeField(auto_now_add=True) # 父评论:自关联,一个评论可以没有父评论所以null=True pcomment = models.ForeignKey(to='self', null=True) def __str__(self): return self.content 2、表数据
2、操作 1.找到id等于2的那个评论的所有子评论(跨表查询) ret = Comment.objects.filter(pcomment__id=2) print(ret) 2.方法2(直接查询) ret = Comment.objects.filter(pcomment_id=2) print(ret) 3.方法3 ret = Comment.objects.filter(id=2).values('comment__id') print(ret) 二、多对多自关联 1、建表 class Person(models.Model): name = models.CharField(max_length=12) friends = models.ManyToManyField(to='self', symmetrical=False) def __str__(self): return self.name 2、注意 在多对多的自关联时,如果需要反向查找,则需要添加symmetrical这个字段, 指定内部是否创建反向操作的字段,默认为True,需要反向查找则改成False 3、操作 1.找到小明的朋友(正向找) ret = Person.objects.filter(name='小明').values('friends__name') print(ret) 2.朋友是小明的那个人(反向找) ret = Person.objects.get(name='小明').person_set.all() print(ret) 或者 ret = Person.objects.filter(name='小明').values('person__name') print(ret)
补充:
create(关键字参数)
创建一个新的对象,保存对象,并将它添加到关联对象集之中,返回新创建的对象。
publisher.objects.create(id=1, name="...")
三、补充的几个方法 1、这几个方法适用于一对多和多对多的情况,一对多的时候,在"一"这张表才有下面这些方法,多对多的时候,两张表跨到第三张表时都有下面这些方法, 且只是对象才能使用(queryset列表不能使用),就是obj.get()、obj.first()、obj.last()才能使用,
需要注意的是:'一'这张表使用下面这些方法时,参数是对象,而多对多的第三张表使用下面这些方法时,参数是id 它存在于下面两种情况: 外键关系的反向查询 多对多关联关系 简单来说就是当 点后面的对象 可能存在多个的时候就可以使用以下的方法 2、方法
1.add(位置参数) 把指定的model对象添加到关联对象集中。 但是一对多中add里面的实参(位置参数)是对象 而多对多中add里面的实参(位置参数)可以是id 2.set([列表]) 更新model对象的关联对象。 但是一对多中set里面的实参(列表)是对象 而多对多中add里面的实参(列表)可以是id 3.remove() 从关联对象集中移除执行的model对象 4.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() 5.注意 对于所有类型的关联字段,add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说,在关联的任何一端,都不需要再调用save()方法。 6.建表 class MyClass(models.Model): cname = models.CharField(max_length=12) class Student(models.Model): sname = models.CharField(max_length=12) myclass = models.ForeignKey(to='MyClass') def __str__(self): return self.sname class Teacher(models.Model): tname = models.CharField(max_length=12) myclass = models.ManyToManyField(to='MyClass') 7.例子 1.一对多 # 查询id=2的班级的所有学生 ret = MyClass.objects.get(id=2).student_set.all() print(ret) # id=2的班级的所有老师 ret = MyClass.objects.get(id=2).teacher_set.all() print(ret) # 给id=1的班级添加一个id=4的学生 student_obj = Student.objects.get(id=4) MyClass.objects.get(id=1).student_set.add(student_obj) ret = MyClass.objects.get(id=1).student_set.all() print(ret) # 把所有学生都绑定到id=1的班级中 MyClass.objects.get(id=1).student_set.set(Student.objects.all()) ret = MyClass.objects.get(id=1).student_set.all() print(ret) 2.多对多 # 给id=2的老师添加一个id=4的班级 Teacher.objects.get(id=2).myclass.add(4)
# 给id=3的班级添加一个id=1的老师
Myclass.objects.get(id=3).teacher_set.add(1)
# 把id=3的班级的老师修改为id=2和id=3的老师
Myclass.objects.get(id=3).teacher_set.set([2, 3])
# 从id=2的老师的中移除2班 Teacher.objects.get(id=2).myclass.remove(2) # 清空id=2的老师的班级 Teacher.objects.get(id=2).myclass.clear() # 给id=2的老师新增一门课:生理课 Teacher.objects.get(id=2).myclass.create(cname='生理课') 四、如何在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语句。 五、基于对象的跟新(save)和基于QuerySet的update跟新的区别 # 把南山出版社的ceo改成小红 # 1. 基于对象的修改(会跟新所有字段,效率慢) publisher_obj = Publisher.objects.get(name='南山出版社') publisher_obj.ceo = '小红' publisher_obj.save() # 2. 基于QuerySet的update跟新(只跟新指定的字段,效率快于基于对象的修改) Publisher.objects.filter(name='南山出版社').update(ceo='小勾') 六、聚合查询
注意:ORM的聚合函数一定要搭配aggregate或者annotate使用
6-1、aggregate
1、介绍 aggregate()是QuerySet的一个终止子句,意思是说,它返回一个包含一些键值对的字典。 键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。 用到的内置函数: from django.db.models import Avg, Sum, Max, Min, Count 2、例子 from django.db.models import Avg, Sum, Max, Min, Count # 求所有书中价格最高的书 ret = Book.objects.all().aggregate(Max('price')) print(ret) # 为聚合值指定一个名称,返回指定的key值 ret = Book.objects.all().aggregate(max_price=Max('price')) print(ret) # 生成不止一个聚合,求所有书的平均价格和最小的价格 ret = Book.objects.all().aggregate(avg_price=Avg('price'), min_price=Min('price')) print(ret) 6-2、annotate分组查询 1、介绍 values/values_list 对应 SQL语句 select 部分 filter 对应 SQL语句 where 部分 2、ORM中分组使用annotate 1. annotate前面查询(values)的是什么,就按什么分组,没有values就默认按id分组,而id是唯一的,因此不写values等于没有分组 2. annotate中要写上分组之后要做的事情 3、建表 class Employee(models.Model): name = models.CharField(max_length=12) age = models.IntegerField() salary = models.IntegerField() province = models.CharField(max_length=12) dept = models.CharField(max_length=12) 4、例子 from django.db.models import Avg, Sum, Max, Min, Count # 使用ORM查询每个部门的平均工资 ret = Employee.objects.values('dept').annotate(avg=Avg('salary')) print(ret) ret = Employee.objects.annotate(avg=Avg('salary')).values('dept', 'avg') print(ret) # 等于没有分组 # 每个部门的平均年龄 ret = Employee.objects.values('dept').annotate(Avg('age')).values_list('dept', 'avg_age') print(ret) 4、多表使用分组 class Publisher(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=16) addr = models.TextField() # 成立日期:对应Python中的datetime.date类型 date = models.DateField() def __str__(self): return self.name class Book(models.Model): # 书名 title = models.CharField(max_length=16) # 价格:最多显示6个数字,小数位有2个 price = models.DecimalField(max_digits=6, decimal_places=2) # ISBN:书籍的唯一编号 isbn = models.CharField(max_length=20, unique=True) # 外键关联出版社,db_constraint=False不在数据库中建立约束 publisher = models.ForeignKey(to='Publisher', on_delete=models.CASCADE, related_name='books') def __str__(self): return self.title class Author(models.Model): name = models.CharField(max_length=12) # 性别,choice选项用的是本模块定义的常量,默认选保密 gender = models.SmallIntegerField(choices=((1, '男'), (2, '女'), (3, '保密')), default=3) # 手机号,唯一约束 phone = models.CharField(max_length=11, unique=True) # 邮箱 email = models.EmailField() # 多对多关联书籍 books = models.ManyToManyField(to='Book', related_name='authors') 例子: from django.db.models import Avg, Sum, Max, Min, Count # 求每个出版社出版的书的平均价格
# 基于Book ret = Book.objects.values('publisher_id').annotate(avg_price=Avg('price')).values_list('publisher__name', 'avg_price') print(ret)
# 基于Publisher
ret = Publisher.objects.annotate(avg_price=Avg(books__price)).values('name', 'avg_price')
print(ret)
# 求每个出版社出版的书的数量 ret = Book.objects.values('publisher_id').annotate(count=Count('id')).values_list('publisher__name', 'count') print(ret) 七、Q查询 filter()等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR语句),你可以使用Q对象。 同样是上面书籍出版社那个数据库 例如: 1、或 | from django.db.models import Q # 查询书的价格大于100或者作者是小明的书 ret = Book.objects.filter(Q(price__gt=100) | Q(authors__name='小明')) print(ret) 2、且 & # 原生的 且 # 查询书的价格大于100且作者是小明的书 ret = Book.objects.filter(price__gt=100, authors__name='小明') print(ret) # Q对象的 且 from django.db.models import Q ret = Book.objects.filter(Q(price__gt=100) & Q(authors__name='小明')) print(ret) 3、非 ~ from django.db.models import Q ret = Book.objects.filter(Q(price__gt=100) & ~Q(authors__name='小明')) print(ret) 4、混合使用: 查询函数可以混合使用Q对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q对象)都将进行'END'运算, 但是,如果出现Q对象,它必须位于所有关键字参数的前面。 # 查询出版社id是1或者2,且作者名字中有小的书 ret = Book.objects.filter(Q(publisher_id=1) | Q(publisher_id=2), authors__name__contains='小') print(ret)
5、Q的拓展使用方法
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
Q查询的两种写法 # Q原始写法 data = data.filter( Q(name__icontains=query_value)|Q(qq__icontains=query_value)|Q(qq_name__icontains=query_value) ) 或者 data = data.filter( Q(('name__icontains', query_value))|Q(('qq__icontains', query_value))|Q(('qq_name__icontains', query_value)) ) # Q使用对象的写法 q = Q() # 实例一个Q对象 q.connector = 'OR' # 连接符,OR AND q.children.append(Q(('name__icontains', query_value))) # Q查询里面的实参是一个元组,元组第一个元素是查询的字段(字符串形式) q.children.append(Q(('qq__icontains', query_value))) # 元组第二个元素是需要匹配的值 q.children.append(Q(('qq_name__icontains', query_value))) data = data.filter(q)
八、F查询 1、字段在原基础上跟新
1.1跟新字段的值(数字) 例如: from django.db.models import F # F用来在字段原来的基础上进行操作 Book.objects.all().update(price=F('price')+20) 进行了上面的操作后,数据库中book表所有的price字段的值全部加了20, 比如本来90的,现在就110
1.2拓展:跟新字段的值(字符串) from django.db.models import F # 给每本书的名字加'新款'(注意:一般在实际中不应该这么做,这里只是用于了解F对象) from django.db.models.functions import Concat # 字符串拼接 from django.db.models import Value # 把字符串转变成F对象可以操作的变量 Book.objects.all().update(title=Concat(F('title'), Value('新款')))
2、同一条记录不同字段之间的比较
# 找出卖出数大于收藏数的书籍
Book.objects.filter(sale_num__gt=F('fav_num')) # sale_num是这本书的卖出的数量,fav_num是这本书收藏的次数
九、事务 在事务代码块内的代码,全部都执行成功后,数据库中才会进行修改 只要存在一句错误的语句,全部代码都不会生效 一般使用在安全性需要很高的场景,比如,银行的转账, 为了避免一方转账后,中途出现断电,服务器异常等情况,导致另一方没收到转账, 而转账方的钱却减少了 from django.db import transaction with transaction.atomic(): # 创建一本书 Book.objects.create(title='嘿嘿书', price=10.99, isbn='213dsxc', publisher_id=1) # 把id=100的书名修改为哈哈书 book_obj = Book.objects.get(id=100) # 没有id=100的书,这里会报错,结果是整体都不生效,数据库不会有任何修改 book_obj.title = '哈哈书' book_obj.save() 十、去重distinct ret = Book.objects.all().values('publisher__name').distinct() print(ret) 十一、Django ORM执行原生SQL(拓展了解) 1、raw 1. 查询自己这个表 ret = Book.objects.raw('select * from app04_book') # raw里面写原生的SQL语句 print(ret) for i in ret: print(i.title, i.price) 2. 查询别的表 在Book表查询publisher表,select必须要写上publisher的主键,能使用的也只有主键,如果要使用其他字段,就在主键后写上其他字段 ret = Book.objects.raw('select id, name from app04_publisher') for i in ret: print(i.id, i.name) 拓展知识:在ORM中,使用的是懒查询,就是当你没有使用这个结果的时候,它是不会去数据库帮你查询的, 比如上面的 ret = Book.objects.raw('select * from app04_book') 当你print这个结果的时候,并不会有内容的 因为ORM没有看到你使用这个ret,它不会去数据库帮你查询的,而当你把ret进行循环的时候,ORM知道你要使用了,它才会 真正地去数据库帮你进行操作并返回结果给你。 2、直接执行自定义SQL 有时候raw()方法并不十分好用,很多情况下我们不需要将查询结果映射成模型,或者我们需要执行DELETE、 INSERT以及UPDATE操作。在这些情况下,我们可以直接访问数据库,完全避开模型层。 我们可以直接从django提供的接口中获取数据库连接,然后像使用pymysql模块一样操作数据库。 from django.db import connection, connections connection获取默认的数据库 connections当有多个数据库的时候,使用关键字获取指定的数据库 connections['default'] 例如: from django.db import connection, connections cursor = connection.cursor() cursor.execute('select * from app04_book') ret = cursor.fetchone() print(ret) 十二、QuerySet方法大全
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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): # 是否有结果
举几个例子: # only:将指定的字段查询加载出来,后续再访问指定的字段就不需要再查询数据库 ret = Book.objects.all().only('title') # 拿到所有书的对象列表 for i in ret: print(i.title) # 访问指定的字段title不需要再去查询数据库 for i in ret: print(i.price) # 访问不是指定的字段,每一次都去查一次数据库 # defer:将除了指定的字段查询加载出来,后续再访问指定的字段就不需要再查询数据库(only的反义词) ret = Book.objects.all().defer('title') for i in ret: print(i.title) # 访问指定的字段title,每一次都需要去查询数据库 for i in ret: print(i.price) # 访问不是指定的字段,不需要再查询数据库 # bulk_create:一次SQL语句批量创建 from datetime import date obj = (Publisher(name='第%s出版社' %(i), addr='中国', date=date.today()) for i in range(100)) Publisher.objects.bulk_create(obj) # select_related:把id=2的书的信息和它关联的出版社的信息一起查询出来。 ret = Book.objects.filter(id=2).select_related('publisher') print(ret[0].publisher.name)
aggregate