Django学习笔记（18）ORM之外键操作

外键操作（非自关联类型）

　　定义User和Project表结构

class User(BaseModel):
    '''用户表'''
    phone = models.CharField(verbose_name='手机号', max_length=11, unique=True)
    email = models.EmailField(verbose_name='邮箱', max_length=25, unique=True)
    password = models.CharField(verbose_name='密码', max_length=32)
    username = models.CharField(verbose_name='账号', max_length=20)

class Project(BaseModel):
    '''项目表'''
    name = models.CharField(verbose_name='项目名', max_length=20, unique=True)
    desc = models.CharField(verbose_name='描述', max_length=200, null=True, blank=True)
    host = models.CharField(verbose_name='域名', max_length=1024)
    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, db_constraint=False, verbose_name='创建者')

表操作

#Project表添加数据
# user_obj = models.User.objects.get(id=1)
# data = {
#     "name":"外键练习",
#     "desc":"描述",
#     "host":"http://127.0.0.1:8000",
#     "user":user_obj
# }
# models.Project.objects.create(**data)


#外键查询
# 正向：A表通过外键主动关联B表（A添加B外键），从A表开始查B表数据，则为正向，即project表添加了user表外键
# 反向：A表通过外键主动关联B表，从B表开始查A表数据，则为反向，即user表被project通过外键关联
# 简单记忆：从有ForeignKey定义的表查没ForeignKey定义的表数据，则为正向；反之，则为反向

#正向查询,通过项目对象查询用户
# project_obj = models.Project.objects.get(id=2)
# print(project_obj.user.username)

# 反向查询,通过用户反查项目
# u_obj = models.User.objects.get(id=1)
# print(u_obj.project_set.all()) # set用法：'小写表名'+'_set'


#外键删除项目，由于models中on_delete=models.DO_NOTHING,db_constraint=False,所以项目和用户相互独立
# models.Project.objects.get(id=2).delete()

#反向删除，通过user反查，删除用户下所有的项目
# u_obj = models.User.objects.get(id=1)
# u_obj.project_set.all().delete()

外键操作（自关联类型）

 　　用例表，A用例和B用例存在依赖关系，

　　Case表结构

class Case(BaseModel):
    '''用例表'''
    title = models.CharField(verbose_name='用例名称', max_length=20, unique=True)
    method_choice = (
        (1, 'POST'),
        (2, 'GET'),
        (3, 'DELETE'),
        (4, 'PUT')
    )
    method = models.SmallIntegerField(choices=method_choice, verbose_name='请求方式')
    cache_field = models.CharField(verbose_name='缓存字段', max_length=128, null=True, blank=True)
    check = models.CharField(verbose_name='校验点', max_length=512)
    params = models.CharField(verbose_name='请求参数', max_length=2048, null=True, blank=True)
    headers = models.CharField(verbose_name='请求头信息', max_length=2048, null=True, blank=True)
    is_json = models.BooleanField(verbose_name='参数是否是json', default=False)
    json = models.CharField(verbose_name='json类型参数', max_length=2048, null=True, blank=True)
    status_choice = (
        (1, '通过'),
        (2, '未运行'),
        (3, '运行中'),
        (999, '失败')
    )
    status = models.SmallIntegerField(choices=status_choice, verbose_name='用例状态',
                                      default=2)  # 记录上一次的状态，每次执行后需要更新这个表的字段
    report_batch = models.CharField(verbose_name='最后一次执行的批次号', null=True, max_length=512, blank=True)

　　

表操作

#外键还有一种使用方式，自关联  自己和自己关联，比如：A用例和B用例关联，数据都在case表中
#Case表创建case数据
# data = {
#     "title":"用例2",
#     "method":"2",
#     "check":"code=0",
# }
# models.Case.objects.create(**data)

#创建自关联数据
# models.CasePremise.objects.create(case_id=1,premise_case_id=2)#直接操作自关联表传入id即可

#查询
# case_obj = models.Case.objects.get(id=1)#获取id为1 的用例信息
# #查出id为1的用例所依赖的用例信息
# qs = case_obj.case.all()
# #all()返回的是一个列表的queryset,case指CasePremise表(通过related_name='case'),即反向查询
# for item in qs:
#     #item 是CasePremise 依赖数据的对象
#     print(item.case.title) #通过CasePremise表中的case外键关联到case表，再取title,即正向查询
#     print(item.premise_case.id)

多对多操作

　　用例case表和用例集合表case_collection表存在多对多关系，case用例表上方已定义

　　ManyToMany类型， Django会自动创建一张表case_collection_case表，存入用例id字段(case_id)和集合id字段(collection_id)

　　用例集合case_collection表结构：

class CaseCollection(BaseModel):
    '''用例集合'''
    name = models.CharField(verbose_name='集合名称', max_length=20, unique=True)
    desc = models.CharField(verbose_name='描述', max_length=200, null=True, blank=True)
    user = models.ForeignKey(User, on_delete=models.DO_NOTHING, db_constraint=False, verbose_name='创建者')
    project = models.ForeignKey(Project, on_delete=models.DO_NOTHING, db_constraint=False, verbose_name='归属项目')
    report_batch = models.CharField(verbose_name='最后一次执行的批次号', null=True, max_length=512, blank=True)
    status_choice = (
        (2, '未运行'),
        (3, '运行中'),
        (4, '执行完毕')
    )
    status = models.SmallIntegerField(choices=status_choice, verbose_name='用例状态',
                                      default=2)  # 记录上一次的状态，每次执行后需要更新这个表的字段
    case = models.ManyToManyField(Case, verbose_name='集合下的用例')

表操作

#多对多
#   用例集合和用例是多对多关系
#   A集合 和 B集合
#   A用例 和 B用例
#   A集合 --  A用例 B用例
#   B集合 --  A用例 B用例
#   ManyToMany

# 先获取到用例集合和用例的信息
case_obj_A = models.Case.objects.get(id=1) # 获取用例A
case_obj_B = models.Case.objects.get(id=2) # 获取用例B
coll_obj = models.CaseCollection.objects.get(id=1) # 获取集合

# 通过集合中的case字段进行多对多的创建(实际就是向case_collection_case表添加数据)
# add 可以接收用例的id，也可以是用例的对象
coll_obj.case.add(case_obj_A)
coll_obj.case.add(case_obj_B)

# 删除多对多关系
coll_obj.case.clear() # 清除集合有关的所有用例
coll_obj.case.remove(1) # 清除集合和用例id为1的关系
coll_obj.case.remove(case_obj_A) # 也支持 传入用例的对象

#重置多对多关系
coll_obj.case.set([1,2]) # 列表方式接受用例id,将用例id为1和2的和集合建立关系

#查询多对多关系
#正向查询
coll_obj.case.all() # 获取这个集合的所有的用例

#反向查询
case_obj_A.casecollection_set.all() # 这个用例所在的全部集合