资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

orm详解
博客园    首页    博问    闪存    新随笔    订阅 orm 详解    管理

ORM：(在django中，根据代码中的类自动生成数据库的表也叫--code first)

ORM：Object Relational Mapping(关系对象映射)

我们提供的服务有：成都网站设计、做网站、微信公众号开发、网站优化、网站认证、循化ssl等。为上千余家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的循化网站制作公司

我们写的类表示数据库中的表

我们根据这个类创建的对象是数据库表里的一行数据

obj.id  obj.name.....就是数据库一行数据中的一部分数据

ORM--First：

我们在学习django中的orm的时候，我们可以把一对多，多对多，分为正向和反向查找两种方式。

1
2
3
4
5
6
7
class UserType(models.Model):
    caption = models.CharField(max_length=32)
 
class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    user_type = models.ForeignKey('UserType')#外键

正向查找：ForeignKey在 UserInfo表中，如果从UserInfo表开始向其他的表进行查询，这个就是正向操作，反之如果从UserType表去查询其他的表这个就是反向操作。

马上就要开始我们的orm查询之旅！！！

建表+配置url+views中写相应的函数

models.py（在django中仅且只能在这里写数据库的相关类）

1
2
3
4
5
6
7
class UserType(models.Model):
    caption = models.CharField(max_length=32)
 
class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    user_type = models.ForeignKey('UserType')

这里我们使用sqlite3数据库，在settings中使用默认设置就可以了

url.py中的配置

1
2
3
4
5
6
7
8
9
from django.conf.urls import url
from django.contrib import admin
from app01 import views
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^user_type',views.user_type),
    url(r'^user_info',views.user_info),
]

views.py先不进行任何操作，我们先保证正常访问已经设置的url

1
2
3
4
5
6
7
from django.shortcuts import render,HttpResponse
 
def user_type(req):
    return HttpResponse("ok")
 
def user_info(req):
    return HttpResponse("ok")

先在表中插入几个数据用于测试：

usertype表

orm 详解

userinfo表数据插入：

所以我们在创建UserType数据的时候有两种方法：第一种方法是直接根据这个字段进行添加数据！给user_type 加 '_id'

1
2
3
4
def user_info(request):
    dic = {'username':'mosson','age':18,'user_type_id':1}
    models.UserInfo.objects.create(**dic)
    return HttpResponse('OK')

或者通过对象添加

1
2
3
4
5
6
7
#先获取组的对象
usertype = models.UserType.objects.fiter(id=2)
#添加的时候直接添加对象就可以
models.UserInfo.objects.create(username='seven',age=18,user_type=usertype)
 
#写成一行也行
models.UserInfo.objects.create(username='lile',age=18,user_type=models.UserType.objects.filter(id=1))

django的get方法是从数据库的取得一个匹配的结果，返回一个对象，如果记录不存在的话，它会报错。
django的filter方法是从数据库的取得匹配的结果，返回一个对象列表，如果记录不存在的话，它会返回[]。

orm 详解

ORM的一对多：

我们在设计表结构的时候什么时候使用一对多呢？

比如我们在建立用户的时候有个菜单让我们选择用户类型的时候，使用一对多！！

1、一对多的正向查找：

正向查：ForeignKey在UserInfo表里，如果根据UserInfo这张表去查询这两张关联的表的合起来的内容就是正向查

反向查：ForeignKey不在UserType里,如果根据UserType这张表去查询这两张关联的表的合起来的内容就是反向查

正向查-demo1--查询所有用户为COO 的用户

在django中外键就相当于简单的使用__连表，在外键那个对象中封装了user_type表中的所有字段

我们要查询所有用户为CEO的用户，我们是不是的根据UserType这张表去查，如果是跨表查询使用“双下划线” + 属性

1
2
3
4
5
6
7
from app01 import models
def index(req):
    ret = models.UserInfo.objects.filter(user_type__caption='COO')
    print(ret)
    for item in ret:
        print(item,item.username,item.age,item.user_type.caption)
    return HttpResponse("OK")

查询结果：

orm 详解

反向查询：--

我们可以根据下面的命令，取出一个用户组，那么对于这个用户组他有多少个用户呢？

