Django---orm多表操作

关注

原创最新推荐文章于 2026-05-31 09:25:44 发布 5.3k 阅读 AI 写同款· GEO 优化 ›

Django数据库连表查询（一对一、一对多、多对多） 1、一对一关系比如某班级学生表和学生详细信息表两张表结构如下 class Student(models.Model): stu_id = models.AutoField(primary_key=True) stu_name = models.CharField(max_length=32) class Stud... 阅读详情

0. 对于ForeignKey的使用

0.1 概念

有ForeignKey的表成为子表，对应没有ForeignKey的表称为主表

0.2 方法

直接使用values或values_list得到数据

filter和values以及values_list中字段的使用按照以下规则

主表中使用自己的字段直接使用，如果使用子表字段按照子表小写表名__字段名称

子表中使用自己的字段直接使用，如果使用主表字段按照外键名__主表字段名称的格式使用主表字段。

先获取对象再通过对象获取数据

filter中字段名的使用与上一条所述相同，区别在于使用first()或all()得到对象后通过对象得到数据的方法

主表对象查询子表

如果主表得到的对象为f，子表表名为Son，那么获取子表数据的方法有一下几种

f.son_set.all()
f.son_set.first()
f.son_set.values()
f.son_set.values_list()

子表对象查询主表

如果子表对象为s，子表中对应主表的外键为fk_father，那么可以使用s.fk_father得到主表对象，通过主表对象可以得到主表中的各个数据。

1. 一对一

一对一有两种实现方式分别是ForeignKey+unique=True以及OneToOneField

使用ForeignKey的方式与上述ForeignKey的使用方一样，使用OneToOneField有别于ForeignKey的地方在于，通过主表对象查询子表时不需要使用_set，可以直接使用子表名获取子表对象

举例说明w.blog_set.first().site和w.blog.site得到的结果是一样的，前者使用ForeignKey后者使用OneToOneField。

2. 一对多

通过外键建立一对多的关系

class UserGroup(models.Model):
    title = models.CharField(max_length=32)

class UserInfo(models.Model):
    user = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    age = models.IntegerField(default=0)

    fk_ug = models.ForeignKey('UserGroup', null=True)

得到的表如下所示：

# UserGroup
id|title
1 |r&d
2 |sales
3 |financial

# UserInfo
id|user|age|fk_ug_id|password|
1 |Jack|18 |1       |123
2 |Mike|28 |2       |123
3 |Dick|34 |3       |123
4 |Kate|23 |1       |123
5 |Zake|25 |1       |123

2.1 子表查询主表

先获取子表对象再查询数据

filter中如果使用子表字段可以直接使用，如果使用主表字段获取子表对象，需要使用外键名__主表字段的格式来获取子表对象

查询子表数据通过子表对象调用子表中的外键然后查询主表数据，查询格式子表对象.外键字段名.主表字段名

v = models.UserInfo.objects.filter(id=1).first()
    print(v.user, v.password, v.age, v.fk_ug.title)

直接使用values跨表查询数据

在values中直接使用外键名实现跨表查询数据，查询格式外键字段名__主表字段名

ret = models.UserInfo.objects.all().values('id', 'user', 'fk_ug__title')
    for item in ret:
        print(item['id'], item['user'], item['fk_ug__title'])
"""
1 Jack r&d
2 Mike sales
3 Dick financial
4 Kate r&d
5 Zake r&d

"""

上面两种方法都可以实现跨表查询，但是第一种每查询一次都要操作一次数据库，二第二种只操作一次数据库，拿到所有数据。

2.2 主表查询子表

先获取主表对象再查询数据

filter中如果使用主表字段直接使用，如果使用子表字段获取主表对象需要使用子表表名__子表字段的格式

通过主表对象查询子表数据，由于主表中没有外键需要使用_set查询子表

obj = models.UserGroup.objects.filter(id=1).first()
    print(obj.userinfo_set) # singleTable.UserInfo.None
    print(obj.userinfo_set.all()) # <QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>

    for row in obj.userinfo_set.all():
        print(row.user, row.age)

    """
    Jack 18
    Kate 23
    Zake 25
    """

直接使用values跨表查询数据，由于主表中没有外键，使用子表表名跨表查询，查询格式为子表表名__子表字段名

3. 多对多

3.1 基于关系表的多对多

两张表通过第三章关系表建立多对多的关系

class Boy(models.Model):
    name = models.CharField(max_length=32)

class Girl(models.Model):
    nick = models.CharField(max_length=32)

class Love(models.Model):
    b = models.ForeignKey('Boy')
    g = models.ForeignKey('Girl')

查询与name='Jack'的男生有关系的女生，Boy中没有外键，所以使用_set反向查找

obj = models.Boy.objects.filter(name='Jack').first()
love_girls = obj.love_set.all()
for row in love_girls:
    print(row.g.nick) # 打印女生的名字

