django中的ORM与 应用与补充

ORM与数据的对应关系

  1. ORM 面向对象和关系型数据库的一种映射,通过操作对象的方式操作数据库数据,不支持对库的操作,只能操作表
  3. 对应关系:
  4. 类   --> 表
  5. 对象 --> 数据行
  6. 属性 --> 字段

ORM 常用字段

  • AutoField 主键

  1. 自增的整形字段，必填参数primary_key=True，则成为数据库的主键。无该字段时，django自动创建。
  3. 一个model不能有两个AutoField字段。
  4. #如
  5. pid = models.AutoField(primary_key=True)

  • IntegerField 整数

  1. 一个整数类型。数值的范围是 -2147483648 ~ 2147483647。
  2. #如
  3. age = models.IntegerField()

  • CharField 字符串

  1. 字符类型，必须提供max_length参数。max_length表示字符的长度。
  2. #小提示 电话号建议使用CharField存储 节省资源
  3. #如
  4. name = models.CharField(max_length=32)

  • BooleanField 布尔值

  1. BooleanField(True/False) #数据库存为True--> 1 False--> 0

  • TextField 文本

  1. TextField()#比较长的字符串

  • DateTimeField 日期时间

  • auto_now_add=True
  1. # 新增数据的时候会自动保存当前的时间
  2. birth = models.DateTimeField(auto_now_add=True)
  4. #默认是 UTC时间 一般不跨时区的应用，可以不使用时区，即在settings.py设置   USE_TZ = False
  • auto_now=True
  1.  # 新增、修改当前数据的时候会自动保存当前的时间
  2. birth = models.DateTimeField(auto_now=True)

  • DecimalField 十进制的小数

  • max_digits 小数总长度

  • decimal_places 小数位长度

  1. max_digits       小数总长度   5
  2. decimal_places   小数位长度   2  #那么整数位长度就为3

ORM 其他字段

  • 字段类型，详情可点击查询官网。
  1.     AutoField(Field)
  2.         - int自增列，必须填入参数 primary_key=True
  4.     BigAutoField(AutoField)
  5.         - bigint自增列，必须填入参数 primary_key=True
  7.         注：当model中如果没有自增列，则自动会创建一个列名为id的列
  8.         from django.db import models
  10.         class UserInfo(models.Model):
  11.             # 自动创建一个列名为id的且为自增的整数列
  12.             username = models.CharField(max_length=32)
  14.         class Group(models.Model):
  15.             # 自定义自增列
  16.             nid = models.AutoField(primary_key=True)
  17.             name = models.CharField(max_length=32)
  19.     SmallIntegerField(IntegerField):
  20.         - 小整数 -32768 ～ 32767
  22.     PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  23.         - 正小整数 0 ～ 32767
  25.     IntegerField(Field)
  26.         - 整数列(有符号的) -2147483648 ～ 2147483647
  28.     PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  29.         - 正整数 0 ～ 2147483647
  31.     BigIntegerField(IntegerField):
  32.         - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
  34.     BooleanField(Field)
  35.         - 布尔值类型
  37.     NullBooleanField(Field):
  38.         - 可以为空的布尔值
  40.     CharField(Field)
  41.         - 字符类型
  42.         - 必须提供max_length参数， max_length表示字符长度
  44.     TextField(Field)
  45.         - 文本类型
  47.     EmailField(CharField)：
  48.         - 字符串类型，Django Admin以及ModelForm中提供验证机制
  50.     IPAddressField(Field)
  51.         - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
  53.     GenericIPAddressField(Field)
  54.         - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
  55.         - 参数：
  56.             protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
  57.             unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"
  59.     URLField(CharField)
  60.         - 字符串类型，Django Admin以及ModelForm中提供验证 URL
  62.     SlugField(CharField)
  63.         - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）
  65.     CommaSeparatedIntegerField(CharField)
  66.         - 字符串类型，格式必须为逗号分割的数字
  68.     UUIDField(Field)
  69.         - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
  71.     FilePathField(Field)
  72.         - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
  73.         - 参数：
  74.                 path,                      文件夹路径
  75.                 match=None,                正则匹配
  76.                 recursive=False,           递归下面的文件夹
  77.                 allow_files=True,          允许文件
  78.                 allow_folders=False,       允许文件夹
  80.     FileField(Field)
  81.         - 字符串，路径保存在数据库，文件上传到指定目录
  82.         - 参数：
  83.             upload_to = ""      上传文件的保存路径
  84.             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
  86.     ImageField(FileField)
  87.         - 字符串，路径保存在数据库，文件上传到指定目录
  88.         - 参数：
  89.             upload_to = ""      上传文件的保存路径
  90.             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
  91.             width_field=None,   上传图片的高度保存的数据库字段名（字符串）
  92.             height_field=None   上传图片的宽度保存的数据库字段名（字符串）
  94.     DateTimeField(DateField)
  95.         - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
  97.     DateField(DateTimeCheckMixin, Field)
  98.         - 日期格式      YYYY-MM-DD
  100.     TimeField(DateTimeCheckMixin, Field)
  101.         - 时间格式      HH:MM[:ss[.uuuuuu]]
  103.     DurationField(Field)
  104.         - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
  106.     FloatField(Field)
  107.         - 浮点型
  109.     DecimalField(Field)
  110.         - 10进制小数
  111.         - 参数：
  112.             max_digits，小数总长度
  113.             decimal_places，小数位长度
  115.     BinaryField(Field)
  116.         - 二进制类型

