ORM之单表增删改查

ORM之基本操作增删改查

　　在函数前，先导入要操作的数据库表模块，model

　　from model所在的路径文件夹 import model

在views文件中，加的路径：

#就一个app01功能的文件，在app01的文件下，在app01的views里加
from app01 import model
#在有路由分发的项目中：AutoCMDB项目里的集成所有的功能的apps文件里找到具体的功能包。
from apps.cases import model

增操作：（create）　

def index(request):
    model.UserGroup.objects.create(tilte='销售部')
    #在UserGroup表中添加title值销售部　
    model.UserInfo.objects.create(username='george',password='',usergroup_id=1)
　　 #在UserGroup表中添加username，password，age，ug_id

查操作：（all、filter）

def index(request):
　　group_list = model.UserGroup.objects.all()
　　#将UserGroup表的所有数据拿到，起别名group_list。
　　group_list = model.UserGroup.objects.filter(id=1)
　　#将UserGroup表的所有数据拿到，过滤id=1的值，并放入别名group_list中。
　　group_list = model.UserGroup.objects.filter(id__gt=1)
　　#将UserGroup表的所有数据拿到，过滤id大于1的值，并放入别名group_list中。
　  group_list = model.UserGroup.objects.filter(id__lt=1)
　　#将UserGroup表的所有数据拿到，过滤id小于1的值，并放入别名group_list中。

def index(request):
    group_list = models.UserGroup.objects.all()
    print(group_list) # 这个列表是一个QuerySet类型的列表，里面是一个个的对象，用for循环可以取到里面的值。
    #可以循环group_list里的数据，因为拿到的是列表。
    for row in group_list:
        print(row.id,row.title)

删操作：（delete）

def index(request):
    model.UserGroup.objects.filter(id=2).delete()
　　#将UserGroup表中的id=2的那列数据删除 

改操作：（update）

def index(request):
    model.UserGroup.objects.filter(id=2).update(title='技术部')
    #将UserGroup表中的id=2的那列的title的值改为技术部

 其他操作：

　　排序操作：.order_by( )

　　view的函数：

def testtest(request):
    """
    排序操作
    :param request:
    :return:
    """
    user_list = models.UserInfo.objects.all()
    user_list1 = models.UserInfo.objects.all().order_by("id")   #order_by是排序，参数是字段，比如加id字段，会按正序排列，从小到大
    user_list2 = models.UserInfo.objects.all().order_by("-id")   #加负号会按倒序排列，从大到小
    user_list3 = models.UserInfo.objects.all().order_by("-id","name")   #如果id有重复的，那么就按name进行排序，也是按从小到大，如果name也叫负号，那么也是从大到小
    print(user_list)
    print(user_list1)
    return render(request,"index.html",{"user_list":user_list,"user_list1":user_list1})

　　models的类：

class UserInfo(models.Model):
    name = models.CharField(max_length=255)
    age = models.IntegerField()
    ut = models.ForeignKey("UserType")

    def __str__(self):
        return "%s_%s" %(self.id,self.name)

　　分组操作：比如根据ut的id来进行分组，计算每组的人数。 annotate()

　　　　　　　但是分组是要加聚合条件的。

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

　　views的函数：

def testtest1(request):
    """
    分组操作
    :param request:
    :return:
    """
    from django.db.models import Count
    user_list = models.UserInfo.objects.values("ut_id").annotate(xxx=Count("id"))   # xxx就是个别名
    #这样会把ut_id一样的分为一类
    print(user_list.query) #用.query是打印查看user_list生成的SQL语句　　　　

　　生成的SQL语句：

　　如果是加条件的话views函数是：

def testtest1(request):
    """
    分组操作
    :param request:
    :return:
    """
    from django.db.models import Count
    user_list = models.UserInfo.objects.values("ut_id").annotate(xxx=Count("id")).filter(xxx__gt=2)
    #这样依旧可以加条件，条件的参数可以写实例中的别名大于2的值，在SQL中就是having操作。
　　
　　 print(user_list.query) #用.query是打印查看user_list生成的SQL语句

