ORM增删改查

#一、ORM单表的增删改查

    #表记录的添加
        from app1.models import *
        #方式1
        Author.objexts.create(name='alvin')
        #方式2
        Author.objects.create(**{'name':'alex'})
        
　　　　　#方式1
        author = Author(name='alvin')
        author.save()
        #方式2
        author = Author()
        author.name = 'alvin'
        author.save()

    #表记录的修改
        #方式1
            Book.object.filter(author='kang').update(price=100)
        #方式2(有save的效率低，不建议用)
            b = Book.objects.get(author='kang')
            b.price = 123
            b.save()
    #表记录的删除
        Book.objects.filter(author='kang').delete()

    #表记录的查找

        #相关查询API
        filter(**kwargs)   包含了与所给筛选条件相匹配的对象,按照条件选出结果
        all()   查询所有结果
        get(**kwargs)    返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会报错

        #下面的方法都是对查询的结果进行处理
        values(*field)    返回一个字典序列
        exclude(**kwargs)  包含了与所给筛选条件不匹配的对象，按照条件排除结果
        order_by(*field)   对查询结果进行排序
        reverse()   对查询结果反向排序
        distinct()   从返回结果中剔除重复记录
        values_list(*field)  返回的是一个元组序列，values返回的是一个字典序列
        count()   返回数据库中匹配查询（QuerySet）的对象数量
        first()  返回第一条记录
        last()  返回最后一条记录
        exists()   如果QuerySet包含数据，则返回True，否则返回False

        __gt大于
        __lt小于
        __in 等于
        __contains 按大写选择
        __icontains 不区分大小写
        __range  在什么之间

# django 升级到2.0之后,表与表之间关联的时候,必须要写on_delete参数,否则会报异常:
# TypeError: init() missing 1 required positional argument: ‘on_delete’
#
# on_delete各个参数的含义如下：
#
#     on_delete=None,               # 删除关联表中的数据时,当前表与其关联的field的行为
#     on_delete=models.CASCADE,     # 删除关联数据,与之关联也删除
#     on_delete=models.DO_NOTHING,  # 删除关联数据,什么也不做
#     on_delete=models.PROTECT,     # 删除关联数据,引发错误ProtectedError
#     # models.ForeignKey('关联表', on_delete=models.SET_NULL, blank=True, null=True)
#     on_delete=models.SET_NULL,    # 删除关联数据,与之关联的值设置为null（前提FK字段需要设置为可空,一对一同理）
#     # models.ForeignKey('关联表', on_delete=models.SET_DEFAULT, default='默认值')
#     on_delete=models.SET_DEFAULT, # 删除关联数据,与之关联的值设置为默认值（前提FK字段需要设置默认值,一对一同理）
#     on_delete=models.SET,         # 删除关联数据,
#      a. 与之关联的值设置为指定值,设置：models.SET(值)
#      b. 与之关联的值设置为可执行对象的返回值,设置：models.SET(可执行对象)
#
# 由于多对多(ManyToManyField)没有 on_delete 参数,所以以上只针对外键(ForeignKey)和一对一(OneToOneField)


#二、ORM多表的增删改查

