Django之ORM框架的使用

一、ORM介绍

ORM:Object-Relation Mapping(对象-关系映射)

优势:

  • 只需要面向对象编程,不需要面向数据库编写代码;
  • 实现了数据模型与数据库的解耦,屏蔽了不同数据库操作上的差异。

劣势:

  • 相比较直接使用SQL语句操作数据库,有性能损失。

ORM与数据库的关系:通常,一个模型(model)映射到一个数据库表。

Django之ORM框架的使用

 二、ORM的使用

1)字段类型

属性名 = models.字段类型,定义属性时需要指定字段类型, 通过字段类型的参数指定选项属性名。

AutoField:自动增长的IntegerField, 不指定时Django会自动创建属性名为id的自动增长属性;

BooleanField:布尔字段,值为True或False;

NullBooleanField:支持Null、True、False三种值;

CharField(max_length=20):字符串;  参数max_length表示最大字符个数

TextFiled:大文本字段;

IntegerField:整数;

DecimalField(max_digits=None, decimal_places=None):可以指定精度的十进制浮点数;
  参数max_digits表示总位数
  参数decimal_places表示小数位数


FloatField():浮点数 

DateField[auto_now=False, auto_now_add=False]):日期

  参数auto_now表示每次保存对象时,自动设置该字段为当前时间,用于"最后一次修改"的时间戳,它总是使用当前日期,默认为false
  参数auto_now_add表示当对象第一次被创建时自动设置当前时间,用于创建的时间戳,它总是使用当前日期,默认为false
  参数auto_now_add和auto_now是相互排斥的,组合将会发生错误

TimeField:参数和DateField一样;

DateTimeField:日期时间,参数同DateField;

FileField:上传文件字段,以二进制的形式;

ImageField:继承于FileField,对上传的内容进行校验,确保是有效的图片。

字段类型

字段选项

null:如果为True,表示允许为空,默认值是False;

blank:如果为True,则该字段允许为空白,默认值是False;

db_column:字段的名称,如果未指定,则使用属性的名称(只限于数据库表中的名字,操作数据库还是类属性的名字);

db_index:若值为True, 则在表中会为此字段创建索引,默认值是False(为了优化查询速度 );

default:默认值,这可以是值或可调用对象。如果可调用,则每次创建新对象时都会调用它;

primary_key:若为True,则该字段会成为模型的主键字段,默认值是False,一般作为AutoField的选项使用;

unique:如果为True, 这个字段在表中必须有唯一值,这个值不能重复,默认值是False。

字段选项

注意:Django会自动为表创建主键字段,如果使用选项设置某属性为主键字段后,Django不会再创建自动增长的主键字段

3)关系字段类型

关系型数据库的关系包括三种类型:

  • OneToOneField:一对一
  • ForeignKey:一对多
  • ManyToManyField:多对多

迁移表

python manage.py makemigrations stu
python manage.py migrate

三、操作表

# 增
Student.objects.create(name="lucy",pwd="123456")

stu = Student(name="zhangsai",pwd="112121")
stu.save()

# 查
Student.objects.get(sno=1)
Student.objects.all()
Student.objects.filter(name="lucy")

# 删
Student.objects.filter(name="lucy").delete()

# 改
Student.objects.filter(name="jack").update(pwd=‘123456‘)

stu = Student.objects.get(sno=1)
stu.pwd = "111222"
stu.save()
# 获取个数
#
# Student.objects.filter(name=‘seven‘).count()

# 大于,小于
#
# Student.objects.filter(sno__gt=1)              # 获取sno大于1的值
# Student.objects.filter(sno__gte=1)             # 获取sno大于等于1的值
# Student.objects.filter(sno__lt=10)             # 获取sno小于10的值
# Student.objects.filter(sno__lte=10)            # 获取sno小于10的值
# Student.objects.filter(sno__lt=10, sno__gt=1)   # 获取sno大于1 且 小于10的值

# in
#
# Student.objects.filter(sno__in=[11, 22, 33])   # 获取sno等于11、22、33的数据
# Student.objects.exclude(sno__in=[11, 22, 33])  # not in