自定义字段

  • 有些字段 django没有提供,就需要我们自定来完成

  • 自定义一个char类型字段：

  1. class MyCharField(models.Field):#自定义的char类型的字段类
  3.     def __init__(self, max_length, *args, **kwargs):
  4.         self.max_length = max_length
  5.         super(MyCharField, self).__init__(max_length= max_length,*args, **kwargs)
  7.     def db_type(self, connection):#限定生成数据库表的字段类型为char，长度为max_length指定的值
  8.         return 'char(%s)'%self.max_length
  • 使用自定义char类型字段：
  1. class Class(models.Model):
  3.     id = models.AutoField(primary_key=True)
  4.     title = models.CharField(max_length=25)
  5.     cname = MyCharField(max_length=25)# 使用自定义的char类型的字段

  • 自定义一个二进制字段，以及Django字段与数据库字段类型的对应关系。

  1. class UnsignedIntegerField(models.IntegerField):
  2.     def db_type(self, connection):
  3.         return 'integer UNSIGNED'
  5. # PS: 返回值为字段在数据库中的属性。
  6. # Django字段与数据库字段类型对应关系如下：
  7.     'AutoField': 'integer AUTO_INCREMENT',
  8.     'BigAutoField': 'bigint AUTO_INCREMENT',
  9.     'BinaryField': 'longblob',
  10.     'BooleanField': 'bool',
  11.     'CharField': 'varchar(%(max_length)s)',
  12.     'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
  13.     'DateField': 'date',
  14.     'DateTimeField': 'datetime',
  15.     'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
  16.     'DurationField': 'bigint',
  17.     'FileField': 'varchar(%(max_length)s)',
  18.     'FilePathField': 'varchar(%(max_length)s)',
  19.     'FloatField': 'double precision',
  20.     'IntegerField': 'integer',
  21.     'BigIntegerField': 'bigint',
  22.     'IPAddressField': 'char(15)',
  23.     'GenericIPAddressField': 'char(39)',
  24.     'NullBooleanField': 'bool',
  25.     'OneToOneField': 'integer',
  26.     'PositiveIntegerField': 'integer UNSIGNED',
  27.     'PositiveSmallIntegerField': 'smallint UNSIGNED',
  28.     'SlugField': 'varchar(%(max_length)s)',
  29.     'SmallIntegerField': 'smallint',
  30.     'TextField': 'longtext',
  31.     'TimeField': 'time',
  32.     'UUIDField': 'char(32)',

字段参数

  • 字段参数，详情可点击查看官网。
  1.     null                数据库中字段是否可以为空  #注意 数据库的 null 和''空字符是两种情况
  2.     db_column           数据库中字段的列名
  3.     default             数据库中字段的默认值
  4.     primary_key         数据库中字段是否为主键
  5.     db_index            数据库中字段是否可以建立索引
  6.     unique              数据库中字段是否可以建立唯一索引
  7.     unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
  8.     unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
  9.     unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
  11.     verbose_name        Admin中显示的字段名称
  12.     blank               Admin中是否允许用户输入为空
  13.     editable            Admin中是否可以编辑
  14.     help_text           Admin中该字段的提示信息
  15.     choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
  16.                         如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
  18.     error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
  19.                         字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
  20.                         如：{'null': "不能为空.", 'invalid': '格式错误'}
  22.     validators          自定义错误验证（列表类型），从而定制想要的验证规则
  23.                       from django.core.validators import RegexValidator
  24.                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,MaxLengthValidator,
  25. MinLengthValidator,MaxValueValidator,MinValueValidator
  26.                         如：
  27.                             test = models.CharField(
  28.                                 max_length=32,
  29.                                 error_messages={
  30.                                     'c1': '优先错信息1',
  31.                                     'c2': '优先错信息2',
  32.                                     'c3': '优先错信息3',
  33.                                 },
  34.                                 validators=[
  35.                                     RegexValidator(regex='root_\d+', message='错误了', code='c1'),
  36.                                     RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
  37.                                     EmailValidator(message='又错误了', code='c3'), ]
  38.                             )字段参数

