Django—ORM常用字段与参数

常用字段

AutoField

int自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。

IntegerField

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

CharField

字符类型，必须提供max_length参数， max_length表示字符长度。

这里需要知道的是Django中的CharField对应的MySQL数据库中的varchar类型，没有设置对应char类型的字段，但是Django允许我们自定义新的字段，下面我来自定义对应于数据库的char类型

DateField

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

配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。

配置上auto_now=True，每次更新数据记录的时候会更新该字段。

DateTimeField

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

关系字段

ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。

ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

ManyToManyField

一般把ManyToManyField字段设置在 '多对多'中'多'的一方

 OneToOneField

一对一字段。

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

单独的py文件测试ORM操作需要配置的参数

import os


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


主要是queryset对象就可以无限制的点queryset方法(*******************)
models.User.objects.filter().filter().filter().count()

新增数据

python
# 第一种：有返回值，并且就是当前被创建的数据对象
    modles.Book.objects.create(name='',price='',publish='',author='',create_time='2019-5-1')
# 第二种：先实例化产生对象，然后调用save方法保存
    book_obj = models.Book(name='',price='',publish='',author='',create_time='2019-5-1')
    book_obj.save()
# 2.验证时间格式字段即可以传字符串也可以传时间对象
    import datetime
    ctime = datetime.datetime.now()
    book = models.Book.objects.create(name='',price='',author='',create_time=ctime)

删除数据

python
        """删除数据"""

# 1.删除书名为xxx的这本书  queryset方法
    res = models.Book.objects.filter(name='').delete()
    print(res)
# 2.删除书名为xxx的这本书  queryset方法
    res = models.Book.objects.filter(name='').first()
    res.delete()

修改数据

python
# 1.queryset修改
    models.Book.objects.filter(name='').update(price='')
 # 2.对象修改
    book = models.Book.objects.filter(name='').first()
    book.price = 66.66
    book.save()  # 对象只有保存方法 这样也能实现修改需求

 查询数据

<1> all():                  查询所有结果
<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象
<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。（源码就去搂一眼～诠释为何只能是一个对象）
<4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象
<5> order_by(*field):       对查询结果排序('-id')/('price')
<6> reverse():              对查询结果反向排序     >>>前面要先有排序才能反向
<7> count():                返回数据库中匹配查询(QuerySet)的对象数量。
<8> first():                返回第一条记录
<9> last():                返回最后一条记录
<10> exists():              如果QuerySet包含数据，就返回True，否则返回False
<11> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列                             model的实例化对象，而是一个可迭代的字典序列
<12> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
<13> distinct():            从返回结果中剔除重复纪录

all

filter

filter内可以放多个限制条件但是需要注意的是多个条件之间是and关系

get

get拿到的是具体确定的唯一对象，可直接进行操作，当给他的条件不能找出一个确定的对象则会报错

exclue(查找除了这个的其他记录)

order_by (对查找结果排序)

注意是字符串形式

默认为升序，降序前面加个‘-’

reverse(对查询结果反向排序 >>>前面要先有排序才能反向)

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

first(返回第一条记录)

 

last(返回最后一条记录)

 exists如果QuerySet包含数据，就返回True，否则返回False

values(*field)

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

.values('') # 列表套字典，好取值

values_list(*field)

它与values() 非常相似，它返回的是一个元组序列，values返回的是一个字典序列

distinct():          

 从返回结果中剔除重复纪录， 去重的对象必须是完全相同的数据才能去重（意味着带了id就没有意义了）

双下划綫

查询年轻大于44岁的用户
    res = models.User.objects.filter(age__gt=44)
    print(res)
    查询年轻小于44岁的用户
    res = models.User.objects.filter(age__lt=44)
    print(res)
    查询年轻大于等于44岁的用户
    res = models.User.objects.filter(age__gte=44)
    print(res)
    查询年轻小于等于44岁的用户
    res = models.User.objects.filter(age__lte=44)
    print(res)

    查询年龄是44或者22或者73的用户
    res = models.User.objects.filter(age__in=[44,22,73])
    print(res)

    查询年龄在22到44范围内
    res = models.User.objects.filter(age__range=[22,44])
    print(res)

