溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
|
|
管理
ORM：Object Relational Mapping(關(guān)系對象映射)
我們寫的類表示數(shù)據(jù)庫中的表
我們根據(jù)這個類創(chuàng)建的對象是數(shù)據(jù)庫表里的一行數(shù)據(jù)
obj.id obj.name.....就是數(shù)據(jù)庫一行數(shù)據(jù)中的一部分數(shù)據(jù)
我們在學習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中寫相應的函數(shù)
models.py（在django中僅且只能在這里寫數(shù)據(jù)庫的相關(guān)類）
|
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數(shù)據(jù)庫，在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先不進行任何操作，我們先保證正常訪問已經(jīng)設置的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")
|
先在表中插入幾個數(shù)據(jù)用于測試：
usertype表
userinfo表數(shù)據(jù)插入：
所以我們在創(chuàng)建UserType數(shù)據(jù)的時候有兩種方法：第一種方法是直接根據(jù)這個字段進行添加數(shù)據(jù)！給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方法是從數(shù)據(jù)庫的取得一個匹配的結(jié)果，返回一個對象，如果記錄不存在的話，它會報錯。
django的filter方法是從數(shù)據(jù)庫的取得匹配的結(jié)果，返回一個對象列表，如果記錄不存在的話，它會返回[]。
我們在設計表結(jié)構(gòu)的時候什么時候使用一對多呢？
比如我們在建立用戶的時候有個菜單讓我們選擇用戶類型的時候，使用一對多??！
正向查：ForeignKey在UserInfo表里，如果根據(jù)UserInfo這張表去查詢這兩張關(guān)聯(lián)的表的合起來的內(nèi)容就是正向查
反向查：ForeignKey不在UserType里,如果根據(jù)UserType這張表去查詢這兩張關(guān)聯(lián)的表的合起來的內(nèi)容就是反向查
在django中外鍵就相當于簡單的使用__連表，在外鍵那個對象中封裝了user_type表中的所有字段
我們要查詢所有用戶為CEO的用戶，我們是不是的根據(jù)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")
|
查詢結(jié)果：
我們可以根據(jù)下面的命令，取出一個用戶組，那么對于這個用戶組他有多少個用戶呢？
|
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)
|
總結(jié)：
正向查找：
filter（跨表的時候，應該是對象__跨表的字段）
獲取這個值的時候，拿到了一行數(shù)據(jù)的時候 line.對象.跨表的字段
反向查找：
filter（關(guān)聯(lián)這個表的表明） 自動創(chuàng)建和表明相同的對象，通過這個對象__跨表的字段
line.自動創(chuàng)建和表明相同的對象_set.方法
多對多和一對多沒有任何關(guān)系
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表里添加數(shù)據(jù)時和第三章關(guān)系表沒有任何關(guān)系，當我們這樣去建立表時，第三張表里面的列就已經(jīng)固定了，分別是這兩個表的id
給主機表添加數(shù)據(jù)：
|
1
2
3
4
5
6
7
8
9
10
11
|
def index(req):
#主機數(shù)據(jù)
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)
#用戶數(shù)據(jù)
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')
|
數(shù)據(jù)中的效果：
空的關(guān)系表
多對多正向、反向添加數(shù)據(jù)
正向添加數(shù)據(jù)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
def index(request):
#正向添加數(shù)據(jù)
#找到用戶dali這個
admin_obj = models.HostAdmin.objects.get(username='dali')
#找到主機
host_list = models.Host.objects.filter(id__lt=3)
#通過找到的dali的對象.add去添加數(shù)據(jù)
admin_obj.host.add(*host_list)
'''
admin_obj 通過大力這個對象.add 去操作的主機,
大力的ID為 2 主機ID為:(1,2)
那就會生成這樣的表:
#2 1
#2 2
'''
return HttpResponse('OK')
|
反向添加數(shù)據(jù)：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
def index(request):
#反向添加數(shù)據(jù)
#獲取主機
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')
|
|
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用那張表做關(guān)聯(lián)
host = models.ManyToManyField(HostInfo , through='HostRelation')
class HostRelation(models.Model):
host = models.ForeignKey('HostInfo')
user = models.ForeignKey('UserMap')
'''
并且這里我們可以添加多個關(guān)系,比如在加一個字段
usertype = models.ForeignKey('UserType')
或者增加一個普通字段
status = models.CharField(max_length=32)
'''
|
現(xiàn)在咱們自己創(chuàng)建了第三張表了?，F(xiàn)在我們已經(jīng)會了兩種方式創(chuàng)建第三張表了，當我們使用自定義創(chuàng)建的第三張表的時候，在去添加數(shù)據(jù)的時候！
就不能使用第一種方式對象添加了！
現(xiàn)在我們有第三張表了這個對象了，我們就不需要管另外兩張表了，直接添加就行了！ 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')
|
將數(shù)據(jù)插入到第三張表中---辦法1：
插入單條數(shù)據(jù)
|
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')
|
多對多兩種方式對比和查詢
查詢--方法一：
第一種方式都是基于表中的對象去找到第三張表！ 通過間接的方式找到這張表的句柄！
|
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就是一個關(guān)系
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就是一個關(guān)系
print( item.user.username)
print (item.host.hostname)
|
通過第二種方式可以把所有的關(guān)系都找到，第一種方式可以把所有的關(guān)系表都找到嗎？
第一種方式只能找到某一個人管理的機器，不能把有的對應關(guān)系找到！
|
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的作用，他就是用來優(yōu)化查詢的，沒有他也可以，用它主要是用來優(yōu)化ForeignKey
|
1
2
3
4
5
6
7
|
def index(request):
ret = models.UserInfo.objects.all()
#咱們看下他執(zhí)行的什么SQL語句
print( ret.query)
'''
SELECT "app01_userinfo"."id", "app01_userinfo"."user_type_id", "app01_userinfo"."username", "app01_userinfo"."age" FROM "app01_userinfo"
'''
|
加上select_related是什么樣子的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
def user_info(request):
ret = models.UserInfo.objects.all().select_related()
#咱們看下他執(zhí)行的什么SQL語句
print ret.query
SELECT "app01_userinfo"."id",
"app01_userinfo"."user_type_id",
"app01_userinfo"."username",
"app01_userinfo"."age",
"app01_usertype"."id",
"app01_usertype"."caption"
FROM
"app01_userinfo" INNER JOIN "app01_usertype" ON ("app01_userinfo"."user_type_id" = "app01_usertype"."id")
|
所以說select_related就是優(yōu)化查詢的！
一、一對多創(chuàng)建
1、創(chuàng)建數(shù)據(jù)
通過對象創(chuàng)建
或者通過對象字段_id創(chuàng)建
2、查找
正向查找
在通過filter的時候跨表使用 雙下劃線 '__'
在獲取值得時候通過.跨表
反向查找
Django自動生成 表名_set
其他操作和正向查找一樣
二、多對對
1、自動生成關(guān)系表
間接的方式獲取關(guān)系表，如果是正向的：一行數(shù)據(jù)的對象.ManyToMany字典就行 反向：一行數(shù)據(jù)的對象.表名_set
2、自定義關(guān)系表（推薦）不管是添加、修改只對關(guān)系表操作就行
三、select_related
用于優(yōu)化查詢，一次性將查詢的表和ForiegnKey關(guān)聯(lián)的表一次性加載到內(nèi)存。
F：用來批量修改數(shù)據(jù)（使用查詢條件的值）
demo：比如我有個price這個列，我想讓price自增10或者某一些自增10
|
1
2
|
# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+10)
|
Q：用來做條件查詢的
默認的django的查詢只是且操作如下：
|
1
|
models.UserInfo.objects.filter(username='mosson',age='18')
|
找到用戶名為：mosson且age=18的數(shù)據(jù)
有沒有這么一種情況：username=mosson或 username=wusir 或 username=alex 并且 age=18的需求？原生的查詢是不支持的!所以就用到了Q~
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
第一步：
#生成一個搜索對象
search_q = Q()
#在生成兩個搜索對象
search2 = Q()
search3 = Q()
第二步：
#標記search2中的搜索條件為 ‘ 或’ 查詢
search2.connector = 'OR'
#把搜索條件加入到search2中
search2.children.append(('字段名','字段內(nèi)容'))
search2.children.append(('字段名','字段內(nèi)容'))
search2.children.append(('字段名','字段內(nèi)容'))
search2.children.append(('字段名','字段內(nèi)容'))
#標記search3中的搜索條件為 ‘ 或’ 查詢
search3.connector = 'OR'
#把搜索條件加入到search3中
search3.children.append(('字段名','字段內(nèi)容'))
search3.children.append(('字段名','字段內(nèi)容'))
search3.children.append(('字段名','字段內(nèi)容'))
search3.children.append(('字段名','字段內(nèi)容'))
第三步：
#把多個搜索條件進行合并
search_q.add(search2,'AND')
search_q.add(search3,'AND')
第四步：
#執(zhí)行搜索
models.HostInfo.objects.filter(search_q)
|
在前端獲取搜索條件的時候我把相同類型的搜索寫成字典的形式{字段名:[條件結(jié)合列表]}，這樣我在查詢的時候直接通過循環(huán)字典就可以把搜索條件分為不同的子條件！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
function SearchSubmit() {
//清空當前列表
$('#table-body').children().remove();
//設置一個空字典
SEARCH_DIC = {};
//找到所有的搜索框體
var search_data = $('.inputs').find("input[is-condition='true']");
//循環(huán)找到的內(nèi)容
$.each(search_data,function (index,data) {
//獲取搜索的類型
/*
這里需要注意:重點:::::
這里和Django的Q可以進行耦合,在我們定義搜索的類型的時候可以直接寫成我們要搜索的的'庫中的字段或者條件都可以!!!'
如下:
<input is-condition="true" type="text" placeholder="逗號分割多條件" class="form-control no-radius" name="hostname" />
*/
var search_name = $(this).attr('name');
//獲取搜索的值
var search_value = $(this).val();
if(SEARCH_DIC.hasOwnProperty(search_name)){//判斷是否有這個KEY
SEARCH_DIC[search_name].push(search_value)
}else{
SEARCH_DIC[search_name] = [search_value]
}
} );//ajax請求結(jié)束
$.get("{% url 'search_info' %}",{'search_list':JSON.stringify(SEARCH_DIC)},function(callback){
$('#table-body').append(callback)
});//搜索按鈕結(jié)束
|
重點：
在前端我們定義input的name屬性的時候，我們可以直接定義為數(shù)據(jù)庫中的“字段名”，并且在Django的Q中支持跨表操作“雙下劃線”，所以我們在定義name的時候可以直接定義雙下劃線操作
|
1
|
search2.children.append(('字段名'__'跨表字段名','跨表字段內(nèi)容'))
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
@login_auth
def search_info(request):
#獲取用戶請求的數(shù)據(jù)
user_post = json.loads(request.GET['search_list'])
print user_post
#生成搜索對象
Serach_Q = Q()
#循環(huán)字典并生成搜索條件集合
for k,v in user_post.items():
#生成一個搜索結(jié)合
q = Q()
#生命集合中的搜索條件為'或'條件
q.connector = 'OR'
#循環(huán)字典中的value,value是前端傳過來的條件集合
for i in v:
#在搜索條件集合中增加條件,條件為元組形式,k為字典中的key! key是字段名或者跨表字段名或者支持_gt等
#i為字典中的vlaue中的元素,為條件
#
q.children.append((k,i))
#沒循環(huán)一次后后,吧他加入到總的搜索條件中
Serach_Q.add(q,'AND')
#使用總的搜索條件進行查詢
data = models.HostInfo.objects.filter(Serach_Q)
#拼接字符串并返回
html = []
for i in data:
html.append(
"
"<td>" + "<input type='checkbox' >"+ "" +
"<td name='host_id'>" + '%s' %i.id + "" +
"<td name='host_name' edit='true'>" + i.hostname + ""+
"<td name='host_ip' edit='true'>" + i.hostip + ""+
"<td name='host_port' edit='true'>" + '%s' %i.hostport + ""+
"<td name='host_business' edit='true' edit-type='select' global-key='BUSINESS' select-val='" + '%s' %i.hostbusiness_id + "'>" + i.hostbusiness.hostbusiness + ""+
"<td name='host_status' edit='true' edit-type='select' global-key='STATUS' select-val='" + '%s' %i.hoststatus_id + "'>" + i.hoststatus.hoststatus + ""+
"
)
html = mark_safe("".join(html))
return HttpResponse(html)
|
| < | 2017年7月 | > |
免責聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點不代表本網(wǎng)站立場，如果涉及侵權(quán)請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關(guān)證據(jù)，一經(jīng)查實，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號
手機網(wǎng)站二維碼
