Django 模型层

Django models层

一.ORM 中常用字段和参数

1.常用字段

AutoField

自增列,可以将其理解为ID主键字段,注意的是必须填入参数 primary_key=True
当model中如果没有自增列，则自动会创建一个列名为id的列
​

id = models.AutoField(primary_key=True) 

IntegerField

整形字段,围在 -2147483648 to 2147483647。(一般不用它来存手机号(位数也不够)，直接用字符串存，)
​

kucun = models.IntegerField()  # 可以不指定参数 

CharField

字符字段，必须提供max_length参数， max_length表示字符长度。
​

title = models.CharField(max_length=255)
# 注意:Django中的CharField对应的MySQL数据库中的varchar类型 

DecimalField

小数字段,必须提供max_digits参数和decimal_places参数
​

price = models.DecimalField(max_digits=8,decimal_places=2)

DateField

日期字段，日期格式  YYYY-MM-DD，相当于Python中的datetime.date()实例。
​

publish_date = models.DateField(auto_now_add=True) 

DateTimeField

日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime()实例。

2.字段参数

verbose_name

　给字段命名

null

用于表示某个字段可以为空。null=True 

unique

如果设置为unique=True 则该字段在此表中必须是唯一的 。

db_index

如果db_index=True 则代表着为此字段设置索引

default

为该字段设置默认值

关于时间参数

1.auto_now_add
配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。
​
2.auto_now
配置上auto_now=True，每次更新数据记录的时候会更新该字段。

3.关系字段

1.ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。
ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

字段参数

1.to 设置要关联的表

publish = models.ForeignKey(to='Publish')  # 默认是跟publish表的主键字段做的一对多外键关联

​
2.to_field
设置要关联的表的字段
​
3.on_delete
当删除关联表中的数据时，当前表与其关联的行的行为。

2.OneToOneField

通常一对一字段用来扩展已有字段。(通俗的说就是一个人的所有信息不是放在一张表里面的，简单的信息一张表，隐私的信息另一张表，之间通过一对一外键关联)
ps:可以用 ForeignKey(unique=True) 代替

字段参数

1.to
设置要关联的表。

author_detail = models.OneToOneField(to='AuthorDetail')

​
2.to_field
设置要关联的字段。
​
3.on_delete
当删除关联表中的数据时，当前表与其关联的行的行为。

ManyToManyField

多对多字段
 # 是虚拟字段,表中不会显式,
作用:
1.告诉orm自动创建第三种表
2.帮助orm跨表查询
​

authors = models.ManyToManyField(to='Author') 

二.表操作

表操作之 字段增删改查

增

当一张表已经创建出来之后 后续还想添加字段,可以有两种方式

(1)给新增的字段设置默认值

addr = models.CharField(max_length=32,default='China')  # default该字段默认值

(2)给新增的字段设置成可以为空

age = models.IntegerField(null=True)  # 该字段允许为空

删

删除字段 直接在models.py中注释该字段 然后重新执行两条命令即可 注意:执行完之后 表中该字段所对应的所有的数据全部删除 并且一般情况下 基本是不会用到真正意义上的删除

1.表操作之 单表

查:必知必会13条

<1> all(): 查询所有结果

<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象

<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误

<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象

<5> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列

<6> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

<7> order_by(*field): 对查询结果排序

<8> reverse(): 对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。

<9> distinct(): 从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)

<10> count(): 返回数据库中匹配查询(QuerySet)的对象数量。

<11> first(): 返回第一条记录

<12> last(): 返回最后一条记录

<13> exists(): 如果QuerySet包含数据，就返回True，否则返回False

总结

# 返回QuerySet对象的方法有
all()
​
filter()
​
exclude()
​
order_by()
​
reverse()
​
distinct()
​
# 特殊的QuerySet
values()       返回一个可迭代的字典序列
​
values_list() 返回一个可迭代的元祖序列
​
# 返回具体对象的
get()
​
first()
​
last()
​
# 返回布尔值的方法有：
exists()
​
# 返回数字的方法有
count()

查:双下划线

1.大于/小于
models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
2.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
3.模糊查询
models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
4.范围
models.Tb1.objects.filter(id__range=[1, 3])      # id范围是1到3的，等价于SQL的bettwen and
5.以什么开头 以什么结尾
字段__startswith  字段__endswith
6.按年查询
models.Class.objects.filter(create_time__year=2017)  # date字段可以通过在其后加__year,__month,__day等来获取date的特点部分数据