# isnull
#
# Student.objects.filter(pub_date__isnull=True)

# contains
#
# Student.objects.filter(name__contains="ven")
# Student.objects.filter(name__icontains="ven") # icontains大小写不敏感
# Student.objects.exclude(name__icontains="ven")

# range
#
# Student.objects.filter(sno__range=[1, 2])   # 范围bettwen and

# 其他类似
#
# startswith,istartswith, endswith, iendswith,

# order by
#
# Student.objects.filter(name=‘seven‘).order_by(‘sno‘)    # asc
# Student.objects.filter(name=‘seven‘).order_by(‘-sno‘)   # desc

# group by
#
# from django.db.models import Count, Min, Max, Sum
# Student.objects.values("sname").annotate(dcount=Count("sname"))

Demo:

# 一对一

class Student(models.Model):
    sno = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, unique=True)
    pwd = models.CharField(max_length=32)

    def __str__(self):
        return u‘Student:%s‘ % self.name


class Scard(models.Model):
    st = models.OneToOneField(Student, primary_key=True, on_delete=models.CASCADE)
    major = models.CharField(max_length=32)

    def __str__(self):
        return u‘Scard:%s‘ % self.major

#======== CRUD ========
        
# 插入数据
stu = Student(name="zhangsai",pwd="112121")
stu.save()

sc = Scard(st=stu,major="计算机")
sc.save()# 正向查询数据
Student.objects.first().scard

# 反向查询数据
Scard.objects.first().st
# 一对多

class Clazz(models.Model):
    cno = models.AutoField(primary_key=True)
    cname = models.CharField(max_length=32)


class Student(models.Model):
    sno = models.AutoField(primary_key=True)
    sname = models.CharField(max_length=32, unique=True)
    cno = models.ForeignKey(Clazz, on_delete=models.CASCADE)

    def __str__(self):
        return u‘Student:%s‘ % self.sname

#======== CRUD ========

# 正向查询
Clazz.objects.last().student_set.all()

# 反向查询数据
Student.objects.first().cno

# 自定义方法
def insertData(clsname,*sname):
    try:
        cls = Clazz.objects.get(cname=clsname)
    except Clazz.DoesNotExist:
        cls = Clazz.objects.create(cname=clsname)
    for sn in sname:
        try:
            stu = Student.objects.get(sname=sn)
        except Student.DoesNotExist:
            stu = Student.objects.create(sname=sn,cno=cls)
            
insertData("B03Mysql","张无忌")
insertData("B04Oracle","金毛狮王")
# 多对多

class Course(models.Model):
    course_no = models.AutoField(primary_key=True)
    course_name = models.CharField(max_length=30)

    def __str__(self):
        return u‘Course:%s‘ % self.course_name


class Teacher(models.Model):
    tno = models.AutoField(primary_key=True)
    tname = models.CharField(max_length=30)
    cour = models.ManyToManyField(Course)

    def __str__(self):
        return u‘Teacher:%s‘ % self.tname

#======== CRUD ========
# 插入数据       
cour1 = Course.objects.create(course_name="Python")
cour2 = Course.objects.create(course_name="Java")
cour3 = Course.objects.create(course_name="Html5")
t1 = Teacher.objects.create(tname="张三")
t2 = Teacher.objects.create(tname="李四")

t1.cour.add(cour1,cour2,cour3)

# 正向查询
Course.objects.first().teacher_set.all()

# 反向查询数据
Teacher.objects.first().cour.all()

# 自定义方法
def insertData(t_name,*coursenames):
    try:
        t = Teacher.objects.get(tname=t_name)
    except Teacher.DoesNotExist:
        t = Teacher.objects.create(tname=t_name)
    course_list=[]
    for cour in coursenames:
        try:
            cour = Course.objects.get(course_name=cour)
        except Course.DoesNotExist:
            cour = Course.objects.create(course_name=cour)
            course_list.append(cour)
        t.cour.add(*course_list)
        
insertData("王五","Oracle","MySQL")