前言
Django框架功能齐全自带数据库操作功能，本文主要介绍Django的ORM框架
https://www.cnblogs.com/sss4/p/7070942.html
到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：
创建数据库，设计表结构和字段
使用 MySQLdb 来连接数据库，并编写数据访问层代码
业务逻辑层去调用数据访问层执行数据库操作
ORM是什么？：(在django中，根据代码中的类自动生成数据库的表也叫--code first)
ORM：Object Relational Mapping(关系对象映射)
类名对应------》数据库中的表名
类属性对应---------》数据库里的字段
类实例对应---------》数据库表里的一行数据
obj.id obj.name.....类实例对象的属性
Django orm的优势：
Django的orm操作本质上会根据对接的数据库引擎，翻译成对应的sql语句；所有使用Django开发的项目无需关心程序底层使用的是MySQL、Oracle、sqlite....，如果数据库迁移，只需要更换Django的数据库引擎即可；
一、Django连接MySQL
1、创建数据库 （注意设置 数据的字符编码）
由于Django自带的orm是data_first类型的ORM，使用前必须先创建数据库
create database day70 default character set utf8 collate utf8_general_ci;
2、修改project中的settings.py文件中设置 连接 MySQL数据库（Django默认使用的是sqllite数据库）
DATABASES = {
'default': {
'ENGINE':'django.db.backends.mysql',
'NAME':'day70',
'USER':'eric',
'PASSWORD':'123123',
'HOST':'192.168.182.128',
'PORT':'3306',
}
}
扩展：查看orm操作执行的原生SQL语句
在project中的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',
},
}
}
3、修改project 中的__init__py 文件设置 Django默认连接MySQL的方式
import pymysql
pymysql.install_as_MySQLdb()
4、setings文件注册APP
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01.apps.App01Config',]
5、models.py创建表
6、进行数据迁移
6.1、在winds cmd或者Linux shell的项目的manage.py目录下执行
python manage.py makemigrations #根据app下的migrations目录中的记录，检测当前model层代码是否发生变化？python manage.py migrate#把orm代码转换成sql语句去数据库执行
python manage.py migrate --fake#只记录变化，不提交数据库操作
python manage.py inspectdb > models.py#检查DB中已经创建完毕的表结构，生成model.py
扩展：修改表结构之后常见报错
这个报错：因为表创建之时，新增字段既没有设置默认值，也没有设置新增字段可为空，去对应原有数据导致；
2中解决方法：
1.设置新增字段可以为空
startdate = models.CharField(max_length=255, verbose_name="任务开始时间",null=True, blank=True) Handledate= models.CharField(max_length=255, verbose_name="开始处理时间",null=True, blank=True) Handledone= models.CharField(max_length=255, verbose_name="处理完毕时间",null=True, blank=True) enddate= models.CharField(max_length=255, verbose_name="任务结束时间",null=True, blank=True) WorkTime_cost=models.CharField(max_length=255,verbose_name='工作耗时',null=True, blank=True)
2.设置新增字段默认值为 当前时间
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>>>timezone.now()
3.更多问题
python manage.py makemigrations :把你写在models中的代码翻译成增、删、改的 SQL 语句；
python manage.py migrate；讲python manage.py makemigrations翻译的SQL语句去数据库执行；
python manage.py migrate --fake；假设 migrate 把所有SQL语句执行成功了；
我在使用Django构建表结构的时候很长一段时间都是没有了解以上3条语句的执行意义，所有经常在修改表结构之后出现报错；
出现报错的原因：
无非就是 makemigrations翻译的 SQL，跟数据库里面真实的表结构 相互冲突,增加、删除不了表、外键关系；
所以遇到报错 你应该先把model中的代码注释掉-----》python manage.py migrate --fake------》python manage.py makemigrations
去数据库把已经存在的表、外键删掉（确保数据库目前的状态，可以让makemigrations翻译出来的SQL语句在数据库里执行成功；然后migrate）--------》 python manage.py migrate；
7.设置pycharm可视化MySQL
三、ORM单表操作
0、orm操作前戏
orm使用方式：
orm操作可以使用类实例化，obj.save的方式，也可以使用create（）的形式
QuerySet数据类型介绍
QuerySet与惰性机制
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
<3>惰性计算和缓存机制
def queryset(request):
books=models.Book.objects.all()[:10]#切片 应用分页books = models.Book.objects.all()[::2]
book= models.Book.objects.all()[6]#索引print(book.title)
forobjinbooks:#可迭代print(obj.title)
books=models.Book.objects.all()#惰性计算--->等于一个生成器，不应用books不会执行任何SQL操作# query_set缓存机制1次数据库查询结果query_set都会对应一块缓存，再次使用该query_set时，不会发生新的SQL操作；#这样减小了频繁操作数据库给数据库带来的压力;authors=models.Author.objects.all()
forauthorin authors:
print(author.name)
print('-------------------------------------')
models.Author.objects.filter(id=1).update(name='张某')
forauthorin authors:
print(author.name)
#但是有时候取出来的数据量太大会撑爆缓存，可以使用迭代器优雅得解决这个问题； models.Publish.objects.all().iterator()
returnHttpResponse('OK')
增加和查询操作
增
def orm(request):
orm2添加一条记录的方法
单表
1、表.objects.create（）
models.Publish.objects.create(name='浙江出版社',addr="浙江.杭州")
models.Classify.objects.create(category='武侠')
models.Author.objects.create(name='金庸',sex='男',age=89,university='东吴大学')
2、类实例化：obj=类（属性=XX） obj.save()
obj=models.Author(name='吴承恩',age=518,sex='男',university='龙溪学院')
obj.save()
1对多
1、表.objects.create()
models.Book.objects.create(title='笑傲江湖',price=200,date=1968,classify_id=6, publish_id=6)
2、类实例化：obj=类（属性=X,外键=obj）obj.save()
classify_obj=models.Classify.objects.get(category='武侠')
publish_obj=models.Publish.objects.get(name='河北出版社')
注意以上获取得是和 book对象 向关联的（外键）的对象
book_obj=models.Book(title='西游记',price=234,date=1556,classify=classify_obj,publish=publish_obj)
book_obj.save()
多对多
如果两表之间存在双向1对N关系，就无法使用外键来描述其关系了；
只能使用多对多的方式，新增第三张表关系描述表；
book=models.Book.objects.get(title='笑傲江湖')
author1=models.Author.objects.get(name='金庸')
author2=models.Author.objects.get(name='张根')
book.author.add(author1,author2)
书籍和作者是多对多关系，
切记：如果两表之间存在多对多关系，例如书籍相关的所有作者对象集合，作者也关联的所有书籍对象集合
book=models.Book.objects.get(title='西游记')
author=models.Author.objects.get(name='吴承恩')
author2 = models.Author.objects.get(name='张根')
book.author.add(author,author2)
#add() 添加#clear() 清空#remove() 删除某个对象returnHttpResponse('OK')
根据条件判断，增加？更新？
# 根据user=user去查找，如果找到更新 如果没有找到创建defaults={} 中的数据tk = gen_tcoken(username)
models.Token.objects.update_or_create(user=user, defaults={'token': tk})
删
级联删除
为防止读者跑路，不再赘述！
改
# 修改方式1 update()models.Book.objects.filter(id=1).update(price=3)
#修改方式2 obj.save() book_obj=models.Book.objects.get(id=1)
book_obj.price=5 book_obj.save()
查
def ormquery(request):
books=models.Book.objects.all()#------query_set对象集合 [对象1、对象2、.... ]books=models.Book.objects.filter(id__gt=2,price__lt=100)
book=models.Book.objects.get(title__endswith='金')#---------单个对象，没有找到会报错book1 = models.Book.objects.filter(title__endswith='金').first()
book2 = models.Book.objects.filter(title__icontains='瓶').last()
books=models.Book.objects.values('title','price',#-------query_set字典集合 [{一条记录},{一条记录} ]'publish__name',
'date',
'classify__category',#切记 正向连表:外键字段___对应表字段'author__name',#反向连表： 小写表名__对应表字段'author__sex',#区别：正向 外键字段__，反向 小写表名__'author__age',
'author__university')
books=models.Book.objects.values('title','publish__name').distinct()
#exclude 按条件排除。。。#distinct()去重, exits()查看数据是否存在？ 返回 true 和falsea=models.Book.objects.filter(title__icontains='金').
returnHttpResponse('OK')
连表查询
反向连表查询：
1、通过object的形式反向连表， obj.小写表名_set.all()
publish=models.Publish.objects.filter(name__contains='湖南').first()
books=publish.book_set.all()
forbookin books:
print(book.title)
通过object的形式反向绑定外键关系
authorobj = models.Author.objects.filter(id=1).first()
objects = models.Book.objects.all()
authorobj.book_set.add(*objects)
authorobj.save()
2、通过values双下滑线的形式，objs.values("小写表名__字段")
注意对象集合调用values（），正向查询是外键字段__XX,而反向是小写表名__YY看起来比较容易混淆；
books=models.Publish.objects.filter(name__contains='湖南').values('name','book__title')
authors=models.Book.objects.filter(title__icontains='我的').values('author__name')
print(authors)
fifter()也支持__小写表名语法进行连表查询：在publish标查询 出版过《笑傲江湖》的出版社
publishs=models.Publish.objects.filter(book__title='笑傲江湖').values('name')
print(publishs)
查询谁（哪位作者）出版过的书价格大于200元
authors=models.Author.objects.filter(book__price__gt=200).values('name')
print(authors)
通过外键字段正向连表查询，出版自保定的书籍；
city=models.Book.objects.filter(publish__addr__icontains='保定').values('title')
print(city)
1、基本操作
# 增## models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs# obj = models.Tb1(c1='xx', c2='oo')# obj.save()# 查## models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）# models.Tb1.objects.all() # 获取全部# models.Tb1.objects.filter(name='seven') # 获取指定条件的数据# 删## models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据# 改# models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新，均支持 **kwargs# obj = models.Tb1.objects.get(id=1)# obj.c1 = '111'# obj.save() # 修改单条数据基本操作
2、进阶操作（了不起的双下划线）
利用双下划线将字段和对应的操作连接起来
# 获取个数## models.Tb1.objects.filter(name='seven').count()
# 大于，小于
## models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值#
models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值#
models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值#
models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值#
models.Tb1.objects.filter(id__lt=10, id__gt=1) #获取id大于1 且 小于10的值#
in## models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33])
# not in# isnull# Entry.objects.filter(pub_date__isnull=True)# contains#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range## models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and#
其他类似## startswith，istartswith, endswith, iendswith,# order by#
# models.Tb1.objects.filter(name='seven').order_by('id') #
asc# models.Tb1.objects.filter(name='seven').order_by('-id') #
desc# group by## from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"# limit 、offset#
# models.Tb1.objects.all()[10:20]# regex正则匹配，iregex 不区分大小写#
# Entry.objects.get(title__regex=r'^(An?|The) +')# Entry.objects.get(title__iregex=r'^(an?|the) +')# date#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))# year## Entry.objects.filter(pub_date__year=2005)# Entry.objects.filter(pub_date__year__gte=2005)#
month## Entry.objects.filter(pub_date__month=12)# Entry.objects.filter(pub_date__month__gte=6)# day## Entry.objects.filter(pub_date__day=3)# Entry.objects.filter(pub_date__day__gte=3)# week_day## Entry.objects.filter(pub_date__week_day=2)# Entry.objects.filter(pub_date__week_day__gte=2)# hour## Event.objects.filter(timestamp__hour=23)# Event.objects.filter(time__hour=5)# Event.objects.filter(timestamp__hour__gte=12)# minute## Event.objects.filter(timestamp__minute=29)# Event.objects.filter(time__minute=46)# Event.objects.filter(timestamp__minute__gte=29)# second## Event.objects.filter(timestamp__second=31)# Event.objects.filter(time__second=2)# Event.objects.filter(timestamp__second__gte=31)进阶操作
3、其他操作（执行原生SQL）
# 执行原生SQL 1.执行自定义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()2.使用extra方法## 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'])3.使用raw方法
解释：执行原始sql并返回模型
说明：依赖model多用于查询
用法：
book = Book.objects.raw("select * from hello_book")
foritemin book:
print(item.title)
https://www.cnblogs.com/413xiaol/p/6504856.html
# F## from django.db.models import F# models.Tb1.objects.update(num=F('num')+1)# Q## 方式一：# Q(nid__gt=10)# Q(nid=8) | Q(nid__gt=10)# Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')# 方式二：# con = Q()# q1 = Q()# q1.connector = 'OR'# q1.children.append(('id', 1))# q1.children.append(('id', 10))# q1.children.append(('id', 9))# q2 = Q()# q2.connector = 'OR'# q2.children.append(('c1', 1))# q2.children.append(('c1', 10))# q2.children.append(('c1', 9))# con.add(q1, 'AND')# con.add(q2, 'AND')## models.Tb1.objects.filter(con)