增

<1> create()

1.create方法能够新增数据 并且有一个返回值
2.返回值就是新增的数据对象本身

res = models.User.objects.create(username=username,password=password)
# insert into user(username,password) values(username,password)
print(res)  >>> User object
print(res.password)
print(res.username)

<2> 对象方法

user_obj = models.User(username=username, password=password)
user_obj.save()

删

models.User.objects.filter(条件).delete()
# delete from user where id = delete_id;
ps: querySet 对象可以用.delete() 方法

改

<1> update()

models.User.objects.filter(id=edit_id).update(username=username,password=password)
# update user set username = username,password = password where id = edit_id
"""
filter拿到是一个列表   filter操作其实都是批量操作
如果filter结果列表中有多个数据 那么会一次性全部修改 
类似于for循环一个个修改
"""
ps: querySet 对象可以用.update() 方法

<2> 对象方法

edit_obj.username = username
edit_obj.password = password
edit_obj.save()
"""
第二种方式会从头到尾将所有的字段全部修改一遍  效率极低,不推荐使用
"""

2.表操作之 多表

<1>.一对多 表关系的增删改

# 一对多 字段数据的增删改查
    # 增
    # 1 传出版社的id数字
    models.Book.objects.create(title='三国演义', prince=189.99, publish_id=1)
    # 2 传出版社对象
    publish_obj = models.Publish.objects.filter(pk=2).first()
    models.Book.objects.create(title='红楼梦', prince=999.99, publish=publish_obj)
​
    # 改
    # 1 传出版社的id数字
    models.Book.objects.filter(pk=1).update(publish_id=3)
    # 2 传出版社对象
    publish_obj = models.Publish.objects.filter(pk=2).first()
    models.Book.objects.filter(pk=1).update(publish=publish_obj)
​
    # 删
    models.Publish.objects.filter(pk=2).delete()  # 默认级联更新级联删除

<1>.多对多 表关系的增删改

 # 多对多表关系 字段数据的增删改
    # 增 给主键为1的书籍添加两个作者
    # 1 传作者的id数字
    book_obj = models.Book.objects.filter(pk=1).first()
    print(book_obj.authors)  # 对象点击多对多虚拟字段 会直接跨到多对多的第三张表
    book_obj.authors.add(1)
    book_obj.authors.add(2, 3)
    # 2 传作者对象
    author_obj = models.Author.objects.filter(pk=1).first()
    author_obj1 = models.Author.objects.filter(pk=2).first()
    author_obj2 = models.Author.objects.filter(pk=3).first()
    book_obj.authors.add(author_obj)
    book_obj.authors.add(author_obj1,author_obj2)
​
    """
       add()
       是给书籍添加作者,括号内既可以传数字也可以传对象
       并且支持一次性传多个,逗号隔开即可
       """
​
    # 改 将主键为1的书籍对象 作者修改为2,3
    # 1 传作者的id数字
    book_obj = models.Book.objects.filter(pk=1).first()
    book_obj.authors.set([2,])
    book_obj.authors.set([2,3])
    # 2 传作者对象
    author_obj = models.Author.objects.filter(pk=1).first()
    author_obj1 = models.Author.objects.filter(pk=2).first()
    author_obj2 = models.Author.objects.filter(pk=3).first()
    book_obj.authors.set([author_obj,])
    book_obj.authors.set([author_obj, author_obj1, author_obj2])
​
    """
    set()括号内,需要传一个可迭代对象 
    可迭代对象中,可以是多个数字组合
    也可以是多个对象组合
    但是不要混着用!!!
    """
​
    # 删
    book_obj = models.Book.objects.filter(pk=1).first()
    book_obj.authors.remove(3)
    book_obj.authors.remove(1,2)
    author_obj = models.Author.objects.filter(pk=1).first()
    author_obj1 = models.Author.objects.filter(pk=2).first()
    author_obj2 = models.Author.objects.filter(pk=3).first()
    book_obj.authors.remove(author_obj)
    book_obj.authors.remove(author_obj1,author_obj2)
    """
        remove()括号内既可以传数字 也可以传对象 
        并且支持传对个 逗号隔开即可
        """
​
    # 将某本书跟作者的关系全部清空
    book_obj = models.Book.objects.filter(pk=1).first()
    book_obj.authors.clear()  # 清空当前书籍与作者的所有关系
    """
       add()
       set()
       remove()
       上面三个都支持传数字 或者对象 并且可以传多个 但是set需要传可迭代对象
​
       clear()
       clear括号内不需要传任何参数
       """

