ORM：对象关系映射-python黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

齐天大圣

1104

文章

938909

访问

+关注

分类

暂无分类

日期归档

2024-11(1)

ORM：对象关系映射

发布于2019-08-07 11:10 阅读(1285) 评论(0) 点赞(4) 收藏(4)

一、简单操作

定义：面向对象和关系型数据库的一种映射，通过操作对象的方式操作数据
对应关系：
- 类对应数据表
- 对象对应数据行（记录）
- 属性对应字段
导入：from app01 import models
查：
- models.Publisher.objects.all()
  - 查询所有的数据，queryset：对象列表
- models.Publisher.objects.get(name='xxxx')
  - 对象，获取一个对象（有且唯一），获取不到或者获取到多个对象会报错
- models.Publisher.objects.filter(name='xxxx')
  - 获取满足条件的所有的对象，queryset：对象列表
增：
- models.Publisher.objects.create(name='xxx')
  - 新插入数据库的对象
- obj = models.Publisher(name='xxx')
  - 存在在内存中的对象
- obj.save()
  - 提交到数据库中，新增
删：
- obj = models.Publisher.objects.get(pk=1)
  - obj.delete()
- obj_list = models.Publisher.objects.filter(pk=1)
  - obj_list.delete()
改：
- obj = models.Publisher.objects.get(pk=1)
- obj.name = 'new name'
  - 在内存中修改对象的属性
- obj.save()
  - 提交数据，保存到数据库中

二、字段

常用字段
- AutoField：自增的整型字段，必填参数primary_key=True
  - 注意：一个model不能有两个AutoField字段
- IntegerField：整数类型，数值的范围是 -2147483648 ~ 2147483647
- CharField：字符类型，必须提供max_length参数，max_length表示字符的长度
- DateField：日期类型，日期格式为YYYY-MM-DD，相当于Python中的datetime.date的实例
  - 参数：
    - auto_now_add=True：新增数据的时候会自动保存当前的时间
    - auto_now=True：新增、修改数据的时候会自动保存当前的时间
- DatetimeField：日期时间类型，格式为YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime的实例
- BooleanField：布尔值类型
- TextField：文本类型
- DecimalField：十进制小数
  - 参数：
    - max_digits：小数总长度
    - decimal_places：小数位总长度

自定义字段

自定义一个char类型字段

class MyCharField(models.Field):
    """
    自定义的char类型的字段类
    """
    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length

使用自定义char类型字段

class Class(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=25)
    # 使用自定义的char类型的字段
    cname = MyCharField(max_length=25)

三、字段参数

null：数据库中字段是否可以为空
default：数据库中字段的默认值
primary_key：数据库中字段是否为主键
db_index：数据库中字段是否可以建立索引
unique：数据库中字段是否可以建立唯一索引
blank：Admin中是否允许用户输入为空
choices：Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
- choices=((0, '女'), (1, '男') ：可填写的内容和提示

四、 Model Meta参数

在表对于的类中写入一个类Meta

class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)

    class Meta:
        # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
        db_table = "table_name"
        # admin中显示的表名称
        verbose_name = '个人信息'
        # verbose_name加s
        verbose_name_plural = '所有用户信息'
        # 联合索引 
        index_together = [
            ("pub_date", "deadline"),      # 应为两个存在的字段
        ]
        # 联合唯一索引
        unique_together = (("driver", "restaurant"),)   # 应为两个存在的字段

五、 ORM操作——必知必会13条

all()：查询所有结果，返回QuerySet对象
get()：返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误，返回单个对象
filter()：返回所有符合条件的对象，返回QuerySet对象
exclude()：返回所有不符合条件的对象，返回QuerySet对象
values('字段')：拿到对象指定的字段和字段的值，返回的是一个字典序列，返回QuerySet对象
values_list('字段')：拿到对象指定的字段的值，返回的是一个元组序列，返回QuerySet对象
order_by()：对查询结果排序，默认升序，字段前加负号则为降序，返回QuerySet对象
- order_by('age','-pid')：先按age字段升序排列，再按pid字段降序排列
reverse()：对查询结果反向排序，只能对已经排序的QuerySet进行反转，返回QuerySet对象
distinct()：对查询结果进行去重，完全相同的内容才能去重，返回QuerySet对象
count()：计数，返回数据库中匹配查询的对象数量，返回数字
first()：返回第一条记录，即取第一个元素，没有返回None，返回单个对象
last()：返回最后一条记录，即取最后一个元素，没有返回None，返回单个对象
exist()：判断查询的数据是否存在，存在返回True，否则返回False，返回布尔值

