Django-ORM

# 在Django中默认使用自带的sqlite数据库
# 如果想使用MySQL，在settings.py文件中添加下面语句，把之前的sqlite配置注掉
    DATABASES = {
        ‘default‘: {
            ‘ENGINE‘: ‘django.db.backends.mysql‘, 
            ‘NAME‘: ‘books‘,    #你的数据库名称
            ‘USER‘: ‘root‘,   #你的数据库用户名
            ‘PASSWORD‘: ‘‘, #你的数据库密码
            ‘HOST‘: ‘‘, #你的数据库主机，留空默认为localhost
            ‘PORT‘: ‘3306‘, #你的数据库端口
        }
    }

TIME_ZONE = ‘Asia/Shanghai‘   # 使用上海时间

# 这时候创建数据库会报错，因为Django默认使用MySQLdb，这是python2的模块，在python3中使用pymysql
# 要解决这个问题，在项目的__init__.py文件中添加
import pymysql
pymysql.install_as_MySQLdb()

# 创建表=========================================
# models.py
from django.db import models

from django.contrib.auth.models import User # django自带的用户登录验证
#使用时在用户表中添加user字段Foreignkey(User)

#创建一张表，可以不写主键id ，创建表时会自动创建
class Book(models.Model):      # 必须继承这个库
    name = models.CharField(
        null=True                      # 字段可以为空
        max_length=25，                # 必填
        db_column = ‘user‘，           # 数据库列名name->user
        db_index = True,                # 创建索引
        unique = True,                    # 加速查找，限制列值唯一
        primary = True,                  # 加速查找，限制列值唯一且非空
        #admin属性
        verbose_name=‘user‘,
        blank=True,                        # 在admin中字段是否可以为空
        editable=True ，                   # 在admin中是否可编辑
        help_text= ‘帮助信息‘，
        choices                                 # 下拉框选项
        # gf = models.IntegerField(choices=[(0,"v1"),(1,"v2"),],default=1)
        error_messages
        validators                           #自定义错误验证
        
        )
    price = models.IntegerField()
    pub_date = models.DateField()
    class Meta:
        uninque_together("字段一","字段二")    # 联合唯一
        abstract = True     # abstract：抽象的 使定义的这个modle不生成表，只用来供其他model类继承



    想要创建表就在命令行输入下面两条命令
    python manage.py makemigrations
    python manage.py migrate
    
#添加表记录
#方法一---------------------------------------------------
#一个实例对象就是一条表记录，先创建一个对象，再保存
b = Book(name = "python",price=45,........)
b.save()

#方法二---------------------------------------------
Book.objects.create(name = "python",price=45,........)



#修改表记录
# 方式一------------------------------------------
Book.objects.filter().update()                        # <class ‘django.db.models.query.QuerySet‘>  
# 方式二-------------------------------------------
b.Book.objects.get()                                             # <class ‘app01.models.Book‘>
b.prince = 80
b.save()

# 删除表记录
Book.objects.filter().delete()

# 查询表记录 
1.  all()      # 取出全部，支持切片
2.  first() # 取出第一个
3.  last()   # 取出最后一个
4.  get()   #一定会取出那一条记录的对象，其他的是取出一组对象，哪怕只有一个
5.  values    values_list   #通过filter筛选出来的多条记录，可以通过调用这两个方法，获取其中的某个字段，前者是字典，后者是元组
6.  exclude()  # 取出除筛选条件之外的记录
7.  distinct()   # values取字段的时候可能会取到重复字段，用该方法可以去重
# 万能的双下划线-------------------------------
__gt：    #字段名下的数据小于，prince__gt = 10,prince大于10的记录  ，__gte大于等于
__contains   # 字段中包含，  name__contains = "p" ,包含"p",  __icontains不区分大小写


