ORM模型

wxyyyang

于 2022-08-21 20:59:00 发布

阅读量178

点赞数

分类专栏： django 文章标签： django python 后端

本文链接：https://blog.csdn.net/wxyyyang/article/details/126455314

版权

django 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了如何使用 Django 的 ORM 进行数据库操作，包括添加、查询、修改和删除记录。同时，展示了数据表间的一对多、一对一和多对多关系映射，并给出了具体的实例。此外，还涵盖了多表查询、聚合查询以及更新和删除操作。

摘要由CSDN通过智能技术生成

ORM模型

#数据库操作
# 数据库为Book数据库
from .models import Book
#1.添加
Book.objects.create(**kwargs)

#2.查询
Book.objects.filter(**kwargs)  #此方法相当于后面写了个where
Book.objects.exclude(**kwargs)  #filter的取反
Book.objects.all().order_by('Filed') #根据字段排序，前加负号则为倒叙

	#2.1双下划线模糊查询
    Book.objects.filter()  
    __lt #小于
    __gt #大于
    __lte #小于等于
    __gte #大于等于
    __icontains #带有指定的字符
    __startswith #以指定字符开头
    __in=[]  #在指定区间
Book.objects.filter(name__exclude='wxy').values('Filed','Filed')  #返回字典
Book.objects.filter(name__exclude='wxy').values_list('Filed','Filed')  #返回元组

#3.修改
Book.objects.filter(Filed='').update(Filde='')

#4.删除
Book.objects.filter(Filed='').delect()

数据表的关系映射

from django.db import models

# Create your models here.

class Department(models.Model):
    d_id = models.AutoField(primary_key=True)
    d_name = models.CharField(max_length=20)

    class Meta:
        db_table = 'Department'

class Student(models.Model):
    Stu_id = models.AutoField(primary_key = True)
    Stu_name = models.CharField(max_length=20,null=False)
    # 一对多关系 ForeignKey() to -> 外键的数据表 on_delete -> 当外键字段数据删除后此表数据的操作 若设置为空需设置此字段允许为空
    Dpt = models.ForeignKey(to='Department',on_delete=models.SET_NULL,null=True)

    class Meta:
        db_table = 'Student'

class Stu_Info(models.Model):
    Info_id = models.AutoField(primary_key = True)
    Info_age = models.IntegerField()
    Info_note = models.TextField()
    Info_create_time = models.DateTimeField(auto_now_add=True)

    # 一对一关系使用 OneToOneField
    Into = models.OneToOneField(to='Student',on_delete=models.CASCADE)

    class Meta:
        db_table = 'Stu_Info'

class Course(models.Model):
    c_id = models.AutoField(primary_key = True)
    c_name = models.CharField(max_length=20,null=False,unique=True)

    #多对多关系的关系表
    Stu_Course = models.ManyToManyField(to='Student')

    class Meta:
        db_table = 'Course'

    def __str__(self):
        return f'课程编号:{self.c_id} 课程名:{self.c_name}'

ORM模型添加操作

ORM关系要诀：正向访问（有外键的表）用字段反向访问用表名_set

#-----------部门表添加---------------------
    # Department.objects.create(d_name='学习部')
    # Department.objects.create(d_name='体育部')
    # Department.objects.create(d_name='生活部')
    # Department.objects.create(d_name='卫生部')

    #-----------学生表的添加------------------------------
    # 1.使用外键字段添加
    # Student.objects.create(Stu_name='hyx',Dpt_id=2)
    # 2.使用关系字段添加
    # dpt = Department.objects.filter(d_name='学习部')[0]
    # Student.objects.create(Stu_name='wxy',Dpt=dpt)
    # print(Student.objects.all().values())

    #---------学生详情表添加-------------------------
    # wxy = Student.objects.get(Stu_name='wxy')
    # hyx = Student.objects.get(Stu_name='hyx')
    # Stu_Info.objects.create(Info_age=18,Info_note='wxy帅的一批',Into=wxy)
    # Stu_Info.objects.create(Info_age=17,Info_note='wxy帅的一般',Into=hyx)

    #-----------课程表添加----------------------------
    # Course.objects.create(c_name='python')
    # Course.objects.create(c_name='java')
    # Course.objects.create(c_name='C#')
    # Course.objects.create(c_name='go')

    #----------中间表添加-----------------
    Course_obj = Course.objects.get(c_id=1)
    Student_obj = Student.objects.get(Stu_name='wxy')

    # 正向访问 模型对象.中间表字段.add() 方法
    # Course_obj.Stu_Course.add(Student_obj)

    # 反向访问 模型对象.表名_set.add()
    Student_obj.course_set.add(*[Course_obj])  #在添加数据时需要使用拆包

ORM模型多表查询、修改、删除

