Django学习系列之ORM-QuerySetAPI

基本操作

 # 增

 models.Tb1.objects.create(c1='xx', c2='oo')              #增加一条数据，可以接受字典类型数据 **kwargs

 obj = models.Tb1(c1='xx', c2='oo')

 obj.save()

    dic = {'c1':'xx','c2':'oo'}

　　models.Tb1.objects.create(**dic)  　　                  #Form的产出结果是一个字典，可以根据这个Form的字典和**直接在数据库创建数据

 # 查

models.Tb1.objects.get(id=123)                             # 获取单条数据，不存在则报错（不建议）

models.Tb1.objects.all()                                   # 获取全部     .first()  取第一条数据

models.Tb1.objects.filter(name='seven')                    # 获取指定条件的数据   也可以用**的方式传参数
models.Tb1.objects.filtet(name__icontains='Searcher')      #过滤name字段包含Searcher的值并且不区分大小写,i是不区分大小写,contains是包含
models.Tb1.objects.filter(name='server').exclude(age='16') #获取指定条件的数据,但是排除某个条件(获取所有name=server的内容,但是排除age=16的)

# 删

models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

# 改

models.Tb1.objects.filter(name='seven').update(gender='')  # 将指定条件的数据更新，均支持 **kwargs

obj = models.Tb1.objects.get(id=1)

obj.c1 = ''

obj.save()                                                  # 修改单条数据

#排除
models.Tb1.objects.order_by('name')            #升序
models.Tb1.objects.order_by('-name')           #降序

细看从数据库取出的类型

 w = models.Simp.objects.all()

 print w, type(w)

 [<Simp: chenc>, <Simp: zan>, <Simp: zhangsan>]    <class 'django.db.models.query.QuerySet'>

 #可以看到，从数据库取出个数据看起来像包含对象的列表。而实际上整个数据为django中的特殊类型 QuerySet 。

.all() 是取得所有列的数据，可以加 .values() 取出某一列，每一项的值为一个字典：

 w = models.Simp.objects.all().values('username')

 print w, type(w)

[{'username': u'chenc'}, {'username': u'zan'}, {'username': u'zhangsan'}] <class 'django.db.models.query.QuerySet'>

.values_list(),获取到的值为一个元组

w = models.Simp.objects.all().values_list('username')

print w, type(w)

[(u'chenc',), (u'zan',), (u'zhangsan',)] <class 'django.db.models.query.QuerySet'>

.values_list() 也可以添加多个参数：（可以配合Form在前端生成动态的select ）

w = models.Simp.objects.all().values_list('id', 'username')

print w, type(w)

[(1, u'chenc'), (2, u'zan'), (3, u'zhangsan')] <class 'django.db.models.query.QuerySet'>

query 可以查看执行的sql语句：

b = models.Simp.objects.all()

print b.query

SELECT "app01_simp"."id", "app01_simp"."username", "app01_simp"."password" FROM "app01_simp"

利用双下划线将字段和对应的操作连接起来

 1     # 获取个数

 2     #

 3     # models.Tb1.objects.filter(name='seven').count()

 4

 5     # 大于，小于

 6     #

 7     # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值

 8     # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值

 9     # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

10

11     # in

12     #

13     # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据

14     # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

15

16     # contains

17     #

18     # models.Tb1.objects.filter(name__contains="ven")

19     # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

20     # models.Tb1.objects.exclude(name__icontains="ven")

21

22     # range

23     #

24     # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

25

26     # 其他类似

27     #

28     # startswith，istartswith, endswith, iendswith,

29

30     # order by

31     #

32     # models.Tb1.objects.filter(name='seven').order_by('id')    # asc 从小到大

33     # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc 从大到小

34

35     # limit 、offset

36     #

37     # models.Tb1.objects.all()[10:20]

38

39     # group by

40     from django.db.models import Count, Min, Max, Sum

41     # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))

42     # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

多对多关系操作

一、准备

1.创建多对多关系表

model.py

class Aihao(models.Model):

''爱好表'''

    name = models.CharField(max_length=122)

    person = models.ManyToManyField('Person')

    def __str__(self):

        return self.name

class Person(models.Model):

''人表'''

    name=  models.CharField(max_length=122)

    def __str__(self):

        return self.name

一个人有多个爱好,一个爱好可以被多个人拥有

2.生成数据库

python3.5 manage.py  makemigrations

