python框架之Django(5)-O/RM

字段&参数

字段与db类型的对应关系

字段	DB Type
AutoField	integer AUTO_INCREMENT
BigAutoField	bigint AUTO_INCREMENT
BinaryField	longblob
BooleanField	bool
CharField	varchar
CommaSeparatedIntegerField	varchar
DateField	date
DateTimeField	datetime
DecimalField	numeric
DurationField	bigint
FileField	varchar
FilePathField	varchar
FloatField	double precision
IntegerField	integer
BigIntegerField	bigint
IPAddressField	char(15)
GenericIPAddressField	char(39)
NullBooleanField	bool
OneToOneField	integer
PositiveIntegerField	integer UNSIGNED
PositiveSmallIntegerField	smallint UNSIGNED
SlugField	varchar
SmallIntegerField	smallint
TextField	longtext
TimeField	time
UUIDField	char(32)

非关系字段

内置字段

字段	说明
AutoField	int自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。
IntegerField	一个整数类型,范围在 -2147483648 to 2147483647。
CharField	字符类型，必须提供max_length参数， max_length表示字符长度。
DateField	日期字段，日期格式 YYYY-MM-DD，相当于Python中的datetime.date()实例。
DateTimeField	日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime()实例。
BigAutoField	bigint自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。
SmallIntegerField	小整数 -32768 ～ 32767
PositiveSmallIntegerField	正小整数 0 ～ 32767
PositiveIntegerField	正整数 0 ～ 2147483647
BigIntegerField	长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
BooleanField	布尔值类型
NullBooleanField	可以为空的布尔值
TextField	文本类型
EmailField	字符串类型，Django Admin以及ModelForm中提供验证机制
IPAddressField	字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
GenericIPAddressField	字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
URLField	字符串类型，Django Admin以及ModelForm中提供验证 URL
SlugField	字符串类型，Django Admin以及ModelForm中提供验证支持字母、数字、下划线、连接符（减号）
CommaSeparatedIntegerField	字符串类型，格式必须为逗号分割的数字
UUIDField	字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
FilePathField	字符串，路径保存在数据库，文件上传到指定目录
ImageField	字符串，路径保存在数据库，文件上传到指定目录
TimeField	时间格式 HH:MM[:ss[.uuuuuu]]
DurationField	长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
FloatField	浮点型
DecimalField	10进制小数
BinaryField	二进制类型

自定义字段

此处示例为创建一个对应db中char类型的字段

创建自定义类型

 class FixedCharField(models.Field):

     """

     自定义的char类型的字段类

     """

     def __init__(self, max_length, *args, **kwargs):

         self.max_length = max_length

         super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)

     def db_type(self, connection):

         """

         限定生成数据库表的字段类型为char，长度为max_length指定的值

         """

         return 'char(%s)' % self.max_length

Code

使用

 class Class(models.Model):

     id = models.AutoField(primary_key=True)

     # 使用自定义的char类型的字段

     name= FixedCharField(max_length=25)

Code

字段参数

参数	说明	可用字段
null	用于表示某个字段可以为空。	all
unique	如果设置为unique=True 则该字段在此表中必须是唯一的。	all
db_index	如果db_index=True 则代表着为此字段设置索引。	all
default	为该字段设置默认值。	all
auto_now_add	配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库	DateField和DateTimeField
auto_now	配置上auto_now=True，每次更新数据记录的时候会更新该字段。	DateField和DateTimeField

关系字段

ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

to

设置要关联的表
to_field

设置要关联的表的字段

related_name

反向操作时，使用的字段名，用于代替原反向查询时的'表名_set'。

 # 班级

 class Classes(models.Model):

     name = models.CharField(max_length=32)

 # 学生

 class Student(models.Model):

     name = models.CharField(max_length=32)

     theclass = models.ForeignKey(to="Classes")

 # 当我们要查询某个班级关联的所有学生（反向查询）时，我们会这么写：

 models.Classes.objects.first().student_set.all()

 # 当我们在ForeignKey字段中添加了参数related_name后：

 class Student(models.Model):

     name = models.CharField(max_length=32)

     theclass = models.ForeignKey(to="Classes", related_name="students")

 # 当我们要查询某个班级关联的所有学生（反向查询）时，我们会这么写：

 models.Classes.objects.first().students.all()