# ORM多表1（一对多）

    # 添加
        Book.objects.create(name='python',price=34,pub_date='2021-01-01',publish_id=2)
        Book.objects.create(name='java',price=10,pub_date='2019-08-01',publish_id=3)

    # 修改
        Book.objects.filter(id=17).update(price=100,pub_date='1998-11-13')

    # 删除
        Book.objects.filter(name='php').delete()   #删除名字为PHP的书

    # 查询：
        # 实例1：查询人民出版社出过的所有书籍的名字和价格
            # 方式1
            pub_obj = Publish.objects.filter(name='人民出版社')[0]
            ret = Book.objects.filter(publish=pub_obj).values('name','price')
            print(ret)

            # 方式2
            pub_obj = Publish.objects.filter(name='人民出版社')[0]
            ret = pub_obj.book_set.all().values('name','price')
            print(ret)

            # 方式3（通过双下划线）
            ret = Book.objects.filter(publish__name='人民出版社').values('name','price')
            print(ret)

        # 实例2：查询python这本书出版社的名字
            # 方式1
            ret0 = Publish.objects.filter(book__name='python').values('name')
            print(ret0)

            # 方式2
            ret1 = Book.objects.filter(name='python').values('publish__name')
            print(ret1)

        # 实例3：通过对象来查找记录
            book_obj = Book.objects.get(name='python')
            print(book_obj)   #python
            print(book_obj.name)  #name=python
            print(book_obj.price)  #price=34
            print(book_obj.pub_date)   #pub_date=2021-01-01
            print(book_obj.publish)   #Publish object
            print(book_obj.publish.name)    #机械出版社
            print(book_obj.publish.city)  #上海
            print(book_obj.publish.id)  #2
            print(book_obj.publish_id)  #publish_id=2
            print(book_obj.id)    #id=13

        # 实例4：查询生产地在甘肃兰州的书的名字
            ret = Book.objects.filter(publish__city='甘肃兰州').values('name')
            print(ret)   #go和java

        # 实例5：查找生产时间在2010-01-01到2021-07-29之间出版的书
            ret = Book.objects.filter(pub_date__lt='2021-07-29',pub_date__gt='2010-01-01').values('name')  #__lt小于，__gt大于
            print(ret)  #python/linux/go/HTML/java

        # 实例6：查找java的出版社
            # 方式1
            ret = Publish.objects.filter(book__name='java').values('name')
            print(ret)    #甘肃出版社

            # 方式2
            ret = Book.objects.filter(name='java').values('publish__name')
            print(ret)

# ORM多表2（多对多）

    #增加
        # 创建多对多的关系：author = models.ManyToManyField("Author")------>此时会自动生成关联表
        #（1）book_authors表添加信息
            #添加一条信息
                book_obj = Book.objects.get(id=13)   #书的对象
                author_objs = Author.objects.get(id=1)
                book_obj.authors.add(author_objs)
            #添加多条信息
                book_obj = Book.objects.get(id=19)
                author_objs = Author.objects.all()
                book_obj.authors.add(*author_objs)

        #（2）通过创建第三张表来添加信息
            Book_Author.objects.create(book_id=16,author_id=1)

    #修改
        修改与一对多修改方式一样

    #删除
        #对book_authors表删除信息（即删除自动生成表的信息）
            #删除一条信息
                book_obj = Book.objects.get(id=19)
                author_objs = Author.objects.get(id=1)
                book_obj.authors.remove(author_objs)
            #删除多条信息
                book_obj = Book.objects.get(id=19)
                author_objs = Author.objects.all()
                book_obj.authors.remove(*author_objs)

    #查询
        #(一)、通过对象的方式绑定关系（自动生成的第三张表的操作）
        #方式1
            book_obj = Book.objects.get(id=13)            
　　　　　　　print(book_obj.authors.all())  #QuerySet对象
　　　　　　　print(type(book_obj.authors.all()))  #<class 'django.db.models.query.QuerySet'>

        #方式2
            author_obj = Author.objects.get(id=2)            
　　　　　　　print(author_obj.book_set.all())        

　　　　#(二)、通过创建的第三张表来查找
　　
　　　　#alex出过的书籍名称及价格
            ret = Book.objects.filter(book_author__author__name='alex').values('name','price')            
　　　　　　　print(ret)        

#注：以下实例都使用自动生成的第三张表来操作
　　　　#实例1：查找alex出过的书籍的名字及价格
            ret_0 = Book.objects.filter(authors__name='alex').values('name','price')            
　　　　　　　print(ret_0)  #<QuerySet [{'name': 'HTML', 'price': 540}, {'name': 'java', 'price': 10}, {'name': 'python', 'price': 34}]>

        #聚合函数：
                annotate(*args,**kwargs):可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。
                aggregate(*args,**kwargs):通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。