python3.5 manage.py  migrate

3.在数据库客户端的展示

-爱好表里有一条数据,id是1

-人表里有一条数据,id是1

-这张表是自动创建的,存储人和爱好的对应关系,这个表就是把人和爱好关联起来,可以看到aihao_id就是代表的爱好ID,person_id就是代表的人,就是person为Alex,爱好为吃饭

4.操作

查询

从人出发获取爱好

from  app01.models  import *

>>> p = Person.objects.get(id=2)  #获取一个人 的对象

>>> p.aihao.all()                 #获取这个人的所有爱好

<QuerySet [<Aihao: 吃饭>, <Aihao: 玩电脑>]>

从爱好出发获取人

>>> a = Aihao.objects.get(id=3)  #获取一个爱好 的对象

>>> a.person_set.all()           #获取有这个爱好的所有人

<QuerySet [<Person: Alex>]>

删除

from app01.models import *

#删除和一个人相关的所有爱好

>>> d = Person.objects.get(id=3)   #获取Person表中id=3的人

>>> d.aihao.all()                           #获取第三张表中(关系对应表) id=3这个人的爱好

<QuerySet [<Aihao: 吃饭>, <Aihao: 玩电脑>]>

>>>d.aihao.clear()                         #在第三张表(关系对应表)中删除和id=3这个人关联的数据

>>> d.aihao.all()                            #获取第三张表中 id=3这个人的爱好

<QuerySet [<>]>                           #现在已经没了

#删除和这个爱好相关的所有人

>>> d = Person.objects.get(id=2)  #获取一个人 的对象

>>> d.aihao.clear()                       #删除和这个人关联的所有爱好

注意:

如果多个表(爱好表[relate_name=aihao_person_set],manytomany到person表,兴趣表[relate_name=xingqu_person_set],manytomany到person表,)

都manytomany到Person表

那每个表manytomany的字段都得设置relate_name字段

如果想通过爱好表反查或者兴趣表反查

比如获取有这个爱好的所有人[a = aihao.object.get(id=2),a.aihao_person_set.all()]

获取有这个兴趣的所有人 [a = xingqu.object.get(id=2),a.xingqu_person_set.all()]

一对多关系操作

表结构

class User(models.Model):

'''用户表'''

    name = models.CharField(max_length=20)

    def __str__(self):

        return self.name

class UserType(models.Model):

'''用户类型表'''

    name = models.CharField(max_length=20)

    user = models.ForeignKey(User)

在数据库客户端查看

User表:

UserType表:

注:user_id字段就是User表的外键

表结构(models.py)

class Asset(models.Model):

    hostname = models.CharField(max_length=64, unique=True)

    os_type  = models.CharField('操作系统类型',max_length=64, blank=True,null=True)

    os_distribution = models.CharField('发型版本',max_length=64, blank=True,null=True)

    os_release  = models.CharField('操作系统版本',max_length=64, blank=True,null=True)

    inside_ip  = models.GenericIPAddressField('内网IP', blank=True, null=True)

    outside_ip = models.GenericIPAddressField('外网IP', blank=True, null=True)

    sn = models.CharField('资产SN号',max_length=128, unique=True)

    business_unit = models.ForeignKey('BusinessUnit', verbose_name='所属业务线',null=True, blank=True)

    admin = models.ForeignKey(UserProfile, verbose_name=u'资产管理员',null=True, blank=True)

    memo  = models.TextField('备注', null=True, blank=True)

    model = models.CharField('型号',max_length=128,null=True, blank=True )

    kernelrelease = models.CharField('内核',max_length=128,null=True, blank=True )

    create_date = models.DateTimeField(blank=True, auto_now_add=True)

    update_date = models.DateTimeField(blank=True,null=True)

    class Meta:

        verbose_name = '资产'

        verbose_name_plural = "资产"

    def __str__(self):

        return '%s sn:%s' %(self.hostname,self.sn)

class RAM(models.Model):

    '''

    内存条

    '''

    asset = models.ForeignKey('Asset')   #这里asset是Asset表的外键,在RAM表中这个字段实际为asset_id,就是Asset表中的id字段(因为Asset表中的id字段是唯一的,所以代表这个RAM属于这个Asset),可以根据asset_id获取Asset表中的信息

    capacity = models.IntegerField('内存大小(MB)')

    create_date = models.DateTimeField(blank=True, auto_now_add=True)

    update_date = models.DateTimeField(blank=True,null=True)

    memo = models.CharField('备注',max_length=128, blank=True,null=True)

    # auto_create_fields = ['sn','slot','model','capacity']

    def __str__(self):

        return '%s:%s' % (self.asset_id,self.capacity)

    class Meta:

        verbose_name = '内存'

        verbose_name_plural = "内存"

