Django之ORM表操作

ORM表操作

1.ORM单表操作

　首先想操作表的增删改查，需要先导入这个表,以之前创建的UserInfo表为例,在app下的views.py中导入

from app import models

def query(request):
    new_obj = models.UserInfo(
        id=1,
        name='北北',
        bday='2019-09-27',
        checked=1,
    )
    new_obj.save()
    return HttpResponse('ok')

这样就创建了一条记录

增加

方式1:

obj = models.UserInfo(
	id = 2,
	name = '京京',
	bday = '2019-9-27',
	checked = '1',
	)
obj.save()

方式2:

ret = models.UserInfo.objects.create(
	name = '欢欢',
	bady = '2019-9-27',
	checked = 0,
	)
print(ret)  #UserInfo object

#ret 是创建的新的记录的model对象

ps:批量插入(bulk_create)

obj_list= []
for i in range(20):
    obj = models.Book(
    	title=f"西游记{i}",
    	price=20+i,
    	publish_date=f"2019-09-{i+1}",
    	publisher="人民出版社"
    	)
    obj_list.append(obj)
    
models.Book.objects.bulk_create(obj_list)  #批量创建


从前端页面获取到的数据即:request.POST得到的是querydict类型
 data = request.POST.dict() --能够将querydict转换成普通的字典
创建数据时可以:
    models.Book.objects.create(**data)

删除

首先要通过简单查询:filter()  -- 查询结果是queryset类型的数据,里面是一个个的model对象,此数据类型类似于列表

方式1:

models.UserInfo.objects.filter(id = 3).delete()
#通过queryset对象删除

方式2:

models.UserInfo.objects.filter(id = 3)[0].delete()
#通过model对象删除

修改

方式1:

models.UserInfo.objects.filter(id = 2).update(
	name = '英英',
	checked = 0,
	)
#通过queryset对象进行修改,而model对象不能调用update方法

方式2:

ret = models.UserInfo.objects.filter(id = 2)[0]
ret.name = '英英'
ret.checked = 0
ret.save()

查找

查询API

1.all() 		查询所有结果,得到的是queryset类型

ret = models.UserInfo.objects.all()

2.filter(**kwargs)  它包含了与所给筛选条件相匹配的对象,结果也是queryset类型  

ret = models.UserInfo.objects.filter(name='英英' checked=0)
#and多条件查询
#查询条件不能匹配到数据时,不会报错,会返回一个空的query(<QuerySet []>),如果没有写查询条件会获取所有数据,queryset类型的数据还能继续调用filter方法

3.get(**kwargs) 

ret = models.UserInfo.objects.get(name='英英')
#得到的是一个model对象(行记录对象),有且只能有一个
#1.查不到数据会报错:UserInfo matching query does noe exist.
#2.超过一个也会报错:returned more than one UserInfo

4.exclude(**kwargs)   排除,它包含了与所给筛选条件不匹配的对象,返回的时queryset类型

ret = models.UserInfo.objects.exclude(name='英英')
#1.object能够调用models.UserInfo.objects.exclude(name__startswith=='贝贝')
#2.queryset类型数据能够调用models.UserInfo.objects.all().exclude(name__startswith=='贝贝')

5.order_by(*filed)  queryset类型的数据来调用，对查询结果排序,默认是按照id来升序排列的，返回值还是queryset类型

ret = models.UserInfo.objects.all().order_by('-grade','id')
#按成绩降序排列,成绩相同的按id升序排列

6.reverse()  queryset类型的数据来调用,对查询结果反向排序,返回值还是queryset类型

ret = models.UserInfo.objects.all().order_by().reverse()
#数据排序后才能进行反装

7.count() 		queryset类型的数据来调用，返回数据库中匹配查询(QuerySet)的对象数量。

ret = models.UserInfo.objects.all().count()

8.first()  	queryset类型的数据来调用,返回第一条记录

ret = models.UserInfo.objects.all().first()

9.last() 	queryset类型的数据来调用,返回最后一条记录

ret = models.UserInfo.objects.all().last()

10.exists()  	queryset类型的数据来调用,如果queryset包含数据,就返回True,否则返回False