还可以直接使用关系表查询，注意b__name这种通过外键加双下滑线的使用方法

love_grils = models.Love.objects.filter(b__name='Jack') # 得到Love对象，下面没循环一次跨表一次
for row in love_girls:
    print(row.g.nick)

love_grils = models.Love.objects.filter(b__name='Jack').values('g__nick') # 得到字典，一次查询得到所有数据
for item in love_girls:
    print(item['g__nick']) # 打印女生的名字

love_grils = models.Love.objects.filter(b__name='Jack').select_related('g') # 得到对象，一次查询得到所有数据
for obj in love_girls:
    print(obj.g.nick) # 打印女生的名字

3.1.1联合唯一索引

不能出现多条相同的数据，使用联合唯一索引。通过在Meta类中设置unique_together实现，实现方法如下所示。

class Boy(models.Model):
    name = models.CharField(max_length=32)

class Girl(models.Model):
    nick = models.CharField(max_length=32)

class Love(models.Model):
    b = models.ForeignKey('Boy')
    g = models.ForeignKey('Girl')

    class Meta:
        unique_together = [
            ('b','g'),
        ]

3.2 基于ManyToManyField的多对多

Django提供了一个叫做ManyToManyField的关键字，实现两张表之间的多对多的关联关系，而不用定义第三张关系表，Django会自动生成关系表。在任意一张表中设置这个关键字都可以，具体使用方法如下所示。

class Boy(models.Model):
    name = models.CharField(max_length=32)
    m = models.ManyToManyField('Girl')

class Girl(models.Model):
    nick = models.CharField(max_length=32)

由于models中并没有定义关系表，所以无法直接操作关系表添加数据，因而需要通过定义了ManyToManyField的类的对象操作关系表，操作方法如下所示：

obj = models.Boy.objects.filter(name='Jack').first()
# 添加
obj.m.add(2)
obj.m.add(3, 4)
obj.m.add(*[1,5])
# 删除
obj.m.remove(2)
obj.m.remove(3, 4)
obj.m.remove(*[1,5])
# 重置
obj.m.set(*[1,]) # 只会剩下一条数据

该示例中使用了三种方法为关系表添加、删除、重置数据，表明添加数据可以接收三种参数。

3.2.1 数据查询

查询与有ManyToManyField的类的对象关联的数据成为正向查找，反之成为反向查找

正向查找

obj = models.Boy.objects.filter(name='Jack').first()
girl_list = obj.m.all()

通过obj.m.clear()可以删除关系表中与name='Jack'相关的所有数据

反向查找

使用_set实现反向查找

obj = models.Boy.objects.filter(name='Alice').first()
boy_list = obj.boy_set.all()

使用ManyToManyField只能生成三列，两张表的id和自己的id

3.3 自定义关系表与ManyToManyField联合使用

class Boy(models.Model):
    name = models.CharField(max_length=32)
    m = models.ManyToManyField('Girl',through="Love",through_fields=('b','g',))

class Girl(models.Model):
    nick = models.CharField(max_length=32)

class Love(models.Model):
    b = models.ForeignKey('Boy')
    g = models.ForeignKey('Girl')

    class Meta:
        unique_together = [
            ('b','g'),
        ]

相比于单独使用自定义关系表，多了查询和清空数据的功能。

相比于单独使用ManyToManyField，增加了灵活性，可以在关系表中定义更多的字段。

3.4 自关联

4. orm其它操作

4.1 排序

order_by('-id', 'name')按照id排序，如果有相同的id则按照name排序，id前的符号表名逆序拍续集。

4.2分组

首先引入模块from django.db.models import Count, Sum, Max, Min

user_list = models.UserInfo.objects.values('fk_ug_id').annotate(cnt=Count('id'))
    print(user_list.query)
    # SELECT "singleTable_userinfo"."fk_ug_id",
    # COUNT("singleTable_userinfo"."id") AS "cnt"
    # FROM "singleTable_userinfo"
    # GROUP BY "singleTable_userinfo"."fk_ug_id"

    user_list = models.UserInfo.objects.values('fk_ug_id').annotate(cnt=Count('id')).filter(cnt__gt=2)
    print(user_list.query)
    # SELECT "singleTable_userinfo"."fk_ug_id", 
    # COUNT("singleTable_userinfo"."id") AS "cnt"
    # FROM "singleTable_userinfo"
    # GROUP BY "singleTable_userinfo"."fk_ug_id"
    # HAVING COUNT("singleTable_userinfo"."id") > 2

4.3 过滤

models.UserInfo.objects.filter(id__gt=1) # 大于
models.UserInfo.objects.filter(id__gte=1) # 大于等于
models.UserInfo.objects.filter(id__lt=1) # 小于
models.UserInfo.objects.filter(id__lte=1) # 小于等于