例：

related_query_name

反向查询操作时，使用的连接前缀，用于替换表名。

on_delete

当删除关联表中的数据时，当前表与其关联的行的行为。

值	说明
models.CASCADE	删除关联数据，与之关联也删除
models.DO_NOTHING	删除关联数据，引发错误IntegrityError
models.PROTECT	删除关联数据，引发错误ProtectedError
models.SET_NULL	删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
models.SET_DEFAULT	删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
models.SET	删除关联数据， a. 与之关联的值设置为指定值，设置：models.SET(值)。 b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)。 def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id"， on_delete = models.SET(func) ) 例：

db_constraint

是否在数据库中创建外键约束，默认为True。

OneToOneField

一对一字段。通常用来扩展已有字段。

一对一的关联关系多用在当一张表的不同字段查询频次差距过大的情况下，将本可以存储在一张表的字段拆开放置在两张表中，然后将两张表建立一对一的关联关系。
```
 class Author(models.Model):

     name = models.CharField(max_length=32)

     info = models.OneToOneField(to='AuthorInfo')

 class AuthorInfo(models.Model):

     phone = models.CharField(max_length=11)

     email = models.EmailField()
```
例：
- to
  
  设置要关联的表。
- to_field
  
  设置要关联的字段。
- on_delete
  
  同ForeignKey字段。

ManyToManyField

用于表示多对多的关联关系。在数据库中通过第三张表来建立关联关系。

to

设置要关联的表。
related_name

同ForeignKey字段。
related_query_name

同ForeignKey字段。

symmetrical

仅用于多对多自关联时，指定内部是否不创建反向操作的属性（表名_set）。默认为True（不创建）。

 class Person(models.Model):

     name = models.CharField(max_length=16)

     friends = models.ManyToManyField("self")

 # 此时，person对象就没有person_set属性。

 class Person(models.Model):

     name = models.CharField(max_length=16)

     friends = models.ManyToManyField("self", symmetrical=False)

 # 此时，person对象现在就可以使用person_set属性进行反向查询。

例：

through

在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系。但我们也可以手动创建第三张表来管理多对多关系，此时就需要通过through来指定第三张表的表名。
through_fields

设置关联的字段。
db_table

默认创建第三张表时，数据库中表的名称。

创建多对多关系的三种方式

 class Book(models.Model):

     title = models.CharField(max_length=32, verbose_name="书名")

 class Author(models.Model):

     name = models.CharField(max_length=32, verbose_name="作者姓名")

 # 自己创建第三张表，分别通过外键关联书和作者

 class Author2Book(models.Model):

     author = models.ForeignKey(to="Author")

     book = models.ForeignKey(to="Book")

     class Meta:

         unique_together = ("author", "book")

方式一：自行创建第三张表

 class Book(models.Model):

     title = models.CharField(max_length=32, verbose_name="书名")

 # 通过ORM自带的ManyToManyField自动创建第三张表

 class Author(models.Model):

     name = models.CharField(max_length=32, verbose_name="作者姓名")

     books = models.ManyToManyField(to="Book", related_name="authors")

方式二：通过ManyToManyField自动创建第三张表

 class Book(models.Model):

     title = models.CharField(max_length=32, verbose_name="书名")

 # 自己创建第三张表，并通过ManyToManyField指定关联

 class Author(models.Model):

     name = models.CharField(max_length=32, verbose_name="作者姓名")

     books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))

     # through_fields接受一个2元组（'field1'，'field2'）：

     # 其中field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。

 class Author2Book(models.Model):

     author = models.ForeignKey(to="Author")

     book = models.ForeignKey(to="Book")

     class Meta:

         unique_together = ("author", "book")

方式三：设置ManyTomanyField并指定自行创建的第三张表

注意：当我们需要在第三张关系表中存储额外的字段时，就要使用第三种方式。但是当我们使用第三种方式创建多对多关联关系时，就无法使用set、add、remove、clear方法来管理多对多的关系了，需要通过第三张表的model来管理多对多关系。

元信息

ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:

db_table

ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。
index_together

联合索引。
unique_together

联合唯一索引。
ordering

指定默认按什么字段排序。只有设置了该属性，我们查询到的结果才可以被reverse()。