ret = models.UserInfo.objects.filter(id=9).exists()
#判断返回结果集是不是有数据

11.values(*filed)   	
#queryset类型的数据来调用，返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列,只要是返回的queryset类型，就可以继续链式调用queryset类型的其他的查找方法，其他方法也是一样的。

ret=models.UserInfo.objects.filter(id=2).values('name','bday')

12.values_list(*filed)
#它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

ret=models.UserInfo.objects.all().values_list('name','bday')

#调用values或者values_list的是objects控制器,那么返回所有数据
#	ret = models.Book.objects.all().values()
#	ret = models.Book.objects.values()  


13.distinct()   #values和values_list得到的queryset类型的数据来调用，从返回结果中剔除重复记录

ret = models.UserInfo.objects.all().values('checked').distinct()

基于双下划线的模糊查询

ret = models.Book.objects.filter(price__gt=35)  #大于
ret = models.Book.objects.filter(price__gte=35) # 大于等于
ret = models.Book.objects.filter(price__lt=35) # 小于等于
ret = models.Book.objects.filter(price__lte=35) # 小于等于
ret = models.Book.objects.filter(price__range=[35,38]) 
# 大于等35,小于等于38    where price between 35 and 38
ret = models.Book.objects.filter(price__in=[32,35,38])
# price值等于这三个值里面的任意一个的对象   or
ret = models.Book.objects.filter(title__contains='西游记') 
# 字段数据中包含这个字符串的数据都要
ret = models.Book.objects.filter(title__icontains="python") # 不区分大小写
ret = models.Book.objects.filter(title__startswith="py")  
# 以什么开头，istartswith  不区分大小写
ret = models.Book.objects.filter(publish_date='2019-09-15')
#按照日期查询

查询某年某月某日:
ret = models.Book.objects.filter(publish_date__year='2018')
#2018写数字也可以
ret = models.Book.objects.filter(publish_date__year__gt='2018')
#查询出版日期大于2018年的
    
ret = models.Book.objects.filter(publish_date__year='2019',publish_date__month='8',publish_date__day='1')
#查询出版日期为2019-8-1的

找字段数据为空的双下滑线
ret = models.Book.objects.filter(publish_date__isnull=True) #这个字段值为空的那些数据

插入时间问题

在表的结构里新增列来显示时间
class UserInfo(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=10)
    bday = models.DateField()
    checked = models.BooleanField()
    # now = models.DateTimeField(null=True)
    now = models.DateTimeField(auto_now_add=True,null=True)
    #自动插入时间
    now2 = models.DateTimeField(auto_now=True,null=True)
    # 更新记录时,自动添加更新时的时间,创建新纪录时也会帮你自动添加创建时的时间
    
在提交后进行新增记录:
import datetime
current_date = datetime.datetime.now()
models.UserInfo.objects.create(
        name='妮妮',
        bday=current_date,
        now=current_date,  # 自己手动直接插入时间没有时区问题
        checked=0
    )

#但是如果让这个字段自动来插入时间,就会有时区的问题,auto_now_add创建记录时自动添加当前创建记录时的时间,存在时区问题
now = models.DateTimeField(auto_now_add=True,null=True)
解决方法:
    settings配置文件中将USE_TZ的值改为False
    USE_TZ = False  
    # 告诉mysql存储时间时按照当地时间来寸,不要用utc时间
使用pycharm的数据库客户端的时候,时区问题要注意



更新时的auto_now参数
	# 更新记录时,自动更新时间,创建新纪录时也会帮你自动添加创建时的时间,但是在更新时只有使用save方法的model对象的形式更新才能自动更新时间,有缺陷,放弃
    now2 = models.DateTimeField(auto_now=True,null=True)

2.ORM多表操作

创建模型

表和表之间的关系

　　一对一、多对一、多对多　，用book表和publish表自己来想想关系，想想里面的操作，加外键约束和不加外键约束的区别，一对一的外键约束是在一对多的约束上加上唯一约束。

实例：我们来假定下面这些概念，字段和关系

　　作者模型：一个作者有姓名和年龄。