Model Meta参数

  • 这个不是很常用，如果你有特殊需要可以使用。详情点击查看官网。
  1. class UserInfo(models.Model):
  2.     nid = models.AutoField(primary_key=True)
  3.     username = models.CharField(max_length=32)
  5.     class Meta:
  6.         # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
  7.         db_table = "table_name"
  9.         # admin中显示的表名称
  10.         verbose_name = '个人信息'
  12.         # verbose_name加s
  13.         verbose_name_plural = '所有用户信息'
  15.         # 联合索引
  16.         index_together = [
  17.             ("pub_date", "deadline"),   # 应为两个存在的字段
  18.         ]
  20.         # 联合唯一索引
  21.         unique_together = (("driver", "restaurant"),)   # 应为两个存在的字段

常用13中查询(必会)

  1. <1> all():#查询所有结果 ——》 QuerySet 对象列表 想要的到方便查看的结果,可以使用__str___方法加在ORM的表类后边 如:
  2.     """
  3.     def __str__(self):
  4.         return '{} - {}'.format(self.pk, self.name)
  5.     """
  6.     ret = models.Person.objects.all()
  8. <2> get(**kwargs):#获取满足条件的一个数据 ——》 对象  获取不到或者多个都报错
  9.     ret = models.Person.objects.get(pk=1)
  11. <3> filter(**kwargs):#获取满足条件的所有数据   ——》 QuerySet   对象列表 没有返回None
  12.     ret = models.Person.objects.filter(pk=1)
  14. <4> exclude(**kwargs):#获取不满足条件的所有数据   ——》 QuerySet   对象列表
  15.     ret = models.Person.objects.exclude(pk=1)
  17. <5> values(*field):#返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，
  18. 而是一个可迭代的字典序列,拿到对象指定的字段和字段的值    QuerySet  [ {} ,{} ]
  19.     ret = models.Person.objects.values('pid','name')
  20. # values()  拿到对象所有的字段和字段的值    QuerySet  [ {} ,{} ]
  22. <6> values_list():#它与values()非常相似，它返回的是一个元组序列，values()返回的是一个字典序列,拿到对象所有的字段的值
  23. QuerySet  [ () ,() ] 用索引取值
  24.     values_list(字段)#拿到对象指定的字段的值      QuerySet  [ {} ,{} ]
  25.     ret = models.Person.objects.values_list('name','pid')
  27. <7> order_by(字段):#对查询结果排序默认升序 123
  28.     order_by(-字段):#字段前边加减号排序方式改为降序321
  29.     order_by(字段1,-字段2):#先按照字段1升序排序,再按照字段2降序排序,如果字段1值有相等的,将按照字段2排序大的在前面
  30.     ret = models.Person.objects.all().order_by('age','-pid')
  32. <8> reverse():#(反向排序 只能对已经排序的QuerySet进行反转)
  33.     ret = models.Person.objects.all().order_by('pk').reverse()
  35. <9> distinct():#(去重  完全相同的内容才能去重)从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。
  36. 此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
  37.     ret = models.Person.objects.values('age').distinct()
  39. <10> count():#(计数)返回数据库中匹配查询(QuerySet)的对象数量。
  40.     ret = models.Person.objects.all().count()
  41.     #len(models.Person.objects.all())效果一样
  43. <11> first():#(取第一元素   没有元素 None)返回第一条记录
  44.     ret = models.Person.objects.filter(pk=1).values().first()
  46. <12> last():#(取最后一元素   没有元素 None)返回最后一条记录
  47.     ret = models.Person.objects.filter(pk=1).values().last()
  49. <13> exists():#(查询的数据是否存在)如果QuerySet包含数据，就返回True，否则返回False
  50.     ret = models.Person.objects.filter(pk=1000).exists()
  1. #返回QuerySet对象的方法有
  2. all()
  4. filter()
  6. exclude()
  8. order_by()
  10. reverse()
  12. distinct()
  14. #特殊的QuerySet
  15. values()       返回一个可迭代的字典序列
  17. values_list() 返回一个可迭代的元祖序列
  19. #返回具体对象的
  20. get()
  22. first()
  24. last()
  26. #返回布尔值的方法有：
  27. exists()
  29. #返回数字的方法有
  30. count()

