ORM：对象关系映射

定义：面向对象和关系型数据库的一种映射，通过操作对象的方式操作数据
对应关系：
- 类对应数据表
- 对象对应数据行（记录）
- 属性对应字段
导入：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, '男') ：可填写的内容和提示

在表对于的类中写入一个类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"),)   # 应为两个存在的字段

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的

基于对象的查询

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

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查询

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)

文章来源: ORM：对象关系映射

标签

对象关系映射

sql修改字段长度

数据库对象

内存映射

orm