　　作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）

　　出版商模型：出版商有名称，所在城市以及email。

　　书籍模型： 书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。

　　模型建立如下：

from django.db import models

# Create your models here.


class Author(models.Model): 
    '''
    作者表
    '''
    
    name=models.CharField(max_length=32)
    age=models.IntegerField()
  au=models.OneToOneField('AuthorDetail',on_delete=models.CASCADE)
	#就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为authorDetail_id
    # 与AuthorDetail建立一对一的关系，一对一的这个关系字段写在两个表的任意一个表里面都可以

class AuthorDetail(models.Model):
	'''
	作者详细信息表
	'''
    
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)

class Publish(models.Model):
    '''
    出版社表
    '''
    
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    #class Meta:
    	#db_table='authordetail'  --指定表名
        #ordering=['id']    --指定排序方式

#多对多的表关系，手动创建一个第三张表，然后写上两个字段，每个字段外键关联到另外两张多对多关系的表，orm的manytomany自动帮我们创建第三张表，两种方式建立关系都可以，手动创建的第三张表进行orm操作的时候，很多关于多对多关系的表之间的orm语句方法无法使用,如果想删除某张表，只需要将这个表注销掉，然后执行那两个数据库同步指令就可以了，自动就删除了。
class Book(models.Model):
    '''
    书籍表
    '''
    
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
publishs=models.ForeignKey(to='Publish',on_delete=models.CASCADE)
	authors=models.ManyToManyFiled('Author',)
    # foreignkey里面可以加很多的参数，to指向表，to_field指向你关联的字段，不写默认会自动关联主键字段，on_delete级联删除　字段名称不需要写成publish_id，orm在翻译foreignkey的时候会自动给你这个字段拼上一个_id,这个字段名称在数据库里面就自动变成了publish_id     
    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且查看book表的时候，看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个book类里面有authors这个字段属性
    # 与Publish建立一对多的关系,外键字段建立在多的一方，字段publish如果是外键字段，那么它自动是int类型
     #注意不管是一对多还是多对多，写to这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面

增加

通过两种方式

一对一:

au_obj = models.AuthorDetail.objects.get(id = 4)
models.Author.objects.create(
	name = '韩寒',
	age = 32,
    #方式1:将对象作为值给au,也就是自动将au_obj的id赋值给au_id
	au = au_obj,
    
    #方式2:直接写id值
    #au_id = 4,    
   
)

一对多:

pub_obj = models.Publish.objects.get(id = 3)
models.Book.objects.create(
	title = '红楼梦',
	price = 160.00,
	publishDate = '2011-11-12',
    #方式1:类属性作为关键字段时,值为model对象
	publishs = pub_obj,

	#方式2:如果关键字为数据库字段名称,那么值为关联数据的值
	#publish_id = 3
	)

多对多:

new_obj = models.Book.objects.create(
	title = '红楼梦',
	price = 180.00,
	publishDate = '2010-08-13',
	publishs_id = 2,
	)
#方式1:
new_obj.authors.add(3,5)   
# new_obj.authors.add(*[3,5])  利用打散的方式,等同于上面的方式

#方式2:
obj1 = models.Author.objects.get(id=3)
obj2 = models.Author.objects.get(id=5)
new_obj.authors.add(obj1,obj2)

删除

一对一:

models.AuthorDetail.objects.filter(id=3).delete()

models.Author.objects.filter(id=3).delete()

一对多:

models.Publish.objects.filter(id=3).delete()

models.Book.objects.filter(id=4).delete()

多对多:

book_obj = models.Book.objects.get(id=2)
book_obj.authors.remove(1)   #指定删除
book_obj.authors.clear()     #清空
book_obj.authors.set(['1','2'])  #先清除在添加,相当于修改

修改

修改的方法与添加类似

ret = models.Publish.objects.get(id=2)
models.Book.objects.filter(id=5).update(
	title = '活着',
    #方式1:
	publishs = ret,

	#方式2:
	#publishs_id = 1,
	)

查询

基于对象的跨表查询

一对一查询(Author与AuthorDetail)