单表查询的双下划线应用

  1. import os
  3. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
  4. import django
  6. django.setup()
  8. from app01 import models
  10. ret = models.Person.objects.filter(pk__gt=1)   # gt  greater than   大于
  11. ret = models.Person.objects.filter(pk__lt=3)   # lt  less than   小于
  12. ret = models.Person.objects.filter(pk__gte=1)   # gte  greater than   equal    大于等于
  13. ret = models.Person.objects.filter(pk__lte=3)   # lte  less than  equal  小于等于
  14. ret = models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
  16. ret = models.Person.objects.filter(pk__range=[2,3])   # range  范围
  17. ret = models.Person.objects.filter(pk__in=[1,3,10,100])   # in  成员判断
  18. ret = models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
  20. ret = models.Person.objects.filter(name__contains='A')#name包含A的
  21. ret = models.Person.objects.filter(name__icontains='A')   # 忽略大小写
  23. ret = models.Person.objects.filter(name__startswith='a')# 以什么开头
  24. ret = models.Person.objects.filter(name__istartswith='A')#以什么开头不区分大小写
  26. ret = models.Person.objects.filter(name__endswith='a')#以什么结尾
  27. ret = models.Person.objects.filter(name__iendswith='I')#不区分大小写
  29. ret  = models.Person.objects.filter(birth__year='2019')#查字段年份
  30. ret  = models.Person.objects.filter(birth__contains='2018-06-24')#查月份只能查年在查月  查日同理
  32. ret  = models.Person.objects.filter(phone__isnull=False)#查看phone字段值不为null的(空字符不等于null哦)

ForeignKey外键的操作

  • 正向查找

  • 对象查找（跨表）

  • 示例：

  1. #语法：
  2. #对象.关联字段.字段
  3. book_obj = models.Book.objects.first()  # 第一本书对象
  4. print(book_obj.publisher)  # 得到这本书关联的出版社对象
  5. print(book_obj.publisher.name)  # 得到出版社对象的名称
  • 字段查找（跨表）
  • 示例：
  1. #语法：
  2. #关联字段__字段
  3. print(models.Book.objects.values_list("publisher__name"))

  • 反向操作

  • 对象查找

  • 示例：

  1. #语法：
  2. #obj.表名_set
  4. publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象
  5. books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书
  6. titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名
  • 字段查找
  • 示例：
  1. #语法：
  2. #表名__字段
  3. titles = models.Publisher.objects.values_list("book__title")

  • 总结:

  1. class Publisher(models.Model):
  2.     name = models.CharField(max_length=32, verbose_name="名称")
  4.     def __str__(self):
  5.         return self.name
  7. class Book(models.Model):
  8.     title = models.CharField(max_length=32)
  9.     pub = models.ForeignKey(Publisher, related_name='books',related_query_name='xxx',on_delete=models.CASCADE)
  11.     def __str__(self):
  12.         return self.title
  14. 基于对象查询
  16. 正向
  18. book_obj.pub    ——》  所关联的对象
  20. book_obj.pub_id    ——》  所关联的对象id
  22. 反向
  24. 没有指定related_name
  26. pub_obj.book_set     ——》  关系管理对象    （类名小写_set）
  28. pub_obj.book_set.all（）   ——》  所关联的所有对象
  30. 指定related_name='books'
  32. pub_obj.books   ——》  关系管理对象    （类名小写_set）
  34. pub_obj.books.all（）   ——》  所关联的所有对象
  36. 基于字段查询
  38. models.Book.objects.filter(pub__name='xxxxx')
  40. 没有指定related_name
  42. models.Publisher.objects.filter(book__title='xxxxx')
  44. 指定related_name=‘books’
  46. models.Publisher.objects.filter(books__title='xxxxx')
  48. 指定related_query_name='book‘
  50. models.Publisher.objects.filter(book__title='xxxxx')

