Django orm操作

一，用一个单独的py文件测试orm操作需要配置的参数

　　在应用中新建一个test.py的测试文件来实现orm操作：

import os
if __name__ == "__main__":                    
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "

    day58.settings")  
     # 以上代码实在当前项目的manage.py中copy的
    
    import django
    django.setup()
    from app01 import models

二，单表的创建，数据的修改，删除

　　1，创建表：

　　在models.py中写下以下代码，并且依次执行python manage.py makemigrations  和 python manage.py migrate

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()
    def __str__(self):
        return '对象的名字:%s'%self.name

　　2，新增数据:

　　　　方式一：

# 基于create创建
user_obj = models.User.objects.create(name='tank',age=73,register_time='2019-2-14')

　　　　方式二：

# 基于对象的绑定方法创建
user_obj = models.User(name='kevin',age=30,register_time='2019-1-1')
user_obj.save()

　　　　ps：register_time 字段可以自动格式化时间：

from datetime import datetime
ctime = datetime.now()
models.User.objects.create(name='egon', age=18, register_time=ctime)

 　　3，修改数据

　　　　方式一：

# 基于对象
user_obj = models.User.objects.filter(name='jason').first()
user_obj.age = 17
user_obj.save()

　　　　方式二：

# 基于queryset
models.User.objects.filter(name='kevin').update(age=66)

　　3，删除数据

　　　　方式一：

# 基于对象
user_obj = models.User.objects.filter(name='owen').first()
user_obj.delete()

　　　　方式二：

# 基于queryset
models.User.objects.filter(name='egon').delete()

三，单表的查询

　　1，查询所有结果

user_obj = models.User.objects.all()

　　2，查询具符合筛选条件的匹配对象

# filter内可以放多个限制条件但是需要注意的是多个条件之间是and关系
models.User.objects.filter(name='jason',age=17)

　　3，查询具符合筛选条件的匹配对象，返回的结果有且只有一个，如果筛选条件对象超过一个或者没有都会报错（不推荐使用）

models.User.objects.get(name='jason')

　　4，查询到与所选筛选条件不匹配的对象

models.User.objects.exclude(name='jason')

　　5，对查询的结果排序

models.User.objects.order_by('age')   # 默认是升序
models.User.objects.order_by('-age')  # 可以在排序的字段前面加一个减号就是降序

　　6，对查询的结果反向排序（前面的结果要有排序（order_by））

models.User.objects.order_by('age').reverse()

　　7，查询querset对象的数量（对queryset对象使用），

 models.User.objects.all().count() # 此时的models.User.objects.all()是一个queryset对象，查询的结果也是querset对象

　　8，查询第一个条记录

models.User.objects.all().first()
models.User.objects.all()[0]  # 不支持负数的索引取值

　　9，查询最后一条记录

models.User.objects.all().last()

　　10，查询该条数据是否存在

models.User.objects.filter(name='jason',age=3).exists() # 如果QuerySet包含数据，就返回True，否则返回False

　　11，返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列

models.User.objects.values('name')  # 列表套字典，字典的键是'字段名'，值是对应数据库中的数据

 　　12，返回一元祖序列

models.User.objects.values_list('name','age')  # 列表套元祖

　 　13，从返回结果中剔除重复纪录，去重的对象必须是完全相同的数据才能去重

models.User.objects.values('name','age').distinct()

 

四，单表的范围查询（双下划线查询）

　　1，查询年轻大于44岁的用户

models.User.objects.filter(age__gt=44) # age > 44

　　2，查询年轻小于44岁的用户

models.User.objects.filter(age__lt=44) # age < 44

　　3，查询年轻大于等于44岁的用户

models.User.objects.filter(age__gte=44) # age >= 44

　　4，查询年轻小于等于44岁的用户

models.User.objects.filter(age__lte=44) # age <= 44

　　5，查询年龄是44或者22或者73的用户

models.User.objects.filter(age__in=[44,22,73]) # or 关系

　　6，查询年龄在22到44范围内

 models.User.objects.filter(age__range=[22,44])

　　7，查询在2017年注册的用户

models.User.objects.filter(register_time__year=2017)

　　8，查询名字中包含字母n的用户 

models.Author.objects.filter(name__contains='n') # 区分大小写
models.Author.objects.filter(name__icontains='n')# 无视大小写