关系属性写在表1,关联到表2,那么通过表1的数据去找表2的数据,叫做正向查询,返过来就是反向查询
    

    # 正向查询  对象.属性
    # 例:查询一下韩寒的电话号码
    obj = models.Author.objects.filter(name='韩寒').first()
    ph = obj.au.telephone
    print(ph)

    
    
    # 反向查询  对象.小写的表名
    # 例:查一下电话号码为120的作者姓名
    obj = models.AuthorDetail.objects.filter(telephone=120).first()
    ret = obj.author.name  
    print(ret)

一对多查询(Publish与Book)

    #正向查询
    # 查询一下红楼梦这本书是哪个出版社出版的  
    obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
    ret = obj.publishs.name
    print(ret)  
    
    #反向查询
    # 查询一下 人民出版社出版过哪些书
    obj = models.Publish.objects.filter(name='人民出版社').first()
    ret = obj.book_set.all()
    for i in ret:
        print(i.title)

多对多查询(Author与Book)

    # 正向查询
    # 查询一下红楼梦是哪些作者写的 
    obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
    ret = obj.authors.all()
    for i in ret:
        print(i.name)

        
    # 反向查询
    # 查询一下韩寒写了哪些书 
    obj = models.Author.objects.filter(name='韩寒').first()
    ret = obj.book_set.all()
    for i in ret:
        print(i.title)
        #print(i.publishs.name) --查询这些书的出版社名称

3.基于双下划线的跨表查询(基于join实现的)

​ Django还提供了一种直观而且高效的方式在查询(lookups)中表示关联关系,它能自动确认SQL JOIN联系.要做跨关系查询,就使用双下划线来连接模型(model)间关联字段的名称,直到最终连接到需要的model

​ 基于双下划线的查询:正向查询按字段,反向查询按表名小写来告诉orm引擎join哪张表,一对一,一对多,多对多都是一个写法(在写orm查询的时候,哪张表在前哪张表在后都没问题,因为是join连表操作)

一对一查询

查询韩寒的手机号

正向查询
ret = models.Author.objects.filter(name='韩寒').values('au__telephone')

反向查询
ret = models.AuthorDetail.objects.filter(author__name = '韩寒').values('telephone')

一对多查询

红楼梦是哪个出版社出版的

正向查询
ret = models.Book.objects.filter(title='红楼梦').values('publishs__name')

反向查询
ret = models.Publish.objects.filter(book__title='红楼梦').values('name')


查询一下人民出版社出版了哪些书

正向查询
ret = models.Book.objects.filter(publishs__name='人民出版社').values('title')

反向查询
ret = models.Publish.objects.filter(name='人民出版社').values('book_title')

多对多查询

查询一下红楼梦是哪些作者写的

正向查询
ret = models.Book.objects.filter(title='红楼梦').values('authors__name')

反向查询
ret = models.Author.objects.filter(book__title='红楼梦').values('name')

related_name

反向查询时,如果定义了related_name,则用related_name替换表名,比如

publish = ForeignKey(to='publisher',related_name = 'booklist')

查询人民出版社出版过哪些书

反向查询 不再按表名:book,而是related_name:booklist
ret = models.Publish.objects.filter(name='人民出版社').values('booklist__title')

4.聚合查询和分组查询

聚合查询

aggregate(*args,**kwargs)

计算所有图书的平均价格

from django.db.models import Avg
ret = models.Book.objects.all().aggregate(Avg('price'))
#或者给它起名字:aggretate(a=Avg('price'))
print(ret)
#{'price__avg':34.35}

aggregate()是QuerySet的一个终止语句,意思是说,它返回一个包含一些键值对的字典.键的名称是聚合值的标识符,值是计算出来的聚合值,键的名称是按照字段和聚合函数的名称自动生成出来的.如果你想为聚合值指定一个名称,可以向聚合子句提供它.

ret = models.Book.objects.aggregate(a=Avg('price'))
print(ret)
#{'a':34.35}

如果希望生成不止一个聚合,可以向aggregate()子句中添加另一个参数,所以,可以这样查询

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