多对多

  1. "关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。
  2. 它存在于下面两种情况：
  3.     1 外键关系的反向查询
  4.     2 多对多关联关系
  5. 简单来说就是当 点后面的对象 可能存在多个的时候就可以使用以下的方法。

  • 方法

  • all()

  1. # all()  所关联的所有的对象
  3. # print(mjj.books.all())
  4. # set  设置多对多的关系    [id,id]    [ 对象，对象 ]
  5. # mjj.books.set([1,2])
  6. # mjj.books.set(models.Book.objects.filter(pk__in=[1,2,3]))

  • create()

  1. #创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。
  2. import datetime
  3. models.Author.objects.first().book_set.create(title="python从入门到放弃", publish_date=datetime.date.today())
  5. # create()
  6. # obj = mjj.books.create(title='葵花宝典',pub_id=1)
  7. # print(obj)
  8. # book__obj = models.Book.objects.get(pk=1)
  9. # obj = book__obj.authors.create(name='taibai')

  • add()

  • 把指定的model对象添加到关联对象集中。
  1. #添加对象
  2. author_objs = models.Author.objects.filter(id__lt=3)
  3. models.Book.objects.first().authors.add(*author_objs)
  5. # add  添加多对多的关系   (id,id)   (对象，对象)
  6. # mjj.books.add(4,5)
  7. # mjj.books.add(*models.Book.objects.filter(pk__in=[4,5]))
  • 添加id
  1. models.Book.objects.first().authors.add(*[1, 2])

  • set()

  1. #更新model对象的关联对象。
  2. book_obj = models.Book.objects.first()
  3. book_obj.authors.set([2, 3])

  • remove()

  1. #从关联对象集中移除执行的model对象
  2. book_obj = models.Book.objects.first()
  3. book_obj.authors.remove(3)
  5. # remove 删除多对多的关系  (id,id)   (对象，对象)
  6. # mjj.books.remove(4,5)
  7. # mjj.books.remove(*models.Book.objects.filter(pk__in=[4,5]))

  • clear()

  1. #从关联对象集中移除一切对象。
  2. book_obj = models.Book.objects.first()
  3. book_obj.authors.clear()
  5. # clear()   清除所有的多对多关系
  6. # mjj.books.clear()
  • 注意

    • 对于ForeignKey对象，clear()和remove()方法仅在null=True时存在

  • 举个例子：

  • ForeignKey字段没设置null=True时

  1. class Book(models.Model):
  2.     title = models.CharField(max_length=32)
  3.     publisher = models.ForeignKey(to=Publisher)
  • 没有clear()和remove()方法
  1. >>> models.Publisher.objects.first().book_set.clear()
  2. Traceback (most recent call last):
  3.   File "<input>", line 1, in <module>
  4. AttributeError: 'RelatedManager' object has no attribute 'clear'
  • 当ForeignKey字段设置null=True时
  1. class Book(models.Model):
  2.     name = models.CharField(max_length=32)
  3.     publisher = models.ForeignKey(to=Class, null=True)
  • 此时就有clear()和remove()方法：
  1. models.Publisher.objects.first().book_set.clear()
  • 注意：
  1. 对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，
  2. 都不需要再调用save()方法。

