数据表关系

目录

• 数据表配置
  • 数据表关系：
    • 基表：
    • 表关联联系：
    • 外键字段属性：
    • models.py
  • 序列化检验措施：
  • 数据测试脚本：
  • 多表查询：
    • ModelSerializer多表操作：

数据表配置

数据表关系：

基表：

#基表 ：
	为抽象表，是专门用来被继承，提供公有字段的，自身不会完成数据库迁移
    
eg:
 from django.contrib.auth.models import User
 class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    created_time = models.DateTimeField(auto_now_add=True)

    class Meta:
        abstract = True  # 基表
	
class book(BaseModel):
    	pass            #继承基表字段


小结：
	mysql可视化软件NaN: 数据表关联可视化功能 ----》 el 图
	数据表存储 是按片存储 
   

表关联联系：

表关系：
	1. 表关联关系： 表与表之间通过外键彼此关联，，重构复杂
    
    2.断关联表关系：
    	不会影响连表查询操作效率
        会提升连表增删改操作效率
        易于后期数据库表的重构
        缺点在于：数据库本身没有连表检测，容易出现脏数据，需要通过严格的逻辑避免脏数据的参数（必要的时候管理脏数据）

脏数据： 删掉表内的外键字段时，与之对应表字段数据可能没有被清除

    A依赖B，先插入A记录，该记录对应的B记录没产生，在没有关联的情况下，该操作可以实现，但是数据就是脏数据
	接着再将B数据添加，脏数据就得到处理了。反过来先操作B后操作A，更满足逻辑思维，一样可以执行。通过逻辑将AB表进行  连表查询，不会有任何异常


#    外键 db_constraint属性：在外键中控制表关联，默认为True表示关联，设置False表示断开关联

外键字段属性：

表关系：
	1）A 和 B一对多：外键在多的一方 A
	2）A 和 C 多对多：外键在查询频率高的一方 A
	3）B 和 D一对一：外键要根据实际需求建立在合理的位置 D

字段属性：
	1）related_name在外键中设置外键反向查询的字段名：正向找字段名，反向找related_name值
    
    2）on_delete在外键中必须设置，表示级联关系，在Django 1.x下，系统默认提供(值为models.CASCADE)，Django 2.x下，必须手动明确
       CASCADE：默认值，级联
           
       DO_NOTHING：外键不会被级联，假设A表依赖B表，B记录删除，A表的外键字段不做任何处理
            
       SET_DEFAULT：假设A表依赖B表，B记录删除，A表的外键字段置为default属性设置的值，所以必须配合default属性使用
    例子：部门没，部门员工进入待定部门（注：部门表一定要有待定部门记录）
    
       SET_NULL：假设A表依赖B表，B记录删除，A表的外键字段置为null，所以必须配合null=True属性使用
      例子：部门没，部门员工进入未分组部门（注：关联部门表外键可以为空）
        
        注：多对多字段不能设置on_delete级联关系，默认为级联，如果要处理级联关系，需要手动明确关系表，处理关系表中的多个外键

models.py

class Book(BaseModel):
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    publish = models.ForeignKey(to='Publish', related_name='books', db_constraint=False, on_delete=models.DO_NOTHING, null=True)
    
    authors = models.ManyToManyField(to='Author', related_name='books', db_constraint=False)

    def __str__(self):
        return self.name

class Publish(BaseModel):
    name = models.CharField(max_length=64)
    address = models.CharField(max_length=64)

class Author(BaseModel):
    name = models.CharField(max_length=64)

class AuthorDetail(BaseModel):
    mobile = models.CharField(max_length=64)
    author = models.OneToOneField(to=Author, related_name='detail', db_constraint=False, on_delete=models.CASCADE)

序列化检验措施：

def post(self, request, *args, **kwargs):
    car_ser = serializers.CarModelSerializer(data=request.data)
    # 如果校验没通过，会自动抛异常反馈给前台，代码不会往下执行
    car_ser.is_valid(raise_exception=True)
    car_obj = car_ser.save()
    return Response({
        'status': 0,
        'msg': 'ok',
        'results': serializers.CarModelSerializer(car_obj).data
    })

注意：raise_exception=True  : 默认false, 手动异常反馈给前台
    						True ,  自动抛异常并结束

数据测试脚本：

#django 测试文件：

	import os, django
	os.environ.setdefault("DJANGO_SETTINGS_MODULE", "d_proj.settings")
	django.setup()

	# 对表的操作测试：
    from api.models import Book, Publish
	
	book = Book.objects.first()  # type: Book (注释：book类型)
	print(book.name)

	publish = Publish.objects.last()  # type: Publish
	publish.delete()

多表查询：

#群查
class PublishAPIView(APIView):
    def get(self, request, *args, **kwargs):
        publish_query = models.Publish.objects.all()
        publish_ser = serializers.PublishModelSerializer(publish_query, many=True)
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': publish_ser.data
        })

ModelSerializer多表操作：

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book    #子系列（获取子系列所有数据）
        fields = '__all__'

class PublishModelSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.Publish   #父系列
        # fields = '__all__' 获取所有序列化 | 反序列的数据
        fields = ['name', 'address', 'books']

小结：
	# 子序列化：
        # 1）只能在序列化中使用
        # 2）字段名必须是外键(正向反向)字段
        #   因为相对于自定义序列化外键字段，自定义序列化字段是不能参与反序列化的，而子序列化必须为外键名，所以就无法入库
        # 3）在外键关联数据是多条时，需要明确many=True
        # 4）是单向操作，因为作为子系列的类必须写在上方，所以不能产生逆方向的子序列化