def add(request):
    #-----------部门表添加---------------------
    # Department.objects.create(d_name='学习部')
    # Department.objects.create(d_name='体育部')
    # Department.objects.create(d_name='生活部')
    # Department.objects.create(d_name='卫生部')

    #-----------学生表的添加------------------------------
    # 1.使用外键字段添加
    # Student.objects.create(Stu_name='hyx',Dpt_id=2)
    # 2.使用关系字段添加
    # dpt = Department.objects.filter(d_name='卫生部')[0]
    # Student.objects.create(Stu_name='老六',Dpt=dpt)
    # print(Student.objects.all().values())

    #---------学生详情表添加-------------------------
    # wxy = Student.objects.get(Stu_name='老六')
    # hyx = Student.objects.get(Stu_name='hyx')
    # Stu_Info.objects.create(Info_age=18,Info_note='老六帅的一批',Into=wxy)
    # Stu_Info.objects.create(Info_age=17,Info_note='wxy帅的一般',Into=hyx)

    #-----------课程表添加----------------------------
    # Course.objects.create(c_name='python')
    # Course.objects.create(c_name='java')
    # Course.objects.create(c_name='C#')
    # Course.objects.create(c_name='go')

    #----------中间表添加-----------------
    Course_obj = Course.objects.get(c_id=3)
    Student_obj = Student.objects.get(Stu_name='老六')

    # 正向访问
    # Course_obj.Stu_Course.add(Student_obj)

    # 反向访问
    Student_obj.course_set.add(*[Course_obj])

    return HttpResponse('添加成功！')

def Selector(request):

    # 学院表 与 学生表 查询：
    # 学生查学院 查一个 正向 学院查学生 查多个 反向
    # 正向访问 通过学生表查学院表，因为外键字段在学生表，所以学生表查学院表为正向访问
    # sobj = Student.objects.get(Stu_name='hyx')
    # print(sobj)

    #反向访问 学院表查学生 模型对象.表名_set
    # dobj = Department.objects.get(d_name='学习部')
    # print(dobj.student_set.get())

    # 学生表 与 学生详情表
    # 学生查学生详情表 查一个 反向 学生详情表查学生 查一个 正向
    # 正向访问 学生详情表查学生表
    # info_obj = Stu_Info.objects.get(Info_note__icontains='帅的一批')
    # print(info_obj.Into.Stu_name)

    #反向访问 学生表查学生详情表  ps!!!  当表关系为一对一关系时 反向访问只需要:模型对象.表名  不需要在后面加_set
    # sobj = Student.objects.get(Stu_name='hyx')
    # print(sobj.stu_info.Info_note)

    # 学生表 与 课程表
    # 反向访问
    # sobj = Student.objects.get(Stu_name='hyx')
    # print(sobj.course_set.all())

    # 正向访问
    # cobj = Course.objects.get(c_name='python')
    # print(cobj.Stu_Course.all())

    return HttpResponse('ok')

# 基于双下划线的多表查询
def ManyTables(requset):

    # 学python课程的学生归属于哪些学院
    # dobj = Course.objects.filter(c_name='python').values('Stu_Course__Dpt__d_name')
    #  学习部的学生都学了哪些课程
    # dobj = Department.objects.filter(d_name='学习部').values('student__course__c_name')
    # xx学生学了什么课程
    dobj = Student.objects.filter(Stu_name='老六').values('course__c_name')

    print(dobj)
    return HttpResponse('ok')

def update(requst):

    six = Student.objects.get(Stu_name='老六')
    six.course_set.set([1,4])
    return HttpResponse('update ok')

def delete(request):
    six = Student.objects.get(Stu_name='老六')
    six.course_set.remove(1)
    return HttpResponse(1)

ORM聚合查询

# models.py
from django.db import models

# Create your models here.

class Min(models.Model):
    id = models.AutoField(primary_key = True)
    name = models.CharField(max_length=20)
    age = models.IntegerField()
    minmoney = models.DecimalField(max_digits=8,decimal_places=2)
    city = models.CharField(max_length=10)

    class Meta:
        db_table = 'min'

    def __str__(self):
        return f'姓名:{self.name} 年龄:{self.age}  零花钱:{self.minmoney} 城市:{self.city}'

# views.py
from django.http import HttpResponse
from django.shortcuts import render
from . models import Min
from django.db.models import Avg,Max,Count,F,Q

# Create your views here.


def add(request):
    # Min.objects.create(name='wxy',age=18,minmoney=0.99,city='长沙')
    # Min.objects.create(name='hyx',age=28,minmoney=100,city='岳阳')
    # Min.objects.create(name='lc',age=38,minmoney=1000,city='长沙')
    # Min.objects.create(name='lzj',age=18,minmoney=99,city='娄底')

    return HttpResponse('1')

def juhe(request):
    # 使用聚合函数需要使用aggregate()方法  传入方法和字段 前面的复制为该聚合方法的别名
    res = Min.objects.all().aggregate(avgs = Avg('minmoney'),max= Max('minmoney'))
    # 如果要进行分组查询则需要使用annotate() 方法
    count = Min.objects.all().annotate(Count('id'))
    print(res)
    print(count)

    # res = Min.objects.values('city').aggregate(Max('minmoney'))  aggregate不会进行分组 若要分组则执行annotate方法加聚合函数
    res = Min.objects.values('city').annotate(Count('id')) # values方法相当于group by
    print(res)
    return HttpResponse('ok')

def fandq(request):
    # res1 = Min.objects.all()
    # print(res1)
    # # F函数会查询数据库中指定字段的值
    # Min.objects.update(minmoney=F('minmoney')+10)
    # res2 = Min.objects.all()
    # print(res1)
    # print(res2)

    # Q函数用于逻辑查询
    # 查询年龄大于等于28并且属于长沙的所有信息
    res1 = Min.objects.filter(Q(age__gte=28)&Q(city__contains='长沙'))
    # 查询不是长沙的或者零花钱为1000的所有信息
    res2 = Min.objects.filter(~Q(city='长沙') | Q(minmoney=1000))
    return HttpResponse('ok')