　　9，查询名字以j开头的用户

models.User.objects.filter(name__startswith='j')

　　10，查询名字以j开头的用户

models.User.objects.filter(name__endswith='n')

五，多表的创建，数据的修改和删除

　　多表的创建

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    # 配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库中。
    # 配置auto_now=True，每次更新数据记录都会更新
    publish_date = models.DateField(auto_now_add=True)
    # 外键关系
    # 默认建立一个publish_id字段 与 Publish表的id字段相连
    # publish_id 必须从Publish的id中选取
    publish = models.ForeignKey(to='Publish',to_field=None) # to_field不指定默认为none
    # 在数据库中会建立一个book_authors表，该表中的book_id 和 Book表的id相连
    # 该表中的author_id 和 Book表的id相连
    # 注意：不会在Book表中建立字段
    authors = models.ManyToManyField(to='Author')  # 虚拟字段，信号字段
    def __str__(self):
        return '书籍对象的名字:%s'%self.title

class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    email = models.EmailField()  # 对应就是varchar类型

    def __str__(self):
        return '出版社对象的名字:%s'%self.name

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # AuthorDetail 相当于Author表的延伸
    # 在author表中会有一个authorDetail_id字段，必须从AuthorDetail的id中选取
    authordetail = models.OneToOneField(to='AuthorDetail')

    def __str__(self):
        return  '作者对象的名字:%s'%self.name

class AuthorDetail(models.Model):
    phone = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)

 　　插入数据

　　　　方式一：

# 直接写id 
models.Book.objects.create(title='红楼梦',price=66.66,publish_id=1)

　　　　方式二：

# 传数据对象
publish_obj = models.Publish.objects.filter(pk=2).first() # 首先创建一个Publish对象
models.Book.objects.create(title='三国演义',price=199.99,publish=publish_obj)

　　修改数据

　　　　queryset修改

# 方式一
models.Book.objects.filter(pk=1).update(publish_id=3)
# 方式二
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj)

　　　　对象修改

# 方式一
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.publish_id = 3  # 点表中真实存在的字段名
book_obj.save()
# 方式二
publish_obj = models.Publish.objects.filter(pk=2).first()
book_obj.publish = publish_obj  # 点orm中字段名 传该字段对应的表的数据对象
book_obj.save()

　　删除数据

# 删除后Publish的数据不会改变
models.Book.objects.filter(pk=1).delete()
# 删除后Book里面与Publish外键管理的字段全部清除
models.Publish.objects.filter(pk=1).delete()

　　给书籍绑定与作者之间的关系（给book_authors表中添加字段）

　　　　方式一：add支持传数字，一个或多个

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.add(1)
book_obj.authors.add(2,3) # 书籍序号为3的作者是序号为2和3的作者

　　　　方式二：add支持传对象，一个或多个

author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj,author_obj1)

　　修改数据与作者的关系

　　　　方式一：

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.set((1,)) # 将序号为3的书籍作者修改为序号为1的作者
book_obj.authors.set((1,2,3)) # set传的必须是可迭代对象！！！

　　　　方式二：

author_list = models.Author.objects.all()
book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.set(author_list) # author_list是一个列表里有多个对象

 　　删除数据与作者的绑定关系

　　　　方式一：

 book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.remove(1)
book_obj.authors.remove(2,3)

　　　　方式二：

book_obj = models.Book.objects.filter(pk=3).first()
author_obj = models.Author.objects.all().first()
author_list = models.Author.objects.all()
book_obj.authors.remove(author_obj)
book_obj.authors.remove(*author_list)

　　清空当前表记录对应的绑定关系：

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.clear()

 

六，多表查询

　　多表查询是基于对象的表查询

　　正向查询案例：

　　　　本质是通过点语法得到与之关联的表对象，从而取值（通过字段来用句点符取值）

　　　　查询书籍是三国演义的出版社邮箱：

book_obj = models.Book.objects.filter(title='三国演义').first()
# book_obj.publish相当于从Book表到了Publish表中了
print(book_obj.publish.email)

　　　　查询书籍是三国演义的作者的所有信息：

book_obj = models.Book.objects.filter(title='三国演义').first()
print(book_obj.authors)  # app01.Author.None
print(book_obj.authors.all())

　　　　查询作者为jason电话号码

