• 1.建立單表模型類
• 2.ORM基本操作
• 3.建立一對多，多對多模型類
• 4.一對多的正、反查詢
• 5..多對多表操作

1.建立單表模型類

class Goods(models.Model):
    goods_name = models.CharField(max_length=32)
    goods_price = models.DecimalField(max_digits=9,decimal_places=2)
    goods_num = models.IntegerField()

    class Meta:
        db_table = 'tb_goods'

2.ORM基本操作

class ORMView(APIView):
    def get(self,request):
        # 單一查詢，如果結果不存在報錯
        goodsobj = Goods.objects.get(goods_price=6.66)
        obj = GoodsSerializers(goodsobj)
        return Response(obj.data)


        # 查詢不包含id=3的資料
        goodsobj = Goods.objects.exclude(id=3)
        obj = GoodsSerializers(goodsobj, many=True)
        return Response(obj.data)


        # 查詢結果的數量
        goodsobj = Goods.objects.all().count()
        return Response(goodsobj)


        #   聚合函式　　使用aggregate()過濾器呼叫聚合函式。
        #   聚合函式包括：Avg 平均，Count 數量，Max 最大，Min 最小，Sum 求和      
        #   需要導包    from django.db.models import *
        goodsobj = Goods.objects.aggregate(Sum('goods_num'))
        print(goodsobj)
        # obj = GoodsSerializers(goodsobj, many=True)
        return Response({'data':''})



        #   比較查詢　　欄位名__lt：小於    欄位名__lte：小於等於
        goodsobj = Goods.objects.filter(id__lt=4)
        obj = GoodsSerializers(goodsobj, many=True)
        return Response(obj.data)


        #   比較查詢　　欄位名__gt：大於    欄位名__gte：大於等於
        goodsobj = Goods.objects.filter(id__gte=2)
        obj = GoodsSerializers(goodsobj, many=True)
        return Response(obj.data)


        #  　空查詢　　欄位名__isnull
        goodsobj = Goods.objects.filter(goods_name__isnull=False)
        obj = GoodsSerializers(goodsobj, many=True)
        return Response(obj.data)


        #   模糊查詢　欄位名__endswith　以　莓　結尾的資料
        goodsobj = Goods.objects.filter(goods_name__endswith='莓')
        obj = GoodsSerializers(goodsobj, many=True)
        return Response(obj.data)


        #   模糊查詢　欄位名__tartswith　以　蘋　開頭的資料
        goodsobj = Goods.objects.filter(goods_name__startswith='蘋')
        obj = GoodsSerializers(goodsobj,many=True)
        return Response(obj.data)

        #   模糊查詢　欄位名__contains　包含　果　的的資料
        goodsobj = Goods.objects.filter(goods_name__contains='果')
        obj = GoodsSerializers(goodsobj,many=True)
        return Response(obj.data)


        # 範圍查詢:  in  只查詢列表中的具體值
        goodsobj = Goods.objects.filter(goods_price__in=[12,25,6.66]).all()
        obj = GoodsSerializers(goodsobj,many=True)
        return Response(obj.data)

        # 範圍查詢:  range １～２０之間
        goodsobj = Goods.objects.filter(goods_price__range=[1,20]).all()
        obj = GoodsSerializers(goodsobj,many=True)
        return Response(obj.data)
 

3.建立一對多，多對多模型類

# 電影
class Movie(models.Model):
    movie_name = models.CharField(max_length=32)
    class Meta:
        db_table = 'tb_movie'


# 角色
class Role(models.Model):
    role_name = models.CharField(max_length=32)
    role_price = models.DecimalField(max_digits=9, decimal_places=2)
    role_desc = models.CharField(max_length=32)

    class Meta:
        db_table = 'tb_role'


# 演員
class Actor(models.Model):
    name = models.CharField(max_length=32)
    address = models.CharField(max_length=32, null=True, blank=True)
    age = models.IntegerField(null=True,blank=True)
    phone = models.CharField(max_length=32, null=True, blank=True)
    movie = models.ForeignKey(Movie, on_delete=models.CASCADE)
    role = models.ManyToManyField(Role)

    class Meta:
        db_table = 'tb_actor'
 

4.一對多的正、反查詢

class ORMView(APIView):
    def get(self,request):
        #   一對多　正向查詢      物件．模型名．欄位
        actorobj = Actor.objects.get(id=1)
        movieo = actorobj.movie.movie_name
        print(movieo)
        return Response('ok')

        #   一對多　反向查詢      物件．模型名_set
        movieobj = Movie.objects.get(id=1)
        actorobj = movieobj.actor_set.all()
        obj = ActorSerializers(actorobj,many=True)
        print(obj.data)
        return Response(obj.data)

5..多對多表操作

class ORMview2(APIView):
    def post(self,request):
        # 多對多新增
        # 方法一：在建立manytomany的models裡新增資料，（一條，一個物件）
        actor = Actor.objects.get(id=5)
        role = Role.objects.get(id=5)

        data = actor.role.add(role)
        print(data)
        return Response('ok')

        # 方法二：在未建立manytomany的models裡新增資料，（一條，一個物件）
        actor = Actor.objects.filter(name='張譯')
        role = Role.objects.get(id=5)

        data = role.actor_set.add(*actor)
        print(data)
        return Response('ok2')


    def put(self,request):
        # 多對多更新
        # 方法一：在建立manytomany的models裡修改資料，引數只能是可迭代物件
        actorobj = Actor.objects.filter(id=5).first()
        roleobj = Role.objects.filter(id=4)

        actorobj.role.set(roleobj)
        return Response('ok')

        # 方法二：在未建立manytomany的models裡修改資料，引數只能是可迭代物件
        actorobj = Actor.objects.filter(id=5)
        roleobj = Role.objects.filter(id=5).first()

        roleobj.actor_set.set(actorobj)
        return Response('ok2')


    def delete(self,request):
        # 方法一：在建立manytomany的models裡刪除資料，（一條，一個物件）
        autorobj = Actor.objects.get(id=5)
        roleobj =Role.objects.get(id=5)

        autorobj.role.remove(roleobj)
        return Response('ok')

        # 方法二：在未建立manytomany的models裡刪除資料，（一條，可迭代物件）
        autorobj = Actor.objects.get(id=5)
        roleobj = Role.objects.get(id=5)

        roleobj.actor_set.remove(autorobj)
        return Response('ok2')