数据库操作

from django.views import View
from django.http import HttpResponse
from .models import Student


class Student1(View):
    def get(self, request):
        """添加一条数据"""
        # ORM对于数据的所有操作都是有子类objects来提供的。objects，可以被修改，开发中一般叫objects为"模型管理器"
        student = Student(
            name="刘德华",
            age=17,
            xingbie=True,
            classmate=301,
            description="一杯忘情水",
        )
        # 自动执行添加数据
        student.save()
        # 添加后的模型会多出一个主键数据，可以通过id或者pk来读取
        print(student.id)  # print(student.pk)
        return HttpResponse('ok')

# 返回值就是添加后的模型对象，会有ID主键的
student = Student.objects.create(
    name="赵本山",
    age=50,
    sex=True,
    classmate=301,
    description="一段小品"
)
print(student)# <User 赵本山>
print(student.pk) 

return HttpResponse('ok')

stu1 = Student(name="小黄1号", age=17, xingbie=True, classmate=301, description="hello")
stu2 = Student(name="小黄2号", age=17, xingbie=False, classmate=301, description="hello")
stu3 = Student(name="小黄3号", age=17, xingbie=True, classmate=301, description="hello")
stu_list = [stu1,stu2,stu3]
ret = Student.objects.bulk_create(stu_list)
print(ret)

return HttpResponse('ok')

查询单一结果，如果不存在或者返回多个结果会抛出异常。

查询不到, 则返回模型类.DoesNotExist异常。

查询多个, 则返回模型类.MultipleObjectsReturned异常。

    def get(self,request):
        """基本查询数据"""
        """get 获取一条数据"""
        try:
            student = Student.objects.get(name="小黄")
            print(student, type(student))
            print(student.name)
            print(student.description)
        except Student.DoesNotExist:
            print("没有查询结果！")
        except Student.MultipleObjectsReturned:
            print("当前数据不是唯一的结果！")
        return HttpResponse("OK")

def get(self, request):
        student = Student.objects.first()
        # SQL: select * from tb_student limit 1;
        print(student) # <User 赵华>
        if student:  # 判断如果student不是None
            print(student.description)

        return HttpResponse('ok')

def get(self, request):
    student_list = Student.objects.all()
    print(student_list)       # 获取结果列表 <QuerySet [<Student: <User 赵华>>,
    print(len(student_list))  # 获取结果列表的长度

    # 把结果列表中的所有模型对象转化成字典结构
    student_list = Student.objects.all().values()
    print(student_list) # <QuerySet [{'id': 1,

    # 把结果列表中的所有模型对象转换成元组结构
    student_list = Student.objects.all().values_list()
    print(student_list) # <QuerySet [(1,

    """使用filter查询过滤数据，并返回所有符合条件的结果
    filter(字段名=条件值)
    filter(字段名=条件值, 字段名=条件值)  # 相当于and
    """
    student_list = Student.objects.filter(classmate=302).all()
    print(student_list)
    return HttpResponse('ok')

    def get(self, request):
        # 先把要更新的数据查询出来，得到一个模型类对象
        student = Student.objects.filter(name="小白").first()
        # SQL: select * from tb_student where name='小白' limit1;
        if student:
            student.name = "小黑"
            student.age = 18
            student.save()  # 把当前模型的中字段值同步到数据库
        return HttpResponse('ok')

    def get(self, request):
        """update 更新多条数据"""
        # 基于update这种操作在数据库操作中，一般称之为"乐观锁" update操作的执行效率比save要高！
        # update如果条件设置宽松，可以修改多条数据
        Student.objects.filter(name="刘德华").update(name="刘福荣")
        # SQL: update tb_student set name="刘福荣" where name="刘德华";
        return HttpResponse('ok')

        student = Student.objects.filter(name="小白").first()
        if student:
            # 调用模型对象的delete方法进行删除
            student.delete()

Student.objects.filter(name="小黄").delete()

    def get(self, request):
        student_list = Student.objects.filter(name__exact="吴杰").all()
        # student_list = Student.objects.filter(name="吴杰").all()  # 常用！！
        print(student_list)
        return HttpResponse('ok')

        student1 = Student.objects.filter(name__contains='华')
        print(student1) # <QuerySet [<Student: <User 赵华>>, <Student: <User 龙华>>,

        student2 = Student.objects.filter(name__endswith='华')
        print(student2) # QuerySet [<Student: <User 赵华>>, <Student: <User 龙华>>,

        student3 = Student.objects.filter(name__startswith="江")
        print(student3) # <QuerySet [<Student: <User 江宸轩>>,

        student = Student.objects.filter(description__isnull=True)
        print(student)

        student = Student.objects.filter(classmate__in=[301, 302, 303]).all().values("id", "name", "classmate")
        print(student) # <QuerySet [{'id': 2, 'name': '程星云', 'classmate': '301'},

        # SQL: SELECT ... WHERE id BETWEEN 51 and 67;
        student_list = Student.objects.filter(id__range=(51, 67)).values("id", "name")
        print(student_list) # <QuerySet [{'id': 51, 'name': '董晴'},

    def get(self, request):
        # # 年龄大于20的
        # # age__gt=20  ---->>>  where age > 20
        student_list = Student.objects.filter(age__gt=22).values("name", "age")  # 后面任何方法，默认补充all()
        print(student_list) # <QuerySet [{'name': '欧阳博', 'age': 23},

        # # 年龄小于19的
        # # age__lt=19  ---->>>  where age < 19
        student_list = Student.objects.filter(age__lt=19).all().values("name","age")
        print(student_list) # <QuerySet [{'name': '张小玉', 'age': 18},
        
        # 年龄不等于19的
        # 使用exclude把符合条件的排除掉。不等于的运算符，使用exclude()过滤器。
        student_list = Student.objects.exclude(age=19).all().values("name","age")
        print(student_list)
        return HttpResponse('ok')

