Django终端打印SQL语句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
1 Setting配置:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 's3',
'USER': 'root',
'PASSWORD': '123456',
'HOST': '127.0.0.1',
'PORT': '3306',
}
}
2 默认python 使用的MysqlDB连接,Python3 支持支持pymysql 所有需要在app里面的__init__加上下面配置:
import pymysql
pymysql.install_as_MySQLdb()
3 models是用类的方式来配置管理数据库表的 需要继承models.Model这个类来管理数据库:
class ec2(models.Model):
name = models.CharField(max_length=32)
price = models.IntegerField()
pub = models.CharField(max_length=22)
4 数据库表建立好后需要让表写入到数据库
1 python manage.py makemigrations
2 python manage.py migrate
5 models 表里面需要在原来的表里面在新增一个字段字段提示:
Please select a fix:
1) Provide a one-off default now (will be set on all existing rows with a null value for this column) #现在提供一次性默认值（将在所有现有行上设置此列的空值）
2) Quit, and let me add a default in models.py 退出，让我添加一个默认的 models.py
Select an option: 1 #选择1
Please enter the default value now, as valid Python
The datetime and django.utils.timezone modules are available, so you can do e.g. timezone.now
Type 'exit' to exit this prompt
>>> "pool" #添加默认字段内容
6 ORM数据增加
有如下表：
class Test(models.Model):
name = models.CharField(max_length=32)
password = models.CharField(max_length=32)
add = models.CharField(max_length=32)
email = models.CharField(max_length=32)
def __str__(self):
return self.name
增的2种形式4种方法
方法1 models.Test.objects.create(name='ajx', password='test', add='beijing', email='123@163.com')
方法2 models.Test.objects.create(**{'name':'djaong','password':'null','add':'null','email':'null'}) #推荐这方法
方法3 arg = models.Test(name='gost', password='test', add='beijing', email='123@163.com')
arg.save()
方法4 arg = models.Test()
arg.name = 'gostadd'
arg.password = 'udi'
arg.add = 'shenzhen'
arg.email = 'null'
arg.save()
通过类的对象操作的话,一定要进行save()方法.
7 ORM更新数据
更新数据
更新id=2的 把password改为1111
models.logininfo.objects.filter(id=2).update(password = '1111')
全部改为1111
models.logininfo.objects.all().update(password = '1111')
8 ORM删除数据
删除所有的
models.logininfo.objects.all().delete()
删除 id =3 的
models.logininfo.objects.filter(id=3).delete()
9 ORM查询
filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
all(): 查询所有结果
get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
-----下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
order_by(*field): 对查询结果排序
reverse(): 对查询结果反向排序
distinct(): 从返回结果中剔除重复纪录
values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
count(): 返回数据库中匹配查询(QuerySet)的对象数量。
first(): 返回第一条记录
last(): 返回最后一条记录
exists(): 判断queryset数据是不是为真,会走sql语句,但是把数据存在缓存
ec1 = ec2.objects.all()[:2]
ec3 = ec2.objects.all()[::2] #隔着获取,每隔2个获取
ec4 = ec2.objects.all()[::-1] #倒着隔着获取
ec5 = ec2.objects.first() #获取第一个
ec6 = ec2.objects.last() #获取最后一个
ec9 = ec2.objects.exclude(name="ok").values("pub") #排除name等于ok的数据 其他都显示
ec12 = ec2.objects.all().values("name").distinct() #找到name字段的值,进行去重
查询执行的语句
user_list = models.userinfo.objects.all()
print(user_list.query) #查询SQL执行的语句
#查询数据
query 查询当前sql语句
ret = models.username.objects.all().query
print(ret)
获取单条数据，不存在则报错（不建议）
models.username.objects.get(id=123) 这查询出来是一个对象
models.username.objects.filte(id=123)filter查询出来的是一个QuerySet类型 models.username.objects.filter(name='seven')[0]查询出来就是一个对象;
获取指定条件的数据
models.username.objects.filter(name='seven')
models.username.objects.exclude(name='seven') 查询不等于seven的数据
查询username表中的所有数据,查询出来的类型是QuerySet,可以用for循环,QuerySet可以支持for循环,拿数据
ret = models.username.objects.all()
print(ret)
for item in ret:
print(item.user, item.id)
查询username中的'id', 'user'字段,数据是以字典形式
ret = models.username.objects.all().values('id', 'user')
print(ret)
for item in ret:
print(item)
查询username中的'id', 'user'字段,数据是以列表形式,里面是元祖
ret = models.username.objects.all().values_list('id', 'user')
print(ret)
for item in ret:
print(item)
10 ORM了不起的双下划线(__)之单表条件查询
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") #like
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
startswith，istartswith, endswith, iendswith,
11 ORM创建一对多
创建一对多（谁是多，ForeignKey就建立在谁的表里面）外面一定是建立到多的那边
class Publisher(models.Model):
Publisher_all = models.CharField(max_length=32)
def __str__(self):
return self.name
class Book(models.Model):
Book_name = models.CharField(max_length=32)
Publisher = models.ForeignKey("Publisher") #会生成一个Publisher_id字段
12 ORM 一对多的查询
一对多查询数据：进行filter跨表操作的时候 需要进行双下划线操作---记死了 (如果是个对象可以用操作比如obj = models.s3.obj.all() 这个查询多来是多条数据,包含在一个对象里面,for循环 所以可以用点来操作)
class Publisher(models.Model): #出版社表
PublisherName = models.CharField(max_length=32)
City = models.CharField(max_length=32)
def __str__(self):
return self.name
class Book(models.Model): #书籍表
Book_name = models.CharField(max_length=32)
ToPublisher = models.ForeignKey("Publisher")
正向查询 书是多,根据书查询年出版社
查询book中ID等于2的对象,根据obj对象查询这个书属于那个城市的出版社(obj.ToPublisher 这个一定是一个对象,这个对象是foreignkey表的对象内容,一条记录的对象)
obj = models.Book.objects.get(id=2)
print(obj.ToPublisher.City) #查询到城市
一对多 3种正向查询的方式:
class Classes(models.Model):
caption = models.CharField(max_length=32)
class Student(models.Model):
name = models.CharField(max_length=32)
cls = models.ForeignKey('Classes')
1 obj = models.Student.objects.all()
print(obj[0].cls.caption)
2 models.Student.objects.all().values('id','name','cls__caption')
3 models.Student.objects.all().values_list('id','name','cls__caption')
反向查询 出版社是单,根据出版社查询多个书籍
根据出版社查询所有的书籍名
obj = models.Publisher.objects.get(PublisherName='新华出版社')
print(obj.book_set.all().values('Book_name')[0]) 和 print(obj.book_set.values('Book_name')[0]) 相等 (book_set 这是django提供的一个反向查询方法 set加上表的名字进行关联,必须小写) Book_set(Book是表名)
双下划线主要用显示关联表的内容(推荐使用)
查询书籍等于'我的心情'这书记属于那个出版社(因为Publisher没使用到ForeignKey,所以直接可以使用book__Book_name) book是表名 Book_name字段名
obj = models.Publisher.objects.filter(book__Book_name='我的心情').values('PublisherName')[0]
或者根据book表查询书名,找到出版社
obj = models.Book.objects.filter(Book_name='我的心情').values('ToPublisher__PublisherName').distinct()[0]
obj = models.Publisher.objects.filter(book__Book_name='我的心情').values('PublisherName').distinct()[0] #distinct去除重复
正向查询,更具出版社查询书名,双下划线前面一定要用一对多那个字段ToPublisher,用Publisher报错,视频讲解有错误
obj = models.Book.objects.filter(ToPublisher__PublisherName='新华出版社').values('Book_name')
13 ORM一对多插入数据
方式1 models.Book.objects.create(**{'Book_name':'c++','Publisher_id':1})
方式2 models.Book.objects.create('Book_name'='c++','Publisher_id'=1)
方式3 obj = models.Publisher.objects.filter(id=3)[0] 或者 obj = models.Publisher.objects.get(id=2)
models.Book.objects.create(**{'Book_name':'c++','Publisher':obj})
#因为 Book表中的 ForeignKey生产的表叫Publisher_id 如果需要通过book表中的Publisher 字段插入的话，就需要先获取到Publisher表中的对象然后在插入数据
14 多对的查询
class book(models.Model):
name = models.CharField(max_length=32)
class author(models.Model):
name = models.CharField(max_length=32)
m = models.ManyToManyField('book')
def __str__(self):
return self.name
操作第3张表,只能间接获取,
操作表的三种方式;跟一对查找差不多
#正向
1 obj = models.author.objects.all()
for i in obj:
print(i.name,i.m.all().values('name'))
2 author_list = models.author.objects.values('id', 'name', 'm__name')
print(author_list)
#反向
3 book_list = models.book.objects.values('id','name','author__name')
print(book_list)
4 obj = models.book.objects.get(id=1)
print(obj.author_set.all())
增加相关操作
obj = models.author.objects.get(id=2) #获取的app aid等于2那个那个数据
obj.m.add(2,3,4,5)
obj.mtm.add(*[2,3,4,5])
清空 删除和更新相关操作
obj.m.clear() #清除author表中id=2的所有数据包含
obj.m.remove(1) 删除id=2 对应的第一本书
obj.m.set([3,5,7]) #更新操作 把aid=2的全部更新为3 5 7.
#反向操作增加 删除 更新同上
obj = models.book.objects.get(id=3)
obj.author_set.add(1,2,3)
15 ORM惰性机制：
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
QuerySet的高效使用：
<1>Django的queryset是惰性的
Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得
到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数，
这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。
<2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
为了验证这些,需要在settings里加入 LOGGING(验证方式)
obj=models.Book.objects.filter(id=3)
# for i in obj:
# print(i)
# if obj:
# print("ok")
<3>queryset是具有cache的
当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行
（evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset，
你不需要重复运行通用的查询。
obj=models.Book.objects.filter(id=3)
# for i in obj:
# print(i)
## models.Book.objects.filter(id=3).update(title="GO")
## obj_new=models.Book.objects.filter(id=3)
# for i in obj:
# print(i) #LOGGING只会打印一次
<4>
简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些
数据！为了避免这个，可以用exists()方法来检查是否有数据：
obj = Book.objects.filter(id=4)
# exists()的检查可以避免数据放入queryset的cache。
if obj.exists():
print("hello world!")
<5>当queryset非常巨大时，cache会成为问题
处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统
进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法
来获取数据，处理完数据就将其丢弃。
objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:
print(obj.name)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
print(obj.name)
#当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使
#用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询
总结:
queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。
使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能
会造成额外的数据库查询。
16 查看ORM执行的每条sql语句?? 在setting里面增加如下配置
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
17 ORM聚合查询(Avg Min Sun Max)
通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。
from django.db.models import Avg,Min,Max,Sum
聚合查询用到aggregate
从整个查询集生成统计值。比如，你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有
图书的集合。
>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}
aggregate()子句的参数描述了我们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的
标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定
一个名称，可以向聚合子句提供它:
>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}
如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
print(models.Apple.objects.all().aggregate(Avg('price')))
print(models.Apple.objects.all().aggregate(Avg('money')))
print(models.Apple.objects.all().aggregate(Min('price')))
print(models.Apple.objects.all().aggregate(Min('money')))
print(models.Apple.objects.all().aggregate(Max('price')))
print(models.Apple.objects.all().aggregate(Max('money')))
print(models.Apple.objects.all().aggregate(Sum('price')))
print(models.Apple.objects.all().aggregate(Sum('money')))
18 ORM F操作
from django.db.models import Q,F
更新Book表中 ID等于3的中的pages字段中的pages数加100
F就如下操作:
def orm(self):
models.Book.objects.filter(id=3).update(pages=F('pages') + 100)
return HttpResponse("OK")
19 ORM Q操作
from django.db.models import Q,F
Q(Q(username=u)&Q(pwd=p))|~Q(Q(emial=u)&Q(pwd=p)) ~非操作
Q(Q(username=u)&Q(pwd=p))|~Q(Q(emial=u)&Q(pwd=p),name='Gosht') name='Gosht'必须放后面,不然报错
Q构造条件分为两种方式:
第1种:
models.UserInfo.objects.filter( Q(Q(username=u)&Q(pwd=p)) | Q(Q(emial=u)&Q(pwd=p)) )
分解:Q(Q(username=u)&Q(pwd=p))|Q(Q(emial=u)&Q(pwd=p))
第一个Q: Q(username=u) & Q(pwd=p) 之间and操作
第二个Q: Q(Q(emial=u) & Q(pwd=p)之间and操作
Q(Q(username=u)&Q(pwd=p)) | Q(Q(emial=u)&Q(pwd=p)) 构建一个大Q 让2个小Q之间or操作
比如一个登录页面允许帐号或者邮件登录2中方式
第2种:
把上面第一种Q(Q(username=u)&Q(pwd=p)) | Q(Q(emial=u)&Q(pwd=p)) 用第二中表达如下
con = Q() 创建一个大Q对象 相当于上面的红色的这个Q(Q(username=u)&Q(pwd=p)) | Q(Q(emial=u)&Q(pwd=p))
q1 = Q() 创建小Q对象 相当于上面的红色的这个 Q(username=u)&Q(pwd=p))
q1.connector = 'AND' 让小Q对象里面条件为and 相当于上面的红色的这个Q(username=u)&Q(pwd=p))
q1.children.append(('username', u)) 让小Q对象里面增加查询条件 相当于上面的红色的这个Q(username=u)&Q(pwd=p))
q1.children.append(('pwd', p)) 让小Q对象里面增加查询条件 相当于上面的红色的这个Q(username=u)&Q(pwd=p))
# Q(Q(username=u)&Q(pwd=p))
q2 = Q() 与上相同
q2.connector = 'AND'
q2.children.append(('email', e))
q2.children.append(('password', p))
# Q(Q(email=2)&Q(pwd=p))
con.add(q1, 'OR') #大Q然后增加小Q1对象
con.add(q2, 'OR') #大Q然后增加小Q2对象
最终构造了一个搜索条件:
Q(Q(username=u)&Q(pwd=p)) | Q(Q(emial=u)&Q(pwd=p))
放入models开始执行 models.UserInfo.objects.filter(con)
为什么要在 con.add(q1, 'OR') 加OR:
可能有这样的条件 id == 1 or q1 or q2 如果不是这样的条件上面 con.add(q1, 'OR') 不会报错
如何让一个字典做第二种方式搜索:
#vla = {'id': 1,'name': 'root'}
for k,v in val.items:
q1.children.append((k, v))
在创建一个q,并且是让connector 等于OR
q = Q()
q.connector = 'OR'
创建条件,(id=1) (id=3) (id=2)之间的关系就是上面创建的OR关系 也就是之间或关系
q.children.append((id,1))
q.children.append((id,3))
q.children.append((id,2))
20 ORM分组
1.和sql对比：
1.models.Employee Employee相当于sql中的from 后面的表名
2.annotate前面的values值相当于group by的字段
3.(a=Avg("salary"))里面如是跨表查询就需要使用双下划线，正查就字段__另一张表的字段，反查就另一张表明__字段
4.annotate后面的values 是select的字段
对应格式：select __ from ___ inner join ———— on ... group by ____
2.关键点：
1.queryset对象.annotate() annotate前面是queryset对象
2.annotate进行分组统计，按前面select的字段进行group by
3.annotate（）返回值依然是queryset对象，增加了分组统计之后的键值对
补充:
1 stu = models.studen.objects.all() ----> 拿到是一个是querset数据类型,可以把这种数据类型理解为是一个列表 取到结果是[obj,obj,obj,obj,obj] #obj是一个对象.怎么获取obj的值? obj.name,obj.age
2 stu = models.studen.objects.all().values('id','name') ----> 拿到是一个也是是querset数据类型取到结果是[{'id':1,"name":'xxx'},{'id':2,"name":'zzz'}]
3 stu = models.studen.objects.all().values('id','name') ----> 拿到是一个也是是querset数据类型取到结果是[(1,'xxx'),(2,'zzz')]
跨表查询(一对多查询)
class school(models.Model):
'''校区表'''
schoolname = models.CharField(max_length=22)
class Student(models.Model):
'''学生表'''
username = models.CharField(max_length=33)
age = models.IntegerField()
gender = models.NullBooleanField()
cs = models.ForeignKey("Classes",on_delete=False) #cs 代表是Classes表的一个对象(title,fk(fk代表是school对象(n)))
class Classes(models.Model):
'''班级表'''
title = models.CharField(max_length=33)
#m = models.ManyToManyField("Teacher")
fk = models.ForeignKye("School",no_delete=False,related_name="sss")
1 查找python班所有的学生
models.Student.objects.filter(cs__title="pyrhon班")
#另外一种写法反向查询(有两次查询sql次数,推荐正向查找):
obj = modes.Classes.objects,fileter(title="python班").first() ===> queryset对象值 [obj.obj,obj] #现在找到班级
obj.student__set.all() ===> queryset对象值 [obj.obj,obj] #通过班级找到学生,student是学生表(小写);也就是说反向查询的时候,Classes表里面隐含了一个字段student__set,通过这个字段,可以进行数据操作(这个隐含的字段必须是其他表跟这个表(classes)ForeignKye字段关联,才能使用)总结:
正向查询:cs 这个ForeignKye字段查询
反向查询:小写的表名字+__set查询 (如果有related_name="sss",可以使用ssss__set后去数据)
2 查找python班所有的学生以及所在班级和姓名
stu = models.Student.objects.filter(cs__title="pyrhon班").values("username","cs__title")
取结果:
for row in stu:
print(row['username'],row['cs__fitle'])
3 查找python班所有的学生以及所在班级,姓名 和 校区
stu = models.Student.objects.filter(cs__title="pyrhon班").values("username","cs__title","cs__fk__schoolname")
跨表查询(多对多)
class Classes(models.Model):
'''班级表'''
title = models.CharField(max_length=33)
m = models.ManyToManyField("Teacher",related_name="sss") #m
class Teacher(models.Model):
'''老师表'''
name = models.CharField(max_length=33) #classes_set
获取到值如下:
obj = models.Classes.objects.all() #对象
get = models.Classes.objects.get(id=1) #对象
filter = models.Classes.objects.filter(id=2)[0] #对象
filter = models.Classes.objects.filter(id=2).first() #对象
filter = models.Classes.objects.filter(id=2) #queryset
#正向添加
filter.m.add(2) #只有对象才能add操作 也就是找到id=2的数据,然后在第三张表中添加第二个老师
filter.m.add(*[1,2])
#反向添加
filter = models.teacher.objects.filter(id=2).first()
filter.classes__set.add(2) #通过老师来添加班级
for 循环获取值:
obj = models.Classes.objects.all()
for i in obj:
print(i.id,i.title,i.m.all().values("name"))
for row in i.m.all():
print(row.name)