　　 return HTTPResponse("...") 

　　加filter条件的SQL：

　　filter 在前和在后是不一样的，在前的话或找不到xxx别名的参数，但他可以找到Count("id") 的id。

　　filter 在前表示是where条件。filter前后都有，就先进行一次筛选出需要的数据，在进程分组，最后在进行一次筛选。

def testtest1(request):
    """
    分组操作
    :param request:
    :return:
    """
    from django.db.models import Count

    user_list = models.UserInfo.objects.filter(id__gt=2).values("ut_id").annotate(xxx=Count("id")).filter(xxx__gt=2)
    #第一个filter先进行id大于2的筛选，然后在根据ut_id进行分组，分完组根据Count 的id 进行大于2的筛选。
    print(user_list.query) #用.query是打印查看user_list生成的SQL语句

　　其他操作：

    models.UserInfo.objects.filter(id__lte=1) # lte和gte 分别是小于等于和大于等于
    models.UserInfo.objects.filter(id__gte=1) # lte和gte 分别是小于等于和大于等于
    models.UserInfo.objects.filter(id__in=[1,2,3]) # in 就必须传一个列表， 这是条件id在1，2，3里面的
    models.UserInfo.objects.filter(id__range=[1,3]) # range是一个范围
    models.UserInfo.objects.filter(name__startswith="xxx")
    models.UserInfo.objects.filter(name__contains="xxx") #包含xxx的数据

    #exclude是排除，除它以外的。
    models.UserInfo.objects.exclude(id=1) # id不等于1

1. 增
    create(name='xx',age='xx'.....)
    dic={name"xxx,age}
    create(**dic)

2. 更新
    models.xx.objects.filter(id=1).update(a=1,b=2)

    models.xx.objects.filter(id=1).update(**dic)

3. 查询
    models.xx.objects.filter(id=1,xxx)
    models.xx.objects.filter(**{'id':1,'name':'alex'})

PS: Django帮助我们数据转换 -> 字典  =》 Form组件（用户请求规则验证+数据字典）

select_related 和 prefetch_related：

        ====================================================
        # q = models.UserInfo.objects.all()
        # select * from userinfo
        # select * from userinfo inner join usertype on ...
        # for row in q:
        #     print(row.name,row.ut.title)

       # select_related: 查询主动做连表
         q = models.UserInfo.objects.all().select_related('ut','gp')
        # select * from userinfo
        # select * from userinfo inner join usertype on ...
         for row in q:
             print(row.name,row.ut.title)

       # prefetch_related: 不做连表，做多次查询
         q = models.UserInfo.objects.all().prefetch_related('ut')
        # select * from userinfo;
        # Django内部：ut_id = [2,4]
        # select * from usertype where id in [2,4]
         for row in q:
             print(row.id,row.ut.title)

        ====================================================
        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')
       
        =====================================================     

        # 1. 和george有关系的姑娘
        # obj = models.Boy.objects.filter(name='george').first()
        # love_list = obj.love_set.all()
        # for row in love_list:
        #     print(row.g.nick)
        #
        #
        # love_list = models.Love.objects.filter(b__name='george')
        # for row in love_list:
        #     print(row.g.nick)
        #
        # love_list = models.Love.objects.filter(b__name='george').values('g__nick')
        # for item in love_list:
        #     print(item['g__nick'])
        #
        # love_list = models.Love.objects.filter(b__name='george').select_related('g')
        # for obj in love_list:
        #     print(obj.g.nick)

        1. ManyToManyField
　　　　　　　　可以创建一个第三张表

        2. 自定义关系表

        3. 杂交

            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)
                # m = models.ManyToManyField('Boy')

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

                class Meta:
　　　　　　　　　　　　"""
　　　　　　　　　　　　联合唯一索引：unique_together 使b和g的相同的id组合只能出现一次
　　　　　　　　　　　　"""
                    unique_together = [
                        ('b','g'),
                    ]
                    

　　关于更多models操作，借鉴url：www.cnblogs.com/wupeiqi/articles/6216618.html

 -------------- END ------------