user_obj = models.Author.objects.filter(name='jason').first()
print(user_obj.authordetail.phone)

　　反向查询案例：

　　　　本质是因为被关联表的并没有明显的字段显示与另一张表的关系，然而实际上有，通过点小写的被关联的表名来取值（通过表名来用句点符取值）

　　　　一对多字段的反向查询：

　　　　　　查询出版社是东方出版社出版的书籍

 publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# 按表名小写_set.all() 因为一个出版社对应着多个图书
print(publish_obj.book_set)  # app01.Book.None
print(publish_obj.book_set.all())

　　　　一对一字段的反向查询：

　　　　　　查询作者电话号码是110的作者姓名　　　　

authordetail_obj = models.AuthorDetail.objects.filter(phone=110).first()
print(authordetail_obj.author.name)

　　　　多对多字段的反向查询：

　　　　　　查询作者jason写过的所有的书

author_obj = models.Author.objects.filter(name='jason').first()
print(author_obj.book_set)  # app01.Book.None
print(author_obj.book_set.all())

七，多表基于双下划线的查询（跨表查询）　　

　　正向查询案例：

　　　　查询书籍为三国演义的出版社地址：

# publish__addr 拿到Publish的addr字段
res = models.Book.objects.filter(title='三国演义').values('publish__addr','title')
print(res)

　　　　查询书籍为红楼梦的作者的姓名：

res = models.Book.objects.filter(title='红楼梦').values("authors__name",'title')
print(res)

　　　　查询作者为jason的家乡：

res = models.Author.objects.filter(name='jason').values('authordetail__addr')
print(res)

 　　反向查询案例

、　　　查询南方出版社出版的书名：

res = models.Publish.objects.filter(name='南方出版社').values('book__title')
print(res)

　　　　查询电话号码为120的作者姓名：

res = models.AuthorDetail.objects.filter(phone=120).values('author__name')
print(res)

　　　　查询作者为jason的写的书的名字：

res = models.Author.objects.filter(name='jason').values('book__title')
print(res)

　　　　查询书籍为三国演义的作者的电话号码：

# authors__authordetail__phone：连续跨表，先到author表，再到authordetail表
res = models.Book.objects.filter(title='三国演义').values('authors__authordetail__phone')
print(res)

　　正反两种方式查询数据

　　　　查询jason作者的手机号：

# 正向
res = models.Author.objects.filter(name='jason').values('authordetail__phone')
print(res)
# 反向
# filter(author__name='jason')：在filter中跨表筛选条件
res = models.AuthorDetail.objects.filter(author__name='jason').values('phone')
print(res)

　　　　查询出版社为东方出版社的所有图书的名字和价格：

# 正向
res = models.Publish.objects.filter(name='东方出版社').values('book__title','book__price')
print(res)
# 反向
res = models.Book.objects.filter(publish__name='东方出版社').values('title','price')
print(res)

　　　　查询东方出版社出版的价格大于400的书：

# 正向
res = models.Publish.objects.filter(name="东方出版社",book__price__gt=400).values('book__title','book__price')
 print(res)
# 反向
res = models.Book.objects.filter(price__gt=400,publish__name='东方出版社').values('title','price')
print(res)

八，聚合查询 (aggregate)

　　查询某个书籍的作者个数：

res = models.Book.objects.filter(pk=3).aggregate(count_num=Count('authors'))
print(res)

　　查询所有出版社出版的书的平均价格：

res = models.Publish.objects.aggregate(avg_price=Avg('book__price'))
print(res)

　　统计东方出版社出版的书籍的个数：

res = models.Publish.objects.filter(name='东方出版社').aggregate(count_num=Count('book__id'))
print(res)

九，分组查询 (annotate) 就是sql语句中的group_by

　　导入聚合函数：

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

　　统计每个出版社出版的书的平均价格：

# 用Publish来分组（因为条件是每个出版社，所以以出版社来分组）
res = models.Publish.objects.annotate(avg_price=Avg('book__price')).values('name','avg_price')
 print(res)

　　统计每一本书的作者个数：

res = models.Book.objects.annotate(count_num=Count('authors')).values('title','count_num')
print(res)

　　统计出每个出版社卖的最便宜的书的价格：

res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
print(res)

　　查询每个作者出的书的总价格：

res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
print(res)