聚合查询和分组查询

  • 聚合

  1. aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。
  3. 键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。
  5. 用到的内置函数：
  7. from django.db.models import Avg, Sum, Max, Min, Count
  8. 示例：
  10. >>> from django.db.models import Avg, Sum, Max, Min, Count
  11. >>> models.Book.objects.all().aggregate(Avg("price"))
  12. {'price__avg': 13.233333}
  13. 如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
  15. >>> models.Book.objects.aggregate(average_price=Avg('price'))
  16. {'average_price': 13.233333}
  17. 如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，
  18. 可以这样查询：
  20. >>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
  21. {'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}

  • 分组

  • 假设现在有一张公司职员表 employee
id name age salary province dept
1 张三 23 2000 河北 财务
2 李四 34 4000 山东 人事
3 王五 45 6000 北京 人事
4 赵六 56 8000 南京 教学部 
  1. #我们使用原生SQL语句，按照部门分组求平均工资：
  2. select dept,AVG(salary) from employee group by dept;
  3. ORM查询:
  5. from django.db.models import Avg
  6. Employee.objects.values("dept").annotate(avg=Avg("salary").values("dept", "avg")

  • 连表查询的分组

  • employee
id name age salary province dept_id
1 张三 23 2000 河北 1
2 李四 34 4000 山东 2
3 王五 45 6000 北京 2
4 赵六 56 8000 南京 3
  • dept
id name
1 财务部
2 人事部
3 教学部
4 行政部 
  1. SQL查询：
  3. select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;
  4. ORM查询：
  6. from django.db.models import Avg
  7. models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")

  • F 和 Q

  • F
  1. 在上面所有的例子中，我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较，那该怎么做呢？
  3. Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
  5. 示例1：
  7. 查询评论数大于收藏数的书籍
  9. from django.db.models import F
  10. models.Book.objects.filter(commnet_num__gt=F('keep_num'))
  11. Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
  13. models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)
  14. 修改操作也可以使用F函数,比如将每一本书的价格提高30元
  16. models.Book.objects.all().update(price=F("price")+30)
  17. 引申：
  19. 如果要修改char字段咋办？
  21. 如：把所有书名后面加上(第一版)
  23. >>> from django.db.models.functions import Concat
  24. >>> from django.db.models import Value
  25. >>> models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("第一版"), Value(")")))

  • Q

  • |(或) &(与) ~(非)

  1. filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。
  3. 示例1：
  5. 查询作者名是小仙女或小魔女的
  7. models.Book.objects.filter(Q(authors__name="小仙女")|Q(authors__name="小魔女"))
  8. 你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询。
  10. 示例：查询作者名字是小仙女并且不是2018年出版的书的书名。
  12. >>> models.Book.objects.filter(Q(author__name="小仙女") & ~Q(publish_date__year=2018)).values_list("title")
  13. <QuerySet [('番茄物语',)]>
  14. 查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，
  15. 它必须位于所有关键字参数的前面。
  17. 例如：查询出版年份是2017或2018，书名中带物语的所有书。
  19. >>> models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="物语")
  20. <QuerySet [<Book: 番茄物语>, <Book: 香蕉物语>, <Book: 橘子物语>]>

  • 事务

  1. #是数据库运行的最基本单位,原子型操作,保证操作的完整性,如:实际生活中银行转账,先从转账者账户扣除200元,再往收款账户存入200元,实际上就是数据库的操作,
  2. 事务就是保证这个操作的完整性,比如转账中间出现了问题,事务会把数据回滚到操作之前的状态.
  4. #事务正确书写格式
  5. from django.db import transaction
  7. try:
  8.     with transaction.atomic():
  9.         # 进行一系列的ORM操作
  10.         models.Publisher.objects.create(name='xxxxx')
  11.         models.Publisher.objects.create(name='xxx22')
  12. except Exception as e :
  13.     print(e)
  14. #注意要是第一条数据已经写入成功,在写入第二条出现错误,事务会把第一条写入信息删除,并抛出异常提示,数据库是有记录的,id主键数会加1,但是没有数据
  • 错误写法导致事务无效

  • QuerySet方法大全

  1. ##################################################################
  2. # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
  3. ##################################################################
  5. def all(self)
  6.     # 获取所有的数据对象
  8. def filter(self, *args, **kwargs)
  9.     # 条件查询
  10.     # 条件可以是：参数，字典，Q
  12. def exclude(self, *args, **kwargs)
  13.     # 条件查询
  14.     # 条件可以是：参数，字典，Q
  16. def select_related(self, *fields)
  17.     性能相关：表之间进行join连表操作，一次性获取关联的数据。
  19.     总结：
  20.     1. select_related主要针一对一和多对一关系进行优化。
  21.     2. select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
  23. def prefetch_related(self, *lookups)
  24.     性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。
  26.     总结：
  27.     1. 对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。
  28.     2. prefetch_related()的优化方式是分别查询每个表，然后用Python处理他们之间的关系。
  30. def annotate(self, *args, **kwargs)
  31.     # 用于实现聚合group by查询
  33.     from django.db.models import Count, Avg, Max, Min, Sum
  35.     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
  36.     # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
  38.     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
  39.     # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
  41.     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
  42.     # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
  44. def distinct(self, *field_names)
  45.     # 用于distinct去重
  46.     models.UserInfo.objects.values('nid').distinct()
  47.     # select distinct nid from userinfo
  49.     注：只有在PostgreSQL中才能使用distinct进行去重
  51. def order_by(self, *field_names)
  52.     # 用于排序
  53.     models.UserInfo.objects.all().order_by('-id','age')
  55. def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  56.     # 构造额外的查询条件或者映射，如：子查询
  58.     Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  59.     Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  60.     Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  61.     Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  63.  def reverse(self):
  64.     # 倒序
  65.     models.UserInfo.objects.all().order_by('-nid').reverse()
  66.     # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序
  68.  def defer(self, *fields):
  69.     models.UserInfo.objects.defer('username','id')
  70.     或
  71.     models.UserInfo.objects.filter(...).defer('username','id')
  72.     #映射中排除某列数据
  74.  def only(self, *fields):
  75.     #仅取某个表中的数据
  76.      models.UserInfo.objects.only('username','id')
  77.      或
  78.      models.UserInfo.objects.filter(...).only('username','id')
  80.  def using(self, alias):
  81.      指定使用的数据库，参数为别名（setting中的设置）
  83. ##################################################
  84. # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
  85. ##################################################
  87. def raw(self, raw_query, params=None, translations=None, using=None):
  88.     # 执行原生SQL
  89.     models.UserInfo.objects.raw('select * from userinfo')
  91.     # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
  92.     models.UserInfo.objects.raw('select id as nid from 其他表')
  94.     # 为原生SQL设置参数
  95.     models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])
  97.     # 将获取的到列名转换为指定列名
  98.     name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
  99.     Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)
  101.     # 指定数据库
  102.     models.UserInfo.objects.raw('select * from userinfo', using="default")
  104.     ################### 原生SQL ###################
  105.     from django.db import connection, connections
  106.     cursor = connection.cursor()  # cursor = connections['default'].cursor()
  107.     cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  108.     row = cursor.fetchone() # fetchall()/fetchmany(..)
  110. def values(self, *fields):
  111.     # 获取每行数据为字典格式
  113. def values_list(self, *fields, **kwargs):
  114.     # 获取每行数据为元祖
  116. def dates(self, field_name, kind, order='ASC'):
  117.     # 根据时间进行某一部分进行去重查找并截取指定内容
  118.     # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
  119.     # order只能是："ASC"  "DESC"
  120.     # 并获取转换后的时间
  121.         - year : 年-01-01
  122.         - month: 年-月-01
  123.         - day  : 年-月-日
  125.     models.DatePlus.objects.dates('ctime','day','DESC')
  127. def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
  128.     # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
  129.     # kind只能是 "year", "month", "day", "hour", "minute", "second"
  130.     # order只能是："ASC"  "DESC"
  131.     # tzinfo时区对象
  132.     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
  133.     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
  135.     """
  136.     pip3 install pytz
  137.     import pytz
  138.     pytz.all_timezones
  139.     pytz.timezone(‘Asia/Shanghai’)
  140.     """
  142. def none(self):
  143.     # 空QuerySet对象
  145. ####################################
  146. # METHODS THAT DO DATABASE QUERIES #
  147. ####################################
  149. def aggregate(self, *args, **kwargs):
  150.    # 聚合函数，获取字典类型聚合结果
  151.    from django.db.models import Count, Avg, Max, Min, Sum
  152.    result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
  153.    ===> {'k': 3, 'n': 4}
  155. def count(self):
  156.    # 获取个数
  158. def get(self, *args, **kwargs):
  159.    # 获取单个对象
  161. def create(self, **kwargs):
  162.    # 创建对象
  164. def bulk_create(self, objs, batch_size=None):
  165.     # 批量插入
  166.     # batch_size表示一次插入的个数
  167.     objs = [
  168.         models.DDD(name='r11'),
  169.         models.DDD(name='r22')
  170.     ]
  171.     models.DDD.objects.bulk_create(objs, 10)
  173. def get_or_create(self, defaults=None, **kwargs):
  174.     # 如果存在，则获取，否则，创建
  175.     # defaults 指定创建时，其他字段的值
  176.     obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})
  178. def update_or_create(self, defaults=None, **kwargs):
  179.     # 如果存在，则更新，否则，创建
  180.     # defaults 指定创建时或更新时的其他字段
  181.     obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})
  183. def first(self):
  184.    # 获取第一个
  186. def last(self):
  187.    # 获取最后一个
  189. def in_bulk(self, id_list=None):
  190.    # 根据主键ID进行查找
  191.    id_list = [11,21,31]
  192.    models.DDD.objects.in_bulk(id_list)
  194. def delete(self):
  195.    # 删除
  197. def update(self, **kwargs):
  198.     # 更新
  200. def exists(self):
  201.    # 是否有结果

  • Django ORM执行原生SQL(了解)

  1. # extra
  2. # 在QuerySet的基础上继续执行子语句
  3. # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  5. # select和select_params是一组，where和params是一组，tables用来设置from哪个表
  6. # Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  7. # Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  8. # Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  9. # Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  11. 举个例子：
  12. models.UserInfo.objects.extra(
  13.                     select={'newid':'select count(1) from app01_usertype where id>%s'},
  14.                     select_params=[1,],
  15.                     where = ['age>%s'],
  16.                     params=[18,],
  17.                     order_by=['-age'],
  18.                     tables=['app01_usertype']
  19.                 )
  20.                 """
  21.                 select
  22.                     app01_userinfo.id,
  23.                     (select count(1) from app01_usertype where id>1) as newid
  24.                 from app01_userinfo,app01_usertype
  25.                 where
  26.                     app01_userinfo.age > 18
  27.                 order by
  28.                     app01_userinfo.age desc
  29.                 """
  31. # 执行原生SQL
  32. # 更高灵活度的方式执行原生SQL语句
  33. # from django.db import connection, connections
  34. # cursor = connection.cursor()  # cursor = connections['default'].cursor()
  35. # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  36. # row = cursor.fetchone()