1
models.UserType.objects.get(id=1)
1
2
3
4
5
6
7
8
9
10
11
obj=models.UserType.objects.get(id=1)
    obj.caption====得到在UserType表中id为1对应的caption
    obj.id======得到在UserType表中id为1
    obj.userinfo_set  #理解为一种能力,可以获取所有当前这个用户类型的用户/或者这个用户类型的多个用户
    obj.userinfo_set.all() #获取所有用户类型为COO的用户
    obj.userinfo_set.filter(username='tim') #获取用户类型为COO的并且用户为tim的用户
 
    '''
    这.userinfo_set.相当于什么?它相当于  models.UserInfo.objects.filter(user_type=obj)
 
    '''

反向查询实例：查询COO用户下的所有的用户名

1
2
3
ret = models.UserType.objects.filter(caption='COO').values('userinfo__username')
   for item in ret:
       print(item,type(item))

方法二、

1
2
3
4
ret = models.UserType.objects.filter(caption='COO').first()
 
    for item in  ret.userinfo_set.all():
        print(item.username)

总结：

　　正向查找：

　　　　filter（跨表的时候，应该是对象__跨表的字段）

　　　　获取这个值的时候，拿到了一行数据的时候 line.对象.跨表的字段

　　反向查找：

　　　　filter（关联这个表的表明） 自动创建和表明相同的对象，通过这个对象__跨表的字段

　　　　line.自动创建和表明相同的对象_set.方法

orm 详解

ORM多对多  系统生成第三张表：

多对多和一对多没有任何关系

models.py

1
2
3
4
5
6
7
8
class Host(models.Model):
    hostname = models.CharField(max_length=32)
    port = models.IntegerField()
 
class HostAdmin(models.Model):
    username = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
    host = models.ManyToManyField('Host')

当我们在host表里和hostadmin表里添加数据时和第三章关系表没有任何关系，当我们这样去建立表时，第三张表里面的列就已经固定了，分别是这两个表的id

给主机表添加数据：

1
2
3
4
5
6
7
8
9
10
11
def index(req):
    #主机数据
    models.Host.objects.create(hostname='host1.test.com', port=80)
    models.Host.objects.create(hostname='host2.test.com', port=80)
    models.Host.objects.create(hostname='host3.test.com', port=80)
    models.Host.objects.create(hostname='host4.test.com', port=80)
    #用户数据
    models.HostAdmin.objects.create(username='alex', email='alex@qq.com')
    models.HostAdmin.objects.create(username='mosson', email='mosson@qq.com')
    models.HostAdmin.objects.create(username='aliven', email='aliven@qq.com')
    models.HostAdmin.objects.create(username='wusir', email='wusir@qq.com')

数据中的效果：

orm 详解

orm 详解

空的关系表

orm 详解

多对多正向、反向添加数据

orm 详解

正向添加数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def index(request):
 
    #正向添加数据
 
    #找到用户dali这个
    admin_obj = models.HostAdmin.objects.get(username='dali')
    #找到主机
    host_list = models.Host.objects.filter(id__lt=3)
    #通过找到的dali的对象.add去添加数据
    admin_obj.host.add(*host_list)
    '''
    admin_obj 通过大力这个对象.add 去操作的主机,
    大力的ID为 2 主机ID为:(1,2)
    那就会生成这样的表:
    #2 1
    #2 2
    '''
    return HttpResponse('OK')

反向添加数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def index(request):
 
    #反向添加数据
    #获取主机
    host_obj = models.Host.objects.get(id=3)
    #获取用户列表
    admin_list = models.HostAdmin.objects.filter(id__gt=1)
    #和一对多一样的道理
    host_obj.hostadmin_set.add(*admin_list)
    #host_obj = 3   管理员ID = 2 3 4
    #3 2
    #3 3
    #3 4   
    return HttpResponse('OK')

ORM 多对多 自定义 第三张表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class HostInfo(models.Model):
    hostname = models.CharField(max_length=32)
    port = models.IntegerField()
 
class UserMap(models.Model):
    username = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
 
    #through告诉Django用那张表做关联
    host = models.ManyToManyField(HostInfo , through='HostRelation')
 