操作

一般操作

常用函数

函数	说明	返回值
all()	查询所有结果。	QuerySet
filter(**kwargs)	它包含了与所给筛选条件相匹配的对象。	QuerySet
get(**kwargs)	返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。	单个对象
exclude(**kwargs)	它包含了与所给筛选条件不匹配的对象。	QuerySet
values(*field)	返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列。	特殊的QuerySet
values_list(*field)	它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列。	特殊的QuerySet
order_by(*field)	对查询结果排序。	QuerySet
reverse()	对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。	QuerySet
distinct()	从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)	QuerySet
count()	返回数据库中匹配查询(QuerySet)的对象数量。	integer
first()	返回第一条记录。	单个对象
last()	返回最后一条记录。	单个对象
exists()	如果QuerySet包含数据，就返回True，否则返回False	boolean

双下划线

 models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

 models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据

 models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

 models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的

 models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

 models.Tb1.objects.filter(id__range=[1, 3])      # id范围是1到3的，等价于SQL的bettwen and

 类似的还有：startswith，istartswith, endswith, iendswith　

 date字段还可以：

 models.Class.objects.filter(first_day__year=2017)

Code

ForeignKey操作

正向

查找对象

 book_obj = models.Book.objects.first()  # 第一本书对象

 print(book_obj.publisher)  # 得到这本书关联的出版社对象

 print(book_obj.publisher.name)  # 得到出版社对象的名称

Code

查找字段

 print(models.Book.objects.values_list("publisher__name"))

Code

反向

查找对象

 publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象

 books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书

 titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名

Code

查找字段

 titles = models.Publisher.objects.values_list("book__title")

Code

ManyToManyField

class RelatedManager

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：

　　外键关系的反向查询

　　多对多关联关系

简单来说就是当点(".")后面的对象可能存在多个的时候就可以使用以下的方法。

方法

create()

创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。

 import datetime

 models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())

Code

add()

添加对象，把指定的model对象添加到关联对象集中。

 author_objs = models.Author.objects.filter(id__lt=3)

 models.Book.objects.first().authors.add(*author_objs)

 # 直接用id关联

 models.Book.objects.first().authors.add(*[1, 2])

Code

set()

更新model对象的关联对象。

 book_obj = models.Book.objects.first()

 book_obj.authors.set([2, 3])

Code

remove()

从关联对象集中移除执行的model对象。

 book_obj = models.Book.objects.first()

 book_obj.authors.remove(3)

Code

clear()

从关联对象集中移除一切对象。

 book_obj = models.Book.objects.first()

 book_obj.authors.clear()

Code

注意
1. 对于通过ForeignKey关联的对象，clear()和remove()方法仅在null=True时存在。
2. 对于所有类型的关联字段，即使不调用save()方法，执行add()、create()、remove()、clear()和set()也会马上更新数据库。

查询

现有模型及其数据信息如下：

 from django.db import models

 class Press(models.Model):

     '''

     出版社

     '''

     id = models.AutoField(primary_key=True)

     name = models.CharField(max_length=50, unique=True)

 class Book(models.Model):

     '''

     书籍

     '''

     id = models.AutoField(primary_key=True)

     name = models.CharField(max_length=50, unique=True)

     price = models.DecimalField(max_digits=5, decimal_places=2)

     stock = models.IntegerField()

     saleNumber = models.IntegerField()

     press = models.ForeignKey(Press)

模型

Press表：


Book表：

数据

聚合和分组

聚合

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

 # 聚合

 from django.db.models import Avg, Max, Min, Count

 print(models.Book.objects.all().aggregate(Avg('price'), Max('price'), Min('price'),Count('id')))

 '''

 result:

     {'price__avg': 44.713333, 'price__max': Decimal('65.30'), 'price__min': Decimal('32.54'), 'id__count': 3}

 '''

例：

分组