　　　　　　　　#实例2：求price的平均值
                　　ret_1 = Book.objects.all().aggregate(Avg('price'))                    
　　　　　　　　　　   print(ret_1)                

　　　　　　　　#实例3：求price的总和
                    ret_2 = Book.objects.all().aggregate(Sum('price'))                    
　　　　　　　　　　　　print(ret_2)                

　　　　　　　　#实例4：求price的最小值
                    ret_3 = Book.objects.all().aggregate(Min('price'))                    
　　　　　　　　　　　　print(ret_3)  #{'price__min': 20}

             #实例5：求price的最大值
                    ret_4 = Book.objects.all().aggregate(max_money=Max('price'))                    
　　　　　　　　　　　　print(ret_4)   #{'max_money': 550}------>max_mongy是可以自己定义的

　　　　　　　　#实例6：alex出过书的总价格
　                  ret_5 = Book.objects.filter(authors__name='alex').aggregate(Sum('price'))                    
　　　　　　　　　　　　print(ret_5)                

　　　　　　　　#实例7：alex出过书的数量
                    ret_6 = Book.objects.filter(authors__name='alex').aggregate(Count('name'))                    
　　　　　　　　　　　　print(ret_6)        

　　　　#分组
　　　　　　　　#实例8：求每个作者出过书的总价格
                ret_7 = Book.objects.values('authors__name').annotate(Sum('price'))                
　　　　　　　　　print(ret_7)        

　　　　#F查询：使用查询条件的值进行操作
　　　　　　　　#实例9：为每本书增加10块钱
                Book.objects.all().update(price=F('price')+10)        

　　　　#Q查询：
　　　　　　　　#实例10：找价格为44或者名字为go的
                ret_8 = Book.objects.filter(Q(price=44) | Q(name='go'))                
　　　　　　　　　　print(ret)            

　　　　　　　　#实例11：查找书名中有P的书
                ret_9 = Book.objects.filter(Q(name__contains='p'))                
　　　　　　　　　print(ret_9)            
　　
　　　　　　　　#实例12：查找书名中有l的并且价格为53的书
                ret_10 = Book.objects.filter(Q(name__contains='l') & Q(price=53))                
　　　　　　　　　print(ret_10)   #linux

            #~(非)的使用
                ret_11 = Book.objects.filter(Q(name__contains='l')& ~ Q(price=53))                
　　　　　　　　　 print(ret_11)  #linux运维

注：

Django的queryset的惰性机制
# <1>Django的queryset是惰性的
#
#      Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得
#      到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
#      上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数，
#      这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。
#
# <2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
#    为了验证这些,需要在settings里加入 LOGGING(验证方式)
#         obj=models.Book.objects.filter(id=3)
#         # for i in obj:
#         #     print(i)
#
#         # if obj:
#         #     print("ok")
#
# <3>queryset是具有cache的
#      当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行
#     （evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset，
#      你不需要重复运行通用的查询。
#         obj=models.Book.objects.filter(id=3)
#
#         # for i in obj:
#         #     print(i)
#                           ## models.Book.objects.filter(id=3).update(title="GO")
#                           ## obj_new=models.Book.objects.filter(id=3)
#         # for i in obj:
#         #     print(i)   #LOGGING只会打印一次
#
# <4>
#      简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些
#      数据！为了避免这个，可以用exists()方法来检查是否有数据：
#
#             obj = Book.objects.filter(id=4)
#             #  exists()的检查可以避免数据放入queryset的cache。
#             if obj.exists():
#                 print("hello world!")
#
# <5>当queryset非常巨大时，cache会成为问题
#
#      处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统
#      进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法
#      来获取数据，处理完数据就将其丢弃。
#         objs = Book.objects.all().iterator()
#         # iterator()可以一次只从数据库获取少量数据，这样可以节省内存
#         for obj in objs:
#             print(obj.name)
#         #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
#         for obj in objs:
#             print(obj.name)
#
#      #当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使
#      #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询
#
# 总结:
#     queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。
# 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能
# 会造成额外的数据库查询。