from django.views import View
from django.http import HttpResponse
from .models import Student
from datetime import datetime, timedelta

class Student1(View):
    def get(self, request):
        student_list = Student.objects.filter(
            created_time__year=2022,
            created_time__month=7,
            created_time__day=20
        ).values("name", "created_time")
        print(student_list)
        # 精确时间查询
        from datetime import datetime
        add_time = "2021-08-18 16:19:38"
        timestamp = datetime.strptime(add_time, "%Y-%m-%d %H:%M:%S")
        student_list = Student.objects.filter(
            created_time=timestamp,
        ).all()
        print(student_list)
        # 查询时间范围在 "2021-08-18 16:19:38" ~ "2021-08-18 16:21:56" 的数据
        start_time = "2021-08-18 16:19:38"
        end_time = "2021-08-18 16:21:56"
        end_time_timestamp = datetime.strptime(end_time, "%Y-%m-%d %H:%M:%S")
        end_time_next = end_time_timestamp + timedelta(seconds=1)
        student_list = Student.objects.filter(
            created_time__gte=start_time,
            created_time__lt=end_time_next,
        ).all()
        print(student_list)
        return HttpResponse('ok')

"""F对象，字段间的值比较查询"""
from django.db.models import F
# 查询出入学以后，数据没有被修改过的学生信息
student = Student.objects.filter(created_time=F("updated_time")).values("name","created_time","updated_time")
print(student)

        """Q对象，复杂逻辑查询，针对多条件进行与或非处理"""
        from django.db.models import Q
        # 多个与 and  Q(条件) & Q(条件)
        # 查询出301班的男生
        # student = Student.objects.filter(Q(classmate=301) & Q(xingbie=1)).values("name","xingbie","classmate")
        # 上面也可以简写成
        # student = Student.objects.filter(classmate=301, xingbie=1).values("name", "xingbie", "classmate")
        """单纯的多个条件并立的情况下，没必要使用到Q对象进行处理，直接编写多个条件，使用逗号串联即可"""

        # NOT
        student = Student.objects.filter(~Q(classmate=301)).values("name", "age", "sex")

        # 多个或，or Q(条件) | Q(条件)
        # 查询出301班的男生 或者 302班的男生
        # student = Student.objects.filter(Q(classmate=301, xingbie=1) | Q(classmate=302, xingbie=1)).values("name",
        # 上面也可以简写成
        # student = Student.objects.filter(classmate__in=[301, 302], xingbie=1).values("name", "xingbie", "classmate")
        # print(student)

order_by("第一排序字段","第二排序字段",....)

当前第一字段的值一样时，参考第二字段进行排序，第二字段的值一样时，参考第三字段进行排序..

# order_by("id")   # 表示按id字段的值进行升序排序，id数值从小到大
# order_by("-id")  # 表示按id字段的值进行降序排序，id数值从大到小
# 调用了order_by以后，如果没有后续声明返回结果的all方法时，默认使用all()进行结果查询
student = Student.objects.order_by("-id")
print(student)

        student_list = Student.objects.filter(classmate="301")
        student_list = student_list.order_by("-age")
        student_list = student_list.filter(sex=1)
        ret = student_list.exists()
        print(ret) # True

   student_list = Student.objects.filter(classmate="301")
        student_list = student_list.order_by("-age")
        student_list = student_list.filter(sex=1)
        ret1 = student_list.values()  # 默认把所有字段全部转换并返回
        ret2 = student_list.values_list()  # 默认把所有字段全部转换并返回
        ret3 = student_list.values_list("id", "name", "age")  # 可以通过参数设置要转换的字段并返回
        print(ret1, type(ret1))  # <QuerySet [{'id': 102,..}]><class 'django.db.models.query.QuerySet'>
        print(ret2, type(ret2))  # <QuerySet [(102,..)]> <class 'django.db.models.query.QuerySet'>
        print(ret3, type(ret3))  # <QuerySet [(102, '赵本山', 50),..]> <class 'django.db.models.query.QuerySet'>

QuerySet查询集在创建时是不会访问数据库执行SQL语句，

直到模型对象被调用输出或者调用模型对象的属性时，才会真正的访问数据库执行SQL语句，

调用模型的情况包括循环迭代、序列化、与if合用，print的时候。

    def get(self, request):
        '''惰性执行，可以让重复的查询操作，只执行一次'''
        # 创建了一个查询集对象student_list，此时没有执行SQL语句的
        student_list = Student.objects.all()
        # 继续执行遍历迭代、或打印操作之后操作后，才进行了数据库的查询
        for student in student_list:
            pass
        return HttpResponse('ok')

        """两个查询集，无法重用缓存，每次查询都会与数据库进行一次交互，增加了数据库的负载"""
        [student.id for student in Student.objects.all()]  # 因为没有缓存查询集到变量中，所以此处第一次执行了SQL语句
        [student.id for student in Student.objects.all()]  # 因为没有缓存查询集到变量中，所以此处第一次执行了SQL语句

        '''经过存储后，可以重用查询集，第二次使用缓存中的数据'''
        student_list = Student.objects.all()
        [student.id for student in student_list]  # 因为上面保存到查询到变量中，所以此处执行了SQL语句
        [student.id for student in student_list]  # 此处调用了之前的缓存数据