使用annotate()函数,对应数据库中的'group by'语句。

 # 查询每个出版社（Press）拥有的书籍（Book）数量

 from django.db.models import Count

 press_list = models.Press.objects.all().annotate(book_count=Count('book'))

 [print(press_info, '出版社名称：{}，书籍数量：{}'.format(press_info.name, press_info.book_count)) for press_info in press_list]

 '''

 result:

     Press object 出版社名称：长江出版社，书籍数量：2

     Press object 出版社名称：电子工业出版社，书籍数量：1

     Press object 出版社名称：清华大学出版社，书籍数量：0

 '''

 # values

 press_list = models.Press.objects.all().annotate(book_count=Count('book')).values('name', 'book_count')

 [print(press_info) for press_info in press_list]

 '''

 result:

     {'name': '长江出版社', 'book_count': 2}

     {'name': '电子工业出版社', 'book_count': 1}

     {'name': '清华大学出版社', 'book_count': 0}

 '''

 # value_list

 press_list = models.Press.objects.all().annotate(book_count=Count('book')).values_list('name', 'book_count')

 [print(press_info) for press_info in press_list]

 '''

 result:

     ('长江出版社', 2)

     ('电子工业出版社', 1)

     ('清华大学出版社', 0)

 '''

例：

F和Q

F查询

from django.db.models import F

1、原来的filter只是单个字段和具体值之间的比较，使用F函数可以实现两个字段值之间的比较。

 # 查询库存数量大于销售数量的书籍

 [print(book.name) for book in models.Book.objects.all().filter(stock__gt=F('saleNumber'))]

 '''

 result:

     django深入解析

     spring源码解析

 '''

 # 操作字符串

 # 给每本书名后加上“当当网出售”

 from django.db.models.functions import Concat

 from django.db.models import Value

 models.Book.objects.update(name=Concat('F("name")', Value("当当网出售")))

 # result:

python框架之Django(5)-O/RM

例：

2、F对象也支持使用算数运算：

list.filter(bread__gte=F('bcommet') * 2)

例：

3、F对象中还可以写作“模型类__列名”进行关联查询：

list.filter(isDelete=F('heroinfo__isDelete'))

例：

4、对于date/time字段，可与timedelta()进行运算：

list.filter(bpub_date__lt=F('bpub_date') + timedelta(days=1))

例：

Q查询

from django.db.models import Q

1、filter() 等方法中的关键字参数查询都是一起进行“AND” 的。如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。

# 查询卖出数量大于10 或 价格小于50的书籍 且名字里包含‘spring’的书籍

[print(book.name) for book in

 models.Book.objects.filter(Q(saleNumber__gt=10) | Q(price__lt=50), name__contains='spring')]

'''

result:

    spring源码解析当当网出售

'''

例：

注意：同时具有字段查询和Q查询时，字段查询必须放在Q查询后面。

2、Q对象包括AND关系和OR关系，可以用&和|运算符进行连接。当以某个运算符连接两个Q对象时，就会产生一个新的Q 对象。如：下面这段语句就产生了一个Q，这是用 "OR" 关系连接：

Q(question__startswith='Who') | Q(question__startswith='What')

例：

3、每种查询函式（比如 filter(), exclude(), get()）除了能接收关键字参数以外，也能以位置参数的形式接受一个或多个 Q 对象。如果你给查询函式传递了多个 Q 对象，那么它们彼此间都是 "AND" 关系。例如：

Poll.objects.get(

    Q(question__startswith='Who'),

    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))

)

例：

4、也可以通过Q对象的children属性拼凑查询条件，传入条件进行查询：

q1 = Q()

q1.connector = 'OR'              # 连接方式 还有 'AND'

q1.children.append(('id', 1))

q1.children.append(('id', 2))

q1.children.append(('id', 3))

models.Tb1.objects.filter(q1)

例：

5、还可以将多个Q对象合并成一个Q对象进行查询：

con = Q()

q1 = Q()

q1.connector = 'OR'

q1.children.append(('id', 1))

q1.children.append(('id', 2))

q1.children.append(('id', 3))

q2 = Q()

q2.connector = 'OR'

q2.children.append(('status', '在线'))

con.add(q1, 'AND')

con.add(q2, 'AND')

models.Tb1.objects.filter(con)

例：

扩展

事务操作

 try:

     from django.db import transaction

     with transaction.atomic():

         new_publisher = models.Publisher.objects.create(name="火星出版社")

         models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社id

 except Exception as e:

     print(str(e))

Code

执行原生Sql

extra