因为是一对多关系,所以一个Asset表对应多个RAM表(一个资产可以有多个内存条),RAM表中asset(asset_id)是Asset表的id,也就是Asset表的外键

示例一:获取某个资产下的所有内存条(根据"一"获取"多")

代码:

>>> a = Asset.objects.get(id=1)  #获取id=1的资产信息

>>> b = a.ram_set.select_related())     #等同于 a.ram_set_all()

...

结果:

<QuerySet [<RAM: 4:1234>, <RAM: 4:2312>]>

示例二:获取某个资产下的每个内存条的capacity值(根据"一"获取一个"多"的某个值)

代码:

>>> a = Asset.objects.get(id=1)  #获取id=1的资产信息
>>> b = a.ram_set_all()          #获取id=1资产下的所有内存条信息

>>> for i in b:                  #循环所有内存条,取出每个内存条的capacity

...      print(i.capacity)

... 

结果:

1234

2312

示例三:获取某个内存条属于哪个资产(根据"多"获取"一")

代码

a = RAM.objects.get(id=)  #获取这个内存条

b = a.asset.name           #获取这个内存条属于哪个资产,获取name字段
结果:
172-16-1-213

示例四:在RAM表中获取属于Asset表id为10的所有内存条(根据外键获取信息)

all_ram = RAM.objects.filter(asset_id=)

#这就获取了所有数据asset_id为10的内存条

一对一关系操作

表结构(models.py)

class Asset(models.Model):

    hostname = models.CharField(max_length=64, unique=True)

    os_type  = models.CharField('操作系统类型',max_length=64, blank=True,null=True)

    os_distribution = models.CharField('发型版本',max_length=64, blank=True,null=True)

    os_release  = models.CharField('操作系统版本',max_length=64, blank=True,null=True)

    inside_ip  = models.GenericIPAddressField('内网IP', blank=True, null=True)

    outside_ip = models.GenericIPAddressField('外网IP', blank=True, null=True)

    sn = models.CharField('资产SN号',max_length=128, unique=True)

    business_unit = models.ForeignKey('BusinessUnit', verbose_name='所属业务线',null=True, blank=True)

    admin = models.ForeignKey(UserProfile, verbose_name=u'资产管理员',null=True, blank=True)

    memo  = models.TextField('备注', null=True, blank=True)

    model = models.CharField('型号',max_length=128,null=True, blank=True )

    kernelrelease = models.CharField('内核',max_length=128,null=True, blank=True )

    create_date = models.DateTimeField(blank=True, auto_now_add=True)

    update_date = models.DateTimeField(blank=True,null=True)

    class Meta:

        verbose_name = '资产'

        verbose_name_plural = "资产"

    def __str__(self):

        return '%s sn:%s' %(self.hostname,self.sn)

class CPU(models.Model):

    '''

    CPU的基本类型

    '''

    asset = models.OneToOneField('Asset')

    cpu_model = models.CharField('CPU型号', max_length=128,blank=True)

    cpu_count = models.SmallIntegerField('物理cpu个数')

    cpu_core_count = models.SmallIntegerField('cpu核数')

    create_date = models.DateTimeField(verbose_name='创建时间',auto_now_add=True)

    update_date = models.DateTimeField(verbose_name='更新时间',blank=True,null=True)

    memo = models.TextField('备注', null=True,blank=True)

    class Meta:

        verbose_name = 'CPU'

        verbose_name_plural = "CPU"

    def __str__(self):

        return self.cpu_model

因为是一对一关系,所以一个Asset表只能对应一个CPU表

示例一:获取关联Asset表的CPU表的cpu_model值和cpu_cont值和cpu_core_count值

代码:

>>> a = models.Asset.objects.all()

>>> for i in a:

...     print(i.cpu.cpu_model,i.cpu.cpu_count,i.cpu.cpu_core_count)

... 

结果

hype -v    2     2

数据库如果添加字段之后执行makemigrations 表名然后执行migrate 表名