Django终端打印SQL语句

  • 在Django项目的settings.py文件中，在最后复制粘贴如下代码：
  1. LOGGING = {
  2.     'version': 1,
  3.     'disable_existing_loggers': False,
  4.     'handlers': {
  5.         'console':{
  6.             'level':'DEBUG',
  7.             'class':'logging.StreamHandler',
  8.         },
  9.     },
  10.     'loggers': {
  11.         'django.db.backends': {
  12.             'handlers': ['console'],
  13.             'propagate': True,
  14.             'level':'DEBUG',
  15.         },
  16.     }
  17. }
  18. #即为你的Django项目配置上一个名为django.db.backends的logger实例即可查看翻译后的SQL语句。

在Python脚本中调用Django环境

  • 创建py文件复制下面代码
  1. import os
  3. #if __name__ == '__main__':
  4.     #os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
  5. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
  6. import django
  7. django.setup()
  9. from app01 import models
  11. books = models.Book.objects.all()
  12. print(books)
  13. #后边写可被执行的ORM或原生sql语句

django控制台写入数据(交互式无法保存记录)

django中的ORM与 应用与补充的更多相关文章

  1. 在Django中使用ORM创建图书管理系统

    一.ORM(对象关系映射) 很多语言的web框架中都有这个概念 1. 为什么要有ORM? 1. 写程序离不开数据,要使用数据就需要连接数据库,但是不同的数据库在sql语句上(mysql,oracle等 ...

  2. Django中的ORM进阶操作

    Django中的ORM进阶操作 Django中是通过ORM来操作数据库的,通过ORM可以很easy的实现与数据库的交互.但是仍然有几种操作是非常绕也特别容易混淆的.于是,针对这一块,来一个分类总结吧. ...

  3. Django中的ORM框架使用小技巧

      Django中的ORM框架使用小技巧 作者:尹正杰  版权声明:原创作品,谢绝转载!否则将追究法律责任. Django对各个数据提供了很好的支持,包括PostgreSQL,MySQL,SQLite ...

  4. django中的ORM介绍和字段及字段参数

    Object Relational Mapping(ORM) ORM介绍 ORM概念 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据 ...

  5. Django中的ORM介绍，字段以及字段的参数。

    Object Relational Mapping(ORM) ORM介绍 ORM概念 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据 ...

  6. Django 中得ORM介绍和字段及字段参数

    ORM 介绍 ORM概念 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术. 简单的说 ORM 是通过使用 ...

  7. Django中使用ORM

    一.ORM概念 对象关系映射(Object Relational Mapping,简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术. 简单的说,ORM是通过使用描述对象和数 ...

  8. Django中的ORM如何通过数据库中的表格信息自动化生成Model 模型类？

    Inspectdb Django项目通过绑定的数据库中的相应表格直接自动化生成Model 模型类 python manage.py inspectdb Django 中的 ORM 可以实现对象关系映射 ...

  9. Django中的ORM

    Django中ORM的使用. 一.安装python连接mysql的模块:MySQL-python sudo pip install MySQL-python 安装完成后在python-shell中测试 ...

随机推荐

  1. 关于引用WebLogic.jar时遇到NoClassDefFoundError问题的解决方法

    前段时间在做一个项目开发时,需要用到weblogic.jndi.WLInitialContextFactory,所以按照以前的经验,将WebLogic.jar添加到Build Path中.可是在执行时 ...

  2. SpringBoot学习笔记（8）：事物处理

    SpringBoot学习笔记(8):事物处理 快速入门 在传统的JDBC事务代码开发过程中,业务代码只有一部分,大部分都是与JDBC有关的功能代码,比如数据库的获取与关闭以及事务的提交与回滚.大量的t ...

  3. ZOJ - 1504 Slots of Fun 【数学】

    题目链接 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1504 题意 给出一串字符串 里面的每个字符的位置 都按照题目的意 ...

  4. sqrt源码

    先找出接近m的浮点数,然后通过下面的不等式中的等于条件得到其平方根. #include <iostream> #include <math.h> using namespace ...

  5. LightOJ - 1151 Snakes and Ladders —— 期望、高斯消元法

    题目链接:https://vjudge.net/problem/LightOJ-1151 1151 - Snakes and Ladders    PDF (English) Statistics F ...

  6. 存储过程IF --ELSE IF -- END IF 使用

    CREATE OR REPLACE PROCEDURE BJPJYXK_HF_SD( sqid_p IN VARCHAR2,--申请单ID xkbh_p IN VARCHAR2,--新生成的许可证编号 ...

  7. hihocoder1075【开锁魔法】

    hihocoder1075[开锁魔法] 题意是给你一个 \(1-n\) 的置换,求选 \(k\) 个可以遍历所有点的概率. 题目可以换个模型:有 \(n\) 个球,有 \(cnt\) 种不同的颜色,求 ...

  8. MySQL 数据底部出现总计字样 第二种办法 纵向合并 20161103

    上次在博客http://www.cnblogs.com/Mr-Cxy/p/5923375.html 我们使用了group by with rollup 函数 field自定义排序 来实现添加底部总计字 ...

  9. ACM学习历程——HDU5017 Ellipsoid（模拟退火）（2014西安网赛K题）

    ---恢复内容开始--- Description Given a 3-dimension ellipsoid(椭球面) your task is to find the minimal distanc ...

  10. wpf datagrid row的命中测试

    1. 添加鼠标左键处理 AddHandler(DataGrid.MouseLeftButtonDownEvent, new RoutedEventHandler(grdStudyList_MouseL ...