# 多表操作（一对多）

    #添加外键，比如把书绑定到出版社
        /*
        class ForeignKey(to,on_delete,**options) 。
        第一个参数是引用的是哪个模型，第二个参数是在使用外键引用的模型数据被删除了，这个字段该如何处理，
        比如有 CASCADE 、 SET_NULL 等
        */
         - 一对一
            - 一张表其实就是一对一
            -两张表的一对一要添加约束唯一性
         -一对多
            # class Userinfo(models.Model):
            #     username = models.CharField(
            #         max_length=32,
            #     )
            #     p_k = models.ForeignKey(
            #         to="Part",                       # 关联的表
            #         to_field="id",                   # 关联的字段，默认关联ID
            #         on_delete=models.CASCADE,        #与之关联的数据全部删除
                                                                                                        #- models.DO_NOTHING，引发错误IntegrityError
                                                                                                        #- models.PROTECT，   引发错误ProtectedError
                                                                                                        #- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
                                                                                                        #- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
                                                                                                        #- models.SET，删除关联数据，
                                                                                                                      #a. 与之关联的值设置为指定值，设置：models.SET(值)
                                                                                                                      #b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)
            #     )
            # class Part(models.Model):
            #     name = models.CharField(
            #         max_length=32,
            #     )
         -多对多
            -多对多的第三张表有两种创建方式
                a. 添加ManyToMany字段
                    mk = models.ManyToManyField(
                        to="Tag",
                        related_name=None,                 # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
                        related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values(‘表名__字段名‘)
                        limit_choices_to=None,        # 在Admin或ModelForm中显示关联数据时，提供的条件：
                        db_table=None,                         # 创建第三张表时的表名
                        db_constraint=True, 
                        through=None,                           # 指定关系表，即不自动创建，而使用手动创建的第三张表，但有些方法无法使用如add
                        through_fields=None,
                    )
                 b.手动创建第三张表
                    class Utotag(models.Model):
                    u = models.ForeignKey(to="User",on_delete=models.CASCADE)
                    t = models.ForeignKey(to="Tag",on_delete=models.CASCADE)
                    class Meta:                         # 约束多对多关系，使对应的多不能重复
                        verbose_name = u‘图片‘
                        verbose_name_plural = u‘图片‘
                            unique_together = [
                                ("u","t"),          #Please correct the error below.
                            ]
         - 自关联
         # 自关联
            """
            一个网站的用户在一张表中
            用户之间的互相关注，是一种自关联
            """
            class User_list(models.Model):
                user = models.CharField(max_length=32)
                uTOu = models.ManyToManyField(to="User_list",related_name="sss")
                # 建议所有的多表关系都使用related_name
             - 会自动创建另一张表  其中的字段名 ：      id       from_user_list_id        to_user_list_id  
         -select_related("外键字段")
            from app01 import models
            b_obj_list = models.B.objects.all().select_related("fk")
            for row in b_obj_list:
                print(row.name)
                print(row.fk.name)
                # for循环进行跨表查询时每次查询都会到数据库中执行查询，效率低
                #models.B.objects.all().select_related("fk"),这样关联表也会被一次取出，提升了性能
                
       # 在Book类中添加这样一个字段，public = models.ForeignKey("被关联的出版社表",on_delete=models.CASCADE)
       #django会自动在字段名后添加 _id ,默认关联到 id 上
    # 添加记录
        #方式一------------------------------------------
            Book.objects.create(name = "GO",prince=70,pub_date=‘2019-08-07‘,public_id=1)
        #方式二-------------------------------------------
            # 先获取要绑定的对象
                public_object=Public.objects.filter(name=‘人民出版社‘)[0]  # 这是一个对象集合所以取索引0
            # 之后把对象赋给外键（不加_id）
                Book.objects.create(name=‘python‘,prince=50,pub_date=‘2017-02-1‘,public=public_object)
     # 查询记录
        
        # 方式一 正向查询：根据外键找关联，先取到model，然后model.外键就取到了这个model关联的对象
                        book_model = Book.objects.get(name="python")
                        print(book_model.public.name)
                        print(book_model.public.city)
        # 方式二 反向查询：从被关联的表反向找关联表，格式：被关联表model.关联表_set.all().values() || _set.all().values_list()
                    OneToOne无法反向查询
                    pub_set = Public.objects.get(id=1)    
                    book_msg = pub_set.book_set.all().values("name","price")
                    print(book_msg)
                    #--  小写类名_set是一种默认形式，可以修改在外键参数添加related_name=""
                        cs = models.ForeignKey(Classes,on_delete=models.CASCADE,related_name="sss")
        # 正向查找和反向查找
        # ---找到学员对应班级，正向查找
        date = models.Students.objects.all().values("student_name","cs__class_name")
        # values是一个queryset字典，而values_list是元组，并且values在get和filter中不能使用
        for i in date:
            print(i["student_name"],i["cs__class_name"])

        # ---找到班级对应的学员，反向查找
        reverse_date = models.Classes.objects.get(id=2).students_set.all().values("student_name")
        print(reverse_date)
        return HttpResponse("成功")
         # 以上两种方式都是通过对象
         # 方式三：伟大的双下划线__ (可以在values中和filter中使用)