ret = models.Book.objects.aggregate(Avg('price'),Max('price'),Min('price'))
print(ret)
#{'price__avg':34.35,'price__max':Decimal('81.20'),'price__min':Decimal('12.99')}

分组查询

annotate()为调用的QuerySet中每一个对象都生成一个独立的统计值(统计方法用聚合函数)

跨表分组查询的本质就是将关联表join成一张表,再按单表的思路进行分组查询

查询每个出版社出版的书的平均价格

#用publish表的id字段进行分组
ret = models.Book.objects.values('publish__id').annotate(a=Avg('price'))

#用book表的publish_id字段进行分组
ret = models.Book.objects.values('publishs_id').annotate(a=Avg('price'))

ret = models.Publish.objects.annotate(a=Avg('book__price')).values('a')

F查询与Q查询

F查询

假设在book表中加入两个字段:评论数:comment,收藏数:keep

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

查询评论数大于收藏数的书籍

from django.db.models import F
ret = models.Book.objects.filter(comment__gt=F('keep'))

Django支持F()对象之间以及F()对象和常数之间的加减乘除和取模的操作

查询评论数大于收藏数两倍的书籍

ret = models.Book.objects.filter(comment__gt=F('keep')*2)

修改操作也可以使用F函数,比如将每一本书的价格提高30元

models.Book.objects.all().update(price=F('price')+30)

Q查询

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

Q对象可以使用&(与), |(或) , ~(非) 操作符组合起来.当一个操作符在两个Q对象使用时,它产生一个新的Q对象

from django.db.models import Q


ret = models.Book.objects.filter(Q(authors__name='韩寒')|Q(authors__name='余华'))

等同于下面的SQL where子句

where name = '韩寒' or name = '余华'

可以组合使用& 和 | 操作符以及使用括号进行分组来编写任意复杂的Q对象.同时,Q对象可以使用 ~ 操作符取反,允许组合正常的查询和取反 (not)查询

ret = models.Book.objects.filter(Q(authors__name='韩寒')&~Q(publishdate__year=2017)).values_list('title')

ret = models.Book.objects.filter(Q(Q(authors__name='韩寒')&~Q(publishdate__year=2017))&Q(id__gt=6)).values_list('title')
#可以使用Q嵌套,多层Q嵌套等

查询函数可以混合使用Q对象和关键字参数 .所有提供给查询函数的参数(关键字参数或Q对象)都将'AND'在一起,但是,如果出现Q对象,它必须位于所有关键字参数的前面,例如

ret = models.Book.objects.filter(
    Q(publishdate__year=2016) | Q(publishdate__year=2017),
    title='python'   #也是and的关系,但是Q必须写在前面
                                 
)

5.ORM执行原生SQL语句

在模型查询API不够用的情况下，我们还可以使用原始的SQL语句进行查询。

Django 提供两种方法使用原始SQL进行查询：一种是使用raw()方法，进行原始SQL查询并返回模型实例；另一种是完全避开模型层，直接执行自定义的SQL语句。

执行原生查询

raw()管理器方法用于原始的SQL查询，并返回模型的实例：

　　　　注意：raw()语法查询必须包含主键。

这个方法执行原始的SQL查询，并返回一个django.db.models.query.RawQuerySet 实例。 这个RawQuerySet 实例可以像一般的QuerySet那样，通过迭代来提供对象实例。

举个例子：

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

可以像下面这样执行原生sql语句

for p in Person.objects.raw('SELECT * FROM myapp_person'):   	print(p)

raw()查询可以查询其他表的数据

举例:

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

raw()方法自动将查询字段映射到模型字段。还可以通过translations参数指定一个把查询的字段名和ORM对象实例的字段名互相对应的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

原生SQL还可以使用参数，注意不要自己使用字符串格式化拼接SQL语句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

直接执行自定义SQL

我们可以直接从django提供的接口中获取数据库连接，然后像使用pymysql模块一样操作数据库。

from django.db import connection, connections
cursor = connection.cursor() 
# cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()

6.python脚本中调用django环境(django外部脚本使用models)

如果想通过自己创建的python文件在django项目中使用django的models，那么就需要调用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)