class HostRelation(models.Model):
    host = models.ForeignKey('HostInfo')
    user = models.ForeignKey('UserMap')
 
    '''
    并且这里我们可以添加多个关系,比如在加一个字段
    usertype = models.ForeignKey('UserType')
    或者增加一个普通字段
    status = models.CharField(max_length=32)
    '''

现在咱们自己创建了第三张表了。现在我们已经会了两种方式创建第三张表了，当我们使用自定义创建的第三张表的时候，在去添加数据的时候！

就不能使用第一种方式对象添加了！

现在我们有第三张表了这个对象了，我们就不需要管另外两张表了，直接添加就行了！ 0 0 ！

添加主机和用户--

1
2
3
4
5
6
7
8
9
10
11
def index(req):
 
    models.HostInfo.objects.create(hostname='alex.test.com', port=80)
    models.HostInfo.objects.create(hostname='seven.test.com', port=80)
    models.HostInfo.objects.create(hostname='mosson.test.com', port=80)
 
    models.UserMap.objects.create(username='alex', email='alex@qq.com')
    models.UserMap.objects.create(username='seven', email='seven@qq.com')
    models.UserMap.objects.create(username='mosson', email='mosson@qq.com')
 
    return HttpResponse('ok')

将数据插入到第三张表中---办法1：

插入单条数据

1
2
3
4
5
6
def index(request):
    models.HostRelation.objects.create(
        user = models.UserMap.objects.get(id=1),
        host = models.HostInfo.objects.get(id=1)
    )
    return HttpResponse('OK')

多对多两种方式对比和查询

orm 详解

查询--方法一：

第一种方式都是基于表中的对象去找到第三张表！ 通过间接的方式找到这张表的句柄！

1
2
3
4
5
6
#正向查
admin_obj = models.HostAdmin.objects.get(id=1)
admin_obj.host.all()
#反相差
host_obj = models.Host.objects.get(id=1)
host_obj.hostadmin_set.all()

查询--方法二：

用第二种方法就没有正向和反向这么一说了，直接查即可！

1
2
3
4
relation_list = models.HostRelation.objects.all()
for item in relation_list:  #每一个item就是一个关系
    print (item.user.username)
    print( item.host.hostname)
1
2
3
4
relation_list = models.HostRelation.objects.filter(user__username='mosson')
    for item in relation_list:  #每一个item就是一个关系
        print( item.user.username)
        print (item.host.hostname)

通过第二种方式可以把所有的关系都找到，第一种方式可以把所有的关系表都找到吗？

第一种方式只能找到某一个人管理的机器，不能把有的对应关系找到！

select_related的作用：

1
2
3
4
5
6
7
class UserType(models.Model):
    caption = models.CharField(max_length=32)
 
class UserInfo(models.Model):
    user_type = models.ForeignKey('UserType') #这个user_type是一个对象,对象里面封装了ID和caption
    username = models.CharField(max_length=32)
    age = models.IntegerField()

select_related的作用，他就是用来优化查询的，没有他也可以，用它主要是用来优化ForeignKey

1
2
3
4
5
6
7
def index(request):
    ret = models.UserInfo.objects.all()
    #咱们看下他执行的什么SQL语句
    print( ret.query)
'''
SELECT "app01_userinfo"."id", "app01_userinfo"."user_type_id", "app01_userinfo"."username", "app01_userinfo"."age" FROM "app01_userinfo"
'''

加上select_related是什么样子的

新闻名称：orm详解
路径分享：http://www.cdkjz.cn/article/ijchgo.html
返回首页 了解更多建站资讯

相关资讯

多年建站经验

多一份参考，总有益处

联系快上网，免费获得专属《策划方案》及报价

咨询相关问题或预约面谈，可以通过以下方式与我们联系

大客户专线   成都：13518219792   座机：028-86922220

在线咨询 提交需求
友情链接 交换友情链接
高县网站建设成都发电机维修成都微信开发江油做网站全网品牌营销大英网站建设柴油发电机租赁网站制作成都广告安装公司成都网站设计

成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图