# 多表操作（多对多）
         #两张表之间的多对多需要第三张表做桥梁
         # 第一种方法是手动添加第三张表，两个外键分别关联两张表
         # 在其中一张表中添加字段 字段名 = models.ManyToManyField("另一张表名")
         
         # 之后Django会自动创建第三张表
         
         # 向第三张表中添加记录
         # 取到要关联的两个对象，使用add方法添加
             author_obj = Author.objects.get(name="alex")
             book_obj = Book.objects.get(id=2)
             book_obj.author.add(author_obj)   # .remove(),可以解除关联，也就是删除第三张表中book_obj对应的数据
             # 还可以直接传参数id号  book_obj.author.add(ID号（[1,2,3]或者 2）) 
         
         # 删除数据
            book_obj.author.remove(book_obj) #可以解除关联，也就是删除第三张表中book_obj对应的数据
            book_obj.author.clear() #清空该对象的关联
         
         # 重置关联
             book_obj.author.set([1,2,3]) # 相当于清空关联，重新设置
         
         # 查询数据
             # 查找alex出过的书
                ret = Book.objects.filter(author__name="alex").values("name","price")
             # 查找GO这本书的作者
                ret1 = Book.objects.filter(name = "GO").values("author__name")
                print(ret1)
                
                    # 查询一班的老师
                            obj4=models.Classes.objects.filter(class_name="一班").first()
                            obj5=models.Classes.objects.get(class_name="一班")
                            print(obj4.ct.all().values("teacher_name"))

                            # obj=models.Classes.objects.all().values("class_name","ct__teacher_name")
                            # for i in obj:
                            #     print(i)


        # 聚合和分组
                # 聚合
                # 首先导入模块 from django.db.models import Avg Sum Min Max Count
                # 求所有书的价格
                # ret = Book.objects.aggregate(Sum("price"))
                # print(ret)
                # 分组
                # 求每个出版社出的书的价格
                ret = Public.objects.values("name").annotate(Sum("book__price"))
                print(ret)
                # 求每个作者出的书的价格
                ret2=Author.objects.values("name").annotate(Sum("book__price"))
                print(ret2)
         #F查询和Q查询
            # filter中的筛选条件可以用逗号隔开写多条，但是这些条件之间是且的关系，怎么表示或和非呢？
            # 修改一条记录，SQL语句可以直接使用算术运算符，但ORM中不行，怎么办呢
                # F查询和Q查询
                # 给每本书的价格加10
                Book.objects.all().update(price=F("price")+10)
                # 查询除了python以外的所有书
                ret = Book.objects.filter(~Q(name="python"))
                for i in ret:
                    print(i.name)
                # 查询价格是50或者60的书
                ret = Book.objects.filter(Q(price=50)|Q(price=60))
                for i in ret:
                    print(i.name)
                 ###########注意在筛选条件中F、Q和键值对可以并存，但F、Q要在键值对前面
                """
               from django.db.models import Q
                query_obj=Q()
                query_obj.connector=‘or‘
                query_obj.children.append((‘qq__contains‘,query))
                query_obj.children.append((‘name__contains‘,query))
        """
         
         # QuerySet  ：查询集合的一些特点
         1.查询语句不会被立即执行，只有使用查询结果时才被执行
         2.查询的结果会放在缓存中，中间无论怎么修改，再次使用查询结果都是缓存中的，除非再次调用查询语句
         3.查询集合会全部放在内存中，当如果这个数据特别大，那么内存就会有极大的负担，所以可以吧查询集合做成一个生成器
             用的时候一条一条的取  ，给集合调用.iterator()方法