结果集修改器，一种提供额外查询参数的机制。

 # 查询所有用户，并多查询出年龄是否大于20的一列

 list = UserInfo.objects.all().extra(select={'gt20': 'age>20'})

 [print(u.gt20) for u in list]

 '''

 result:

     1

     1

     0

 '''

 # 查询年龄大于20的用户

 list = UserInfo.objects.all().extra(where=['age>20'])

 # 等价于

 list = UserInfo.objects.filter(age__gt=20)

例：

raw

执行原始sql并返回模型实例。
```
 list = UserInfo.objects.raw('select * from UserInfo')

 [print(i.name) for i in list]
```
例：
惰性查询，返回rawQuerySet，只有在使用时才会真正执行。

cursor

直接执行自定义Sql(这种方式完全不依赖model,前两种还是要依赖于model)。

 from django.db import connection

 cursor = connection.cursor()

 # 插入操作

 cursor.execute("insert into UserInfo(name,age) values('郭敬明','99')")

 # 更新操作

 cursor.execute("update UserInfo set name='张三' where name='张大三'")

 # 删除操作

 cursor.execute("delete from UserInfo where name='张三'")

 # 查询操作

 cursor.execute('select * from UserInfo')

 for u in cursor: print(u)

 user_list = cursor.fetchall()  # 读取所有

 for u in user_list: print(u)

 '''

 result:

     (1, '张三', 21)

     (2, '李四', 23)

     (3, '王五', 19)

     (4, '赵六', 40)

 '''

例：

查询指定列之only&defer

现有如下模型：

class User(models.Model):

    nick_name = models.CharField(max_length=32)

    age = models.IntegerField()

模型

首先我们是知道 queryset.values 和 queryset.values_list 方法都是查询模型中指定字段，但是它们返回值的数据结构是不同的。如下：

print(models.User.objects.values('nick_name', 'age'))

# <QuerySet [{'nick_name': 'zhangsan', 'age': 12}, {'nick_name': 'lisi', 'age': 32}, {'nick_name': 'wangwu', 'age': 23}]>

print(models.User.objects.values_list('nick_name', 'age'))

# <QuerySet [('zhangsan', 12), ('lisi', 32), ('wangwu', 23)]>

可以看到，前者返回的是放着字典的 queryset ，而后者返回是放着元组的 queryset 。下面再看一下 queryset.only 方法：

queryset.only

print(models.User.objects.only('nick_name'))

# (0.000) SELECT "api_user"."id", "api_user"."nick_name" FROM "api_user"  LIMIT 21; args=()

# <QuerySet [<User: User object (1)>, <User: User object (2)>, <User: User object (3)>]>

从 console 打印的 sql 可以看到， queryset.only 除了查询指定列还默认查询了主键，而返回值是对应模型对象。再看下面代码：

user_set = models.User.objects.only('nick_name')

for user in user_set:

    print(user.age)

'''

12

32

23

(0.000) SELECT "api_user"."id", "api_user"."nick_name" FROM "api_user"; args=()

(0.000) SELECT "api_user"."id", "api_user"."age" FROM "api_user" WHERE "api_user"."id" = 1; args=(1,)

(0.000) SELECT "api_user"."id", "api_user"."age" FROM "api_user" WHERE "api_user"."id" = 2; args=(2,)

(0.000) SELECT "api_user"."id", "api_user"."age" FROM "api_user" WHERE "api_user"."id" = 3; args=(3,)

'''

可以看到，当我们使用 only 中未指定的列时，这个列会即时加载。

queryset.defer

queryset.defer 与上面的 queryset.only 方法正好相反，它是用来查询除指定列之外的字段。如下：

user_set = models.User.objects.defer('nick_name')

for user in user_set:

    print(user.age)

    print(user.nick_name)

'''

(0.000) SELECT "api_user"."id", "api_user"."age" FROM "api_user"; args=()

(0.000) SELECT "api_user"."id", "api_user"."nick_name" FROM "api_user" WHERE "api_user"."id" = 1; args=(1,)

(0.000) SELECT "api_user"."id", "api_user"."nick_name" FROM "api_user" WHERE "api_user"."id" = 2; args=(2,)

(0.000) SELECT "api_user"."id", "api_user"."nick_name" FROM "api_user" WHERE "api_user"."id" = 3; args=(3,)

'''