ORM：对象关系映射

一、简单操作

  1. 定义：面向对象和关系型数据库的一种映射，通过操作对象的方式操作数据

  2. 对应关系：

    • 类对应数据表
    • 对象对应数据行（记录）
    • 属性对应字段

  3. 导入：from app01 import models

  4. 查：

    • models.Publisher.objects.all()
      • 查询所有的数据，queryset：对象列表
    • models.Publisher.objects.get(name='xxxx')
      • 对象，获取一个对象（有且唯一），获取不到或者获取到多个对象会报错
    • models.Publisher.objects.filter(name='xxxx')
      • 获取满足条件的所有的对象，queryset：对象列表

  5. 增：

    • models.Publisher.objects.create(name='xxx')
      • 新插入数据库的对象
    • obj = models.Publisher(name='xxx')
      • 存在在内存中的对象
    • obj.save()
      • 提交到数据库中，新增

  6. 删：

    • obj = models.Publisher.objects.get(pk=1)
      • obj.delete()
    • obj_list = models.Publisher.objects.filter(pk=1)
      • obj_list.delete()

  7. 改：

    • obj = models.Publisher.objects.get(pk=1)
    • obj.name = 'new name'
      • 在内存中修改对象的属性
    • obj.save()
      • 提交数据，保存到数据库中

二、 字段

  1. 常用字段

    • 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：小数位总长度

  2. 自定义字段

    • 自定义一个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)

三、 字段参数

  1. null：数据库中字段是否可以为空
  2. default：数据库中字段的默认值
  3. primary_key：数据库中字段是否为主键
  4. db_index：数据库中字段是否可以建立索引
  5. unique：数据库中字段是否可以建立唯一索引
  6. blank：Admin中是否允许用户输入为空
  7. 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条

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

  • 总结：

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

六、 单表查询的双下划线

  1. 条件判断，相当于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的
  2. __range：范围查询，相当于SQL的between...and...
    • ret = models.Person.objects.filter(pk__range=[1,3])
      • 获取pk范围是1到3的
  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
  4. 模糊查询：相当于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'的，忽略大小写
  5. 判断以...开头/结尾
    • __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'结尾的，忽略大小写
  6. __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的
  7. __isnull：查询与null的项
    • __isnull = True：查询值是null的
      • ret = models.Person.objects.filter(phone__isnull=True)
        • 获取phone字段的值是null的
    • __isnull = False：查询值不是null的

七、 ForeignKey操作

  1. 基于对象的查询

    • 正向查询，语法：对象.关联字段.字段
    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()

  2. 基于字段的查询

    • 正向查询，语法：关联字段__字段
    # 查询老男孩出版的书
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')

八、 多对多的操作

  1. 基于对象的查询

    • 正向查询，语法：对象.多对多字段.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()

  2. 基于字段的查询

    • 正向查询，语法：多对多字段__字段
    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')

  3. 关系管理对象的方法

    • 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')

九、 聚合和分组

  1. 聚合

    • 内置函数：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)

  2. 分组

    • 一般和聚合一起使用
    # 统计每一本书的作者个数，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查询

  1. 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)

  2. 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)

十二、 其他操作设置

  1. 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()

  2. 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',
        },
    }
}

  3. 在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)
posted @ 2019-07-11 17:29  林染  阅读(303)  评论(2)  编辑  收藏  举报