查询名字中包含字母n的用户  sqlite数据库演示不出来大小写的情况！！！
    res = models.Author.objects.filter(name__contains='n')
    res = models.User.objects.filter(name__icontains='e')  # 无视大小写
    print(res)

    查询名字以j开头的用户
    res = models.User.objects.filter(name__startswith='j')
    print(res)
    查询名字以n结尾的用户
    res = models.User.objects.filter(name__endswith='n')
    print(res)

    查询注册是在2017年的用户
    res = models.User.objects.filter(register_time__year=2017)  # sqlite对日期格式不太精准
    print(res)

多表查询

表与表之间的关系
一对一(OneToOneField):一对一字段无论建在哪张关系表里面都可以，但是推荐建在查询频率比较高的那张表里面
一对多(ForeignKey):一对多字段建在多的那一方
多对多(ManyToManyField):多对多字段无论建在哪张关系表里面都可以，但是推荐建在查询频率比较高的那张表里面
ps:如何判断表与表之间到底是什么关系
换位思考
A能不能有多个B
B能不能有多个A

add() 添加

给书籍绑定与作者之间的关系
    添加关系 add:add支持传数字或对象，并且都可以传多个
    book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.add(1)
    book_obj.authors.add(2,3)
    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)

set() 修改

修改书籍与作者的关系  set()  set传的必须是可迭代对象！！！
    book_obj = models.Book.objects.filter(pk=3).first()
    可以传数字和对象，并且支持传多个
    book_obj.authors.set((1,))
    book_obj.authors.set((1,2,3))

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

remove() 移除，不能接受可迭代对象

删除书籍与作者的绑定关系
    book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.remove(1)
    book_obj.authors.remove(2,3)
    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)  # 需要将queryset打散

clear() 清空，不用传参

清空  clear()  清空的是你当前这个表记录对应的绑定关系
    book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.clear()

正向反向的概念

正向查询按字段，反向查询按表表名小写

 一对一
     正向：author---关联字段在author表里--->authordetail        按字段
     反向：authordetail---关联字段在author表里--->author        按表名小写
         查询jason作者的手机号   正向查询
         查询地址是 :山东 的作者名字   反向查询
      
一对多
     正向：book---关联字段在book表里--->publish        按字段
     反向：publish---关联字段在book表里--->book        按表名小写_set.all() 因为一个出版社对应着多个图书

多对多
     正向：book---关联字段在book表里--->author        按字段
     反向：author---关联字段在book表里--->book        按表名小写_set.all() 因为一个作者对应着多个图书

正向

 查询书籍是三国演义的出版社邮箱
    book_obj = models.Book.objects.filter(title='三国演义').first()
    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()
    print(publish_obj.book_set)  # app01.Book.None
    print(publish_obj.book_set.all())

    查询作者jason写过的所有的书                      多对多字段的反向查询
    author_obj = models.Author.objects.filter(name='jason').first()
    print(author_obj.book_set)  # app01.Book.None
    print(author_obj.book_set.all())

    查询作者电话号码是110的作者姓名                   一对一字段的反向查询
    authordetail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    print(authordetail_obj.author.name)

基于双下划綫查询

正向

 查询书籍为三国演义的出版社地址
    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)
    查询书籍为三国演义的作者的电话号码
    res = models.Book.objects.filter(title='三国演义').values('authors__authordetail__phone')
    print(res)

配置文件配置参数查看所有orm操作内部的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',
                },
            }
        }

聚合函数 aggregate

from django.db.models import Max,Min,Count,Sum,Avg
    查询所有书籍的作者个数
    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)  # 4498.636
    统计东方出版社出版的书籍的个数
    res = models.Publish.objects.filter(name='东方出版社').aggregate(count_num=Count('book__id'))
    print(res)

分组查询(group by) annotate

统计每个出版社出版的书的平均价格
    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)