总结：

# 返回的是queryset对象的
all()    
filter()
exclude()
values()  
values_list() 
order_by() 
reverse() 
distinct()
# 返回的是单个对象的
get() 
first()
last()
# 返回的是数字的
count()
# 返回的是布尔值的
exists()

六、单表查询的双下划线

条件判断，相当于SQL中的while
- __gt：大于
  - ret = models.Person.objects.filter(pk__gt=1)
    - 获取pk大于1的
- __lt：小于
  - ret = models.Person.objects.filter(pk__lt=3)
    - 获取pk小于3的
- __gte：大于等于
  - ret = models.Person.objects.filter(pk__gte=1)
    - 获取pk大于等于1的
- __lte：小于等于
  - ret = models.Person.objects.filter(pk__lte=3)
    - 获取pk小于等于3的
__range：范围查询，相当于SQL的between...and...
- ret = models.Person.objects.filter(pk__range=[1,3])
  - 获取pk范围是1到3的
__in：成员判断
- ret = models.Person.objects.filter(pk__in=[1,3])
  - 获取pk等于1、3的，相当于SQL的 in
- ret = models.Person.objects.exclude(pk__in=[1,3])
  - 获取pk不等于1和3的，相当于SQL的 not in
模糊查询：相当于SQL的 like 和正则匹配
- __contains：模糊查询
  - ret = models.Person.objects.filter(name__contains='A')
    - 获取name字段的值包含'A'的
- __icontains：在contains的基础上，对条件中的字母大小写不敏感
  - ret = models.Person.objects.filter(name__icontains='A')
    - 获取name字段的值包含'A'或'a'的，忽略大小写
判断以...开头/结尾
- __startswith：以...开头
  - ret = models.Person.objects.filter(name__startswith='A')
    - 获取name字段的值以'A'开头的
- __istartswith：在startswith的基础上，对条件中的字母大小写不敏感
  - ret = models.Person.objects.filter(name__istartswith='A')
    - 获取name字段的值以'A'或'a'开头的，忽略大小写
- __endswith：以...结尾
  - ret = models.Person.objects.filter(name__endswith='A')
    - 获取name字段的值以'A'结尾的
- __iendswith：在endswith的基础上，对条件中的字母大小写不敏感
  - ret = models.Person.objects.filter(name__iendswith='A')
    - 获取name字段的值以'A'或'a'结尾的，忽略大小写
__year：判断日期年份
- ret = models.Person.objects.filter(birth__year='2019')
  - 获取birth字段的值的年份是2019的
- __year只能筛选年份，如果要筛选年月日，使用contains：模糊查询
  - ret = models.Person.objects.filter(birth__contains='2018-06-24')
    - 获取birth字段的值是2018-06-24的
__isnull：查询与null的项
- __isnull = True：查询值是null的
  - ret = models.Person.objects.filter(phone__isnull=True)
    - 获取phone字段的值是null的
- __isnull = False：查询值不是null的

七、 ForeignKey操作

基于对象的查询

正向查询，语法：对象.关联字段.字段

book_obj = models.Book.objects.get(title='菊花怪大战MJJ')
book_obj.pub
book_obj.pub.name

反向查询，语法：对象.表名_set.all()，表名即类名小写
- 设置ForeignKey的参数：related_name，相当于替换了类名小写_set

pub_obj = models.Publisher.objects.get(pk=1)
# 没有指定related_name，使用类名小写_set
pub_obj.book_set.all()
# 指定related_name='books'
pub_obj.books.all()

基于字段的查询

正向查询，语法：关联字段__字段

# 查询老男孩出版的书
ret = models.Book.objects.filter(pub__name='老男孩出版社')

反向查询，语法：表名__字段
- 设置ForeignKey的参数：related_query_name，相当于替换了表名

# 查询出版菊花怪大战MJJ的出版社
# 没有指定related_name，使用类名的小写
ret= models.Publisher.objects.filter(book__title='菊花怪大战MJJ')
# related_name='books'
ret= models.Publisher.objects.filter(books__title='菊花怪大战MJJ')
# related_query_name='xxx'
ret= models.Publisher.objects.filter(xxx__title='菊花怪大战MJJ')