<3>跨表查询

正向与反向的概念
    
    

# 一对一
    # 正向：author表--->关联字段在author表里--->authordetail表      按字段
    # 反向：authordetail表--->关联字段在author表里--->author表      按表名小写
    
      
    # 一对多
    # 正向：book表--->关联字段在book表里--->publish表       按字段
    # 反向：publish表--->关联字段在book表里--->book表       按表名小写_set.all() 因为一个出版社对应着多个图书
    
    # 多对多
    # 正向：book表--->关联字段在book表里--->author表        按字段
    # 反向：author表--->关联字段在book表里--->book表        按表名小写_set.all() 因为一个作者对应着多个图书
    
    
    正向查询按外键字段
    反向查询按表名小写
    """
    基于对象的跨表查询(子查询:将一张表的查询结果当做另外一个查询语句的条件)
    """
    强调:在书写orm语句的时候 跟写sql语句一样 
    不要尝试着 一次性写完  应该做到写一点看一点再一点
​

基于对象的跨表查询

1.正向

# 查询书籍id是1 的出版社名称
book_obj = models.Book.objects.filter(pk=1).first()
print(book_obj.publish.name)  # 对象点外键字段直接跳到对应的表里
2.反向
# 查询出版社是东方出版社出版的书籍
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# print(publish_obj.book_set)  # app01.Book.None
print(publish_obj.book_set.all())
# 总结
"""
    当你反向查询的结果是多个的时候,就需要 表名_set.all()
    否则直接表明小写即可
""" 

 

基于双下划线的查询(连表操作)

本质:   left join
        inner join
        right join
        union

# 查询xiongda作者的手机号
1.正向
res=models.Author.objects.filter(name='xiongda').values('author_detail__phone','author_detail__addr')
print(res)
(解释:author_detail 是 Author表中关联AuthorDetail表的外键字段(外键字段可以理解为就是被关联表中的一行数据即一条记录)
author_detail__phone 就是拿到了xiongda对应在AuthourDetail表中的那条记录里的phone字段的值)
2.反向
res1 = models.AuthorDetail.objects.filter(author__name='xiongda').values('phone')
print(res1)

聚合查询(aggregate)

# 统计所有书的总价格
from django.db.models import Max,Min,Count,Avg,Sum
​
res = models.Book.objects.aggregate(Sum('price'))
res1 = models.Book.objects.aggregate(Avg('price'))
res2 = models.Book.objects.aggregate(Count('price'))
res3 = models.Book.objects.aggregate(Max('price'))
res4 = models.Book.objects.aggregate(Min('price'))
res5=models.Book.objects.aggregate(Max('price'),Min('price'),Count('pk'),Avg('price'),Sum('price'))

分组查询(annotate)

from django.db.models import Max, Min, Count, Avg, Sum
​
# 统计每一本书的作者个数
res = models.Book.objects.annotate(author_num=Count('authors')).values('author_num','title')
​
# 统计出每个出版社卖的最便宜的书的价格
res = models.Publish.objects.annotate(mmp =Min('book__price')).values('name','mmp')
​
# 统计不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1)
​
ps: models 后面跟的是什么就按什么分组

F 查询

F查询的本质就是从数据库中获取某个字段的值
"""
之前查询等号后面的条件都是我们人为输入的
现在变成了需要从数据库中获取数据放在等号后面,实现了动态比较的效果
"""

from django.db.models import F
​
# 查询库存数量大于卖出数量的书
res = models.Book.objects.filter(kucun__gt=F('maichu'))
​
# 将书籍库存数全部增加1000
models.Book.objects.update(kucun=F('kucun')+1000)
​
# 把所有书名后面加上'新款'
from django.db.models.functions import Concat
from django.db.models import Value
​
ret3 = models.Book.objects.update(title=Concat(F('title'), Value('新款')))
models.Book.objects.update(title = F('title')+'新款')  # 不能这么写

Q 查询

filter() 等方法中逗号隔开的条件是与的关系。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。
| 代表或的关系
~ 是取反