models.UserInfo.objects.filter(id__in=[1, 3, 4]) # 是列表中的某一个

models.UserInfo.objects.filter(id__range=[1, 3]) # 在一个范围内

models.UserInfo.objects.filter(name__startswith='xxx') # 区分大小写， 以‘xxx’开头
models.UserInfo.objects.filter(name__istartswith='xxx') # 不区分大小写， 以‘xxx’开头

models.UserInfo.objects.filter(name__endswith='xxx') # 区分大小写， 以‘xxx’结尾
models.UserInfo.objects.filter(name__iendswith='xxx') # 不区分大小写， 以‘xxx’结尾

models.UserInfo.objects.filter(name__contains='xxx') # 区分大小写， 包含‘xxx’
models.UserInfo.objects.filter(name__icontains='xxx') # 不区分大小写， 包含‘xxx’

models.UserInfo.objects.exclude(name__contains='xxx') # 不包含‘xxx’

4.4 F, Q, extra

4.4.1 F

from django.db.models import F

models.UserInfo.objects.all().update(age=F("age") + 1)

# 通过F取得F中参数在数据库中对应的字段所对应的值

4.4.2 Q

用于构造复杂的查询条件

from django.db.models import Q

models.UserInfo.objects.filter(Q(nid=8) | Q(nid__gt=10))

# 取 nid = 8 或者 大于等于10

q1 = Q()
q1.connector = 'OR'
q1.children.append('id', 1)
q1.children.append('id', 10)
q1.children.append('id', 9)

q2 = Q()
q2.connector = 'OR'
q2.children.append('c1', 1)
q2.children.append('c1', 10)
q2.children.append('c1', 9)

con = Q()
con.add(q1, 'AND')
con.add(q2, 'AND')


# 相当于 （id = 1 or id = 10 or id = 9）and (c1 = 1 or c2 = 10 or c3 = 9)

Q使用实例

from django.db.models import Q

condition_dict = {
    'k1':[1, 2, 3, 4],
    'k2':[1,],
}

con = Q()

for k, v in condition_dict.items():
    q = Q()
    q.connector = 'OR'
    for i in v:
        q.children.append('id', i)
    con.add(q, 'AND')

models.UserInfo.objects.filter(con)

4.4.3 extra

通过extra实现子查询
v = models.UserInfo.objects.all().extra(select={"n": "select count(1) from app01_usertype where id>%s"}, select_params=[1,])

通过select_params给%s传参数，如果有多个参数，在列表中依次添加，按顺序调用

models.UserInof.objects.extra(
    where=["id=1", "name=Jack"],
)

models.UserInfo.objects.extra(
                    select={'newid':'select count(1) from app01_usertype where id>%s'},
                    select_params=[1,],
                    where = ['age>%s'],
                    params=[18,],
                    order_by=['-age'],
                    tables=['app01_usertype']
                )
                """
                select 
                    app01_userinfo.id,
                    (select count(1) from app01_usertype where id>1) as newid
                from app01_userinfo,app01_usertype
                where 
                    app01_userinfo.age > 18
                order by 
                    app01_userinfo.age desc
                """

4.4.4 raw sql

from django.db import connection, connections

cursor = connection.cursor() # connection=default数据
cursor = connections['db2'].cursor()

cursor.execute("""SELECT * from auth_user where id = %s""", [1])

row = cursor.fetchone()
row = cursor.fetchall()

4.4.5 连表查询

使用select_related连表查询

q = models.UserInfo.objects.all().select_related('fk_ug')
    print(q.query)

    # SELECT "singleTable_userinfo"."id",
    # "singleTable_userinfo"."user",
    # "singleTable_userinfo"."password",
    # "singleTable_userinfo"."age",
    # "singleTable_userinfo"."fk_ug_id",
    # "singleTable_usergroup"."id", 
    # "singleTable_usergroup"."title"
    # FROM "singleTable_userinfo"
    # LEFT OUTER JOIN "singleTable_usergroup"
    # ON ("singleTable_userinfo"."fk_ug_id" = "singleTable_usergroup"."id")

4.4.6 多次查询

prefetch_related

q = models.UserInfo.objects.all().prefetch_related('fk_ug')
for row in q:
    print(row.id, row.fk_ug.title)

    # 1 r & d
    # 2 sales
    # 3 financial
    # 4 r & d
    # 5 r & d
    # 6 sales

可以看出上述语句实现了跨表，但并咩有连表查询，而是使用多次查询，

首先，select * from UserInfo并统计fk_ug的种类

然后通过select * from usertype where id in [2, 4]得到usertype，然后得到最终的数据。

具体实现更复杂，这里只是阐述基本的实现原理。

通过这种方式，在数据量比较大的情况下，相比于连表提高了查询效率。

收录于