八、多对多的操作

基于对象的查询

正向查询，语法：对象.多对多字段.all()

mjj = models.Author.objects.get(pk=1)
mjj.books        # 关系管理对象
mjj.books.all()

反向查询，语法：对象.类名小写_set.all()
- 设置related_name，相当于替换了类名小写_set

book_obj = models.Book.objects.filter(title='桃花侠大战菊花怪').first()
# 不指定related_name
book_obj.author_set      # 关系管理对象
book_obj.author_set.all()
# 指定related_name='authors'
book_obj.authors         # 关系管理对象
book_obj.authors.all()

基于字段的查询

正向查询，语法：多对多字段__字段

ret = models.Author.objects.filter(books__title='菊花怪大战MJJ')

反向查询，语法：类名小写__字段
- 设置related_query_name，相当于替换了类名小写

# 不指定related_name
ret = models.Book.objects.filter(author__name='MJJ')
# 指定related_name='authors'
ret = models.Book.objects.filter(authors__name='MJJ')
# 指定related_query_name='xxx'
ret = models.Book.objects.filter(xxx__name='MJJ')

关系管理对象的方法

all()：所关联的所有对象

mjj = models.Author.objects.get(pk=1)
mjj.books.all()

set()：设置多对多关系

# set()  [id,id]   [对象，对象]
mjj.books.set([1,2])
mjj.books.set(models.Book.objects.filter(pk__in=[1,2,3]))

add()：添加多对多关系

# add  (id,id)   (对象，对象)
mjj.books.add(4,5)
mjj.books.add(*models.Book.objects.filter(pk__in=[4,5]))

remove()：删除多对多关系

# remove (id,id)   (对象，对象)
mjj.books.remove(4,5)
mjj.books.remove(*models.Book.objects.filter(pk__in=[4,5]))

clear()：清除所有多对多关系

mjj.books.clear()

create()：创建多对多关系

obj = mjj.books.create(title='跟MJJ学前端',pub_id=1)

book__obj = models.Book.objects.get(pk=1)
obj = book__obj.authors.create(name='taibai')

九、聚合和分组

聚合

内置函数：Max（最大值）、Min（最小值）、Avg（平均值）、Sum（求和）、Count（计数）

from app01 import models
from django.db.models import Max, Min, Avg, Sum, Count
# 为聚合值指定名称，注意关键字传参要在位置传参后面
ret = models.Book.objects.filter(pk__gt=3).aggregate(Max('price'),avg=Avg('price'))
print(ret)

分组

一般和聚合一起使用

# 统计每一本书的作者个数，annotate：注释
ret = models.Book.objects.annotate(count=Count('author')) 

# 统计出每个出版社的最便宜的书的价格
# 方式一
ret = models.Publisher.objects.annotate(Min('book__price')).values()
# 方式二：objects后面接values，就是按字段分组，相当于分组条件
ret = models.Book.objects.values('pub_id').annotate(min=Min('price'))

十、 F查询和Q查询

F查询

from django.db.models import F
# 比较两个字段的值
ret=models.Book.objects.filter(sale__gt=F('kucun'))

# 只更新sale字段
models.Book.objects.all().update(sale=100)

# 取某个字段的值进行操作
models.Book.objects.all().update(sale=F('sale')*2+10)

Q查询

条件符号：&（与）、|（或）、~（非）

from django.db.models import Q
ret = models.Book.objects.filter(~Q(Q(pk__gt=3) | Q(pk__lt=2)) & Q(price__gt=50))
print(ret)

十一、事务

使用try进行回滚时，必须把try写在with的外面，否则无法回滚

from django.db import transaction

try:
    with transaction.atomic():
        # 进行一系列的ORM操作
        models.Publisher.objects.create(name='xxxxx')
        models.Publisher.objects.create(name='xxx22')
except Exception as e :
    print(e)

十二、其他操作设置

Django ORM执行原生SQL

# 执行原生SQL
# 更高灵活度的方式执行原生SQL语句
from django.db import connection, connections
cursor = connection.cursor()  
cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone()

Django终端打印SQL语句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

在Python中脚本中调用Django环境

在要执行的py文件中写入

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
# orm_practice.settings表示当前项目的settings.py，orm_practice是当前项目名称
import django
django.setup()

from app01 import models
# 再继续写要执行的语句，例如
books = models.Book.objects.all()
print(books)