from django.db.models import Q
​
# 查询 卖出数大于100 或者 价格小于100块的
models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))
​
# 查询 书名不是 三国演义的书 或者 价格等于444元的
models.Book.objects.filter(~Q(title='三国演义')|Q(price=444))
​
# Q高级用法
    q = Q()
    q.connector = 'or'  # 修改查询条件的关系   默认是and
    q.children.append(('title__contains','三国演义'))  # 往列表中添加筛选条件
    q.children.append(('price__gt',444))  # 往列表中添加筛选条件
    res = models.Book.objects.filter(q)  # filter支持你直接传q对象  但是默认还是and关系
    print(res)

​

三.Django终端打印SQL语句

如果你想知道你对数据库进行操作时，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',
        },
    }
}

四.单独的py文件测试ORM

import os
​
​
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day58.settings")
    import django
    django.setup()
    from app01 import models  # 这一句话必须在这下面导入
 

 五.自定义char字段

class MyChar(models.Field):
    def __init__(self,max_length,*args,**kwargs):
        self.max_length = max_length
                        
        super().__init__(max_length=max_length,*args,**kwargs)

    def db_type(self, connection):
        return 'char(%s)'%self.max_length

六.数据库查询优化

orm内所有的语句操作 都是惰性查询:只会在你真正需要数据的时候才会走数据库,如果你单单只写orm语句时不会走数据库的

这样设计的好处 在于 减轻数据库的压力

 

only

特点: 

当你点击一个是only括号内指定的字段的时候,只走一次数据库查询,

当你点击一个不是only括号内指定的字段的时候不会报错,而是会频繁的走数据库查询

res = models.Book.objects.only('title')
for r in res:
    print(r.price)

 

defer

特点:defer与only是相反的,defer会将不是括号内的所有的字段信息 全部查询出来封装对象中

当你点击了括号内指定的字段,就会频繁的周数据库

当你点击了不是括号内指定的字段,不再走数据库

res1 = models.Book.objects.defer('title')
for r in res1: 
    print(r.price)  # 不在走数据库
    print(r.title)  # 将频繁走数据

select_related

特点:

select_related:会将括号内外键字段所关联的那张表 直接全部拿过来(可以一次性拿多张表)跟当前表拼接操作
从而降低你跨表查询 数据库的压力

注意:

select_related括号只能放外键字段(一对一表关系和一对多表关系可以使用)

res = models.Book.objects.all().select_related('publish')
 for r in res:
     print(r.publish.name)
res = res = models.Book.objects.all().select_related('外键字段1__外键字段2__外键字段3__外键字段4')  # 只要有外键就可以一直连表

 prefetch_related 

 特点: 不主动连表

res = models.Book.objects.prefetch_related('publish')
for r in res:
    print(r.publish.name)
"""
不主动连表操作(但是内部给你的感觉像是连表操作了)  而是将book表中的publish全部拿出来  在取publish表中将id对应的所有的数据取出
res = models.Book.objects.prefetch_related('publish')
括号内有几个外键字段 就会走几次数据库查询操作    
"""

 

七.事务

ACID: 原子性,一致性,隔离性,持久性

如何使用

from django.db import transaction
    
with transaction.atomic():
    """
    数据库操作
    在该代码块中书写的操作 同属于一个事务
    """
    models.Book.objects.create()
    models.Publish.objects.create()
    # 添加书籍和出版社 就是同一个事务 要么一起成功要么一起失败
print('出了 代码块 事务就结束')

 八.多对多表关系的三种创建方式

1.全自动(*)

优势:不需要手动创建第三张表

不足:由于第三张表不是手动创建的,也就意味着第三张表字段是固定的无法扩展

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    authors = models.ManyToManyField(to='Author')

class Author(models.Model):
    name = models.CharField(max_length=32)

2.纯手动(了解)

优势:第三张表由于是手动创建的,所以可以任意扩展字段

不足 :orm查询不方便(无法正向查询)

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)

class Author(models.Model):
    name = models.CharField(max_length=32)
                                
class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateField(auto_now_add=True)

3.半自动(*****)

优势:结合了全自动与纯手动两个优点

不足:多对多字段的 add,set,remove,clear 无法使用

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    authors = models.ManyToManyField(to='Author',through='Book2Author',through_fields=('book','author'))
    # through 告诉django orm 书籍表和作者表的多对多关系是通过Book2Author来记录的
    # through_fields 告诉django orm记录关系时用过Book2Author表中的book字段和author字段来记录的

class Author(models.Model):
    name = models.CharField(max_length=32)
    # books = models.ManyToManyField(to='Book', through='Book2Author', through_fields=('author', 'book'))

class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateField(auto_now_add=True)