Python Web框架篇：Django Model ORM(對象關系映射)

本文轉載自查看原文 2017-10-19 22:52 3807 Python Django篇/ Python_web框架篇

一，基本操作

用於實現面向對象編程語言里不同類型系統的數據之間的轉換，換言之，就是用面向對象的方式去操作數據庫的創建表以及增刪改查等操作。

1.增(create , save)：

 1 2     from app01.models import *
 3 
 4     #create方式一:   Author.objects.create(name='Alvin')
 5     
 6     #create方式二:   Author.objects.create(**{"name":"alex"})
 7     
 8     #save方式一:     author=Author(name="alvin")
 9                     author.save()
10                     
11     #save方式二:     author=Author()
12                     author.name="alvin"
13                     author.save()

2.刪（delete）：

 1 #正向    book = models.Book.objects.filter(id=1)
 2 
 3     #刪除第三張表中和女孩1關聯的所有關聯信息
 4         book.author.clear()        #清空與book中id=1 關聯的所有數據
 5         book.author.remove(2)  #可以為id
 6         book.author.remove(*[1,2,3,4])     #可以為列表,前面加*
 7 
 8     #反向
 9         author = models.Author.objects.filter(id=1)
10         author.book_set.clear() #清空與boy中id=1 關聯的所有數據

3.改（update和save）：

update方法直接設定對應屬性

# models.Tb1.objects.filter(name='seven').update(gender='0')  # 將指定條件的數據更新，均支持 **kwargs

save方法會將所有屬性重新設定一遍,效率低

  　　　　# obj = models.Tb1.objects.get(id=1)
        # obj.c1 = '111'
        # obj.save()                                                 # 修改單條數據

查詢：

 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__gte=1)              # 獲取id大於等於1的值
 9         # models.Tb1.objects.filter(id__lt=10)             # 獲取id小於10的值
10         # models.Tb1.objects.filter(id__lte=10)             # 獲取id小於10的值
11         # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 獲取id大於1 且 小於10的值
12 
13         # in
14         #
15         # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 獲取id等於11、22、33的數據
16         # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
17 
18         # isnull
19         # Entry.objects.filter(pub_date__isnull=True)
20 
21         # contains
22         #
23         # models.Tb1.objects.filter(name__contains="ven")
24         # models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
25         # models.Tb1.objects.exclude(name__icontains="ven")
26 
27         # range
28         #
29         # models.Tb1.objects.filter(id__range=[1, 2])   # 范圍bettwen and
30 
31         # 其他類似
32         #
33         # startswith，istartswith, endswith, iendswith,
34 
35         # order by
36         #
37         # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
38         # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc
39 
40         # group by
41         #
42         # from django.db.models import Count, Min, Max, Sum
43         # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
44         # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
45 
46         # limit 、offset
47         #
48         # models.Tb1.objects.all()[10:20]
49 
50         # regex正則匹配，iregex 不區分大小寫
51         #
52         # Entry.objects.get(title__regex=r'^(An?|The) +')
53         # Entry.objects.get(title__iregex=r'^(an?|the) +')
54 
55         # date
56         #
57         # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
58         # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
59 
60         # year
61         #
62         # Entry.objects.filter(pub_date__year=2005)
63         # Entry.objects.filter(pub_date__year__gte=2005)
64 
65         # month
66         #
67         # Entry.objects.filter(pub_date__month=12)
68         # Entry.objects.filter(pub_date__month__gte=6)
69 
70         # day
71         #
72         # Entry.objects.filter(pub_date__day=3)
73         # Entry.objects.filter(pub_date__day__gte=3)
74 
75         # week_day
76         #
77         # Entry.objects.filter(pub_date__week_day=2)
78         # Entry.objects.filter(pub_date__week_day__gte=2)
79 
80         # hour
81         #
82         # Event.objects.filter(timestamp__hour=23)
83         # Event.objects.filter(time__hour=5)
84         # Event.objects.filter(timestamp__hour__gte=12)
85 
86         # minute
87         #
88         # Event.objects.filter(timestamp__minute=29)
89         # Event.objects.filter(time__minute=46)
90         # Event.objects.filter(timestamp__minute__gte=29)
91 
92         # second
93         #
94         # Event.objects.filter(timestamp__second=31)
95         # Event.objects.filter(time__second=2)
96         # Event.objects.filter(timestamp__second__gte=31)

View Code

二、連表操作

利用雙下划線和 _set 將表之間的操作連接起來

2.1 一對一操作

user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.password
 
user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()

2.2 一對多操作

1、搜索條件使用 __ 連接

2、獲取值時使用 . 連接

2.3 多對多

三級聯動models

class Province(models.Model):
    name = models.CharField(max_length=32)

class City(models.Model):
    name = models.CharField(max_length=32)
    pro = models.ForeignKey("Province")

class Xian(models.Model):
    name = models.CharField(max_length=32)
    cy = models.ForeignKey("City")

views

def menu(request):
    # for i in range(10):
    #     models.Province.objects.create(name="河北"+str(i))
    # for i in range(5):
    #     models.City.objects.create(name="廊坊" + str(i),pro_id=1)
    # return HttpResponse("OK")
    pro_list = models.Province.objects.all()
    return render(request, 'menus.html', {"pro_list": pro_list})

def fetch_city(request):
    # 根據用戶傳入的省份ID，獲取與其相關的所有市ID
    # ret = {'status': True, 'error': None, 'data': None}

    province_id = request.GET.get('province_id')
    # result = models.City.objects.filter(pro_id=province_id)
    # # QuerySet內部放置對象
    # from django.core import serializers
    # data = serializers.serialize("json", result)

    result = models.City.objects.filter(pro_id=province_id).values('id','name')
    # QuerySet內部放置對象
    result = list(result)
    import json
    data = json.dumps(result)

    # result = models.City.objects.filter(pro_id=province_id).values_list('id','name')
    # # QuerySet內部放置對象
    # print(result)
    # result = list(result)
    # import json
    # data = json.dumps(result)
    return HttpResponse(data)

def fetch_xian(request):
    # for i in range(10):
    #     models.Xian.objects.create(name='縣'+ str(i), cy_id=1)
    city_id = request.GET.get('city_id')
    xian_list = models.Xian.objects.filter(cy_id=city_id).values('id','name')
    xian_list = list(xian_list)
    return HttpResponse(json.dumps(xian_list))

menu.html

 1 {% extends "layout.html" %}
 2 
 3 {% block css %}
 4 {% endblock %}
 5 
 6 
 7 {% block content %}
 8     <h1>二級聯動</h1>
 9     <select id="province">
10         <option value="-1">請選擇省份</option>
11         {% for p in pro_list %}
12             <option value="{{ p.id }}">{{ p.name }}</option>
13         {% endfor %}
14     </select>
15 
16     <select id="city">
17         <option value="-1">請選擇市</option>
18     </select>
19 {% endblock %}
20 
21 
22 {% block js %}
23     <script>
24         $(function () {
25             bindProvinceEvent();
26         });
27         function bindProvinceEvent(){
28             $('#province').change(function () {
29                 var v = $(this).val();
30                 if(v == '-1'){
31 
32                 }else{
33                     $('#city option:gt(0)').remove();
34                     $.ajax({
35                         url: '/fetch_city.html',
36                         type: 'GET',
37                         data: {'province_id': v},
38                         dataType: 'json',
39                         success: function (arg) {
40                             $.each(arg, function(k,v){
41                                 var city_id =  v.pk;
42                                 var city_name = v.fields.name;
43                                 var tag = document.createElement('option');
44                                 tag.innerHTML = city_name;
45                                 tag.setAttribute('value', city_id);
46                                 $('#city').append(tag);
47                             });
48                         }
49                     })
50                 }
51             })
52         }
53     </script>
54 {% endblock %}

View Code

三、高級操作

3.1.F() 表達式

一個 F()對象代表了一個model的字段值或注釋列。使用它就可以直接參考model的field和執行數據庫操作而不用再把它們（model field）查詢出來放到python內存中。作為代替，Django使用 F()對象生成一個SQL表達式，來描述數據庫層級所需要的操作

from django.db.models import F

reporter = Reporters.objects.get(name='Tintin')
reporter.stories_filed = F('stories_filed') + 1
reporter.save()

雖然reporter.stories_filed = F('stories_filed') + 1看起來像一個正常的Python分配值賦給一個實例屬性，事實上這是一個描述數據庫操作的SQL概念

當Django遇到 F()實例，它覆蓋了標准的Python運算符創建一個封裝的SQL表達式。在這個例子中，reporter.stories_filed就代表了一個指示數據庫對該字段進行增量的命令。

無論reporter.stories_filed的值是或曾是什么，Python一無所知--這完全是由數據庫去處理的。所有的Python，通過Django的F() 類，只是去創建SQL語法參考字段和描述操作。

F()配合 update()可以應用於對象實例的 QuerySets這減少了我們上面使用的兩個查詢 - get()和save() - 只有一個：

reporter = Reporters.objects.filter(name='Tintin')
reporter.update(stories_filed=F('stories_filed') + 1)
我們可以使用update()方法批量地增加多個對象的字段值。這比先從數據庫查詢后，通過循環一個個增加，並一個個保存要快的很多。

Reporter.objects.all().update(stories_filed=F('stories_filed') + 1)
F()表達式的效率上的優點主要體現在：直接通過數據庫操作而不是Python；減少數據庫查詢次數。

`3.2.Q()` 對象

Q() 對象和F 對象類似，把一個SQL 表達式封裝在Python 對象中，這個對象可以用於數據庫相關的操作。

通常，Q() 對象使得定義查詢條件然后重用成為可能。這允許construction of complex database queries使用| (OR) 和 & (AND) 操作符; 否則QuerySets中使用不了OR。

例如，下面的Q 對象封裝一個LIKE 查詢：

from django.db.models import Q
Q(question__startswith='What')

Q 對象可以使用& 和| 操作符組合起來。當一個操作符在兩個Q 對象上使用時，它產生一個新的Q 對象。

例如，下面的語句產生一個Q 對象，表示兩個"question__startswith" 查詢的“OR” ：

Q(question__startswith='Who') | Q(question__startswith='What')

它等同於下面的SQL WHERE 子句：

WHERE question LIKE 'Who%' OR question LIKE 'What%'

你可以組合& 和| 操作符以及使用括號進行分組來編寫任意復雜的Q 對象。同時，Q 對象可以使用~ 操作符取反，這允許組合正常的查詢和取反(NOT) 查詢：

Q(question__startswith='Who') | ~Q(pub_date__year=2005)

每個接受關鍵字參數的查詢函數（例如filter()、exclude()、get()）都可以傳遞一個或多個Q 對象作為位置（不帶名的）參數。如果一個查詢函數有多個Q 對象參數，這些參數的邏輯關系為“AND"。例如：

Poll.objects.get(
　　Q(question__startswith='Who'),
　　Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)

... 大體上可以翻譯成這個SQL：

SELECT * from polls WHERE question LIKE 'Who%'
AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

3.3.執行原生SQL

# # from django.db import connection, connections

# cursor = connection.cursor() # cursor = connections['default'].cursor()

# cursor.execute("""SELECT * from auth_user where id = %s""", [1])

# row = cursor.fetchone()

3.4 extra

extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
   Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
   Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
   Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
   Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
3.4其他

def select_related(self, *fields)
    性能相關：表之間進行join連表操作，一次性獲取關聯的數據。
    model.tb.objects.all().select_related()
    model.tb.objects.all().select_related('外鍵字段')
    model.tb.objects.all().select_related('外鍵字段__外鍵字段')
    主動做連表操作
    select * from user left join user_type on tb.xxx=tb1.oo               
     
def prefetch_related(self, *lookups)
    性能相關：多表連表操作時速度會慢，使用其執行多次SQL查詢在Python代碼中實現連表操作。
            # 獲取所有用戶表
            # 獲取用戶類型表where id in (用戶表中的查到的所有用戶ID)
            #select * from user_type where id in 用戶類型ID{1，2}
            models.UserInfo.objects.prefetch_related('外鍵字段')      #不連表，一次性多次查詢

def annotate(self, *args, **kwargs)
    # 用於實現聚合group by查詢
　　# 用於實現聚合group by查詢    前面的values寫的是誰，就group誰

    from django.db.models import Count, Avg, Max, Min, Sum
    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
    
    print(v.query)
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1


    from django.db.models import Count, Case, When, IntegerField
    Article.objects.annotate(
        numviews=Count(Case(
            When(readership__what_time__lt=threshold, then=1),
            output_field=CharField(),
        ))
    )

    students = Student.objects.all().annotate(num_excused_absences=models.Sum(
        models.Case(
            models.When(absence__type='Excused', then=1),
        default=0,
        output_field=models.IntegerField()
    )))        

def aggregate(self, *args, **kwargs):
   # 聚合函數，獲取字典類型聚合結果
   from django.db.models import Count, Avg, Max, Min, Sum
　　
　　result = models.UserInfo.objects.aggregate(k=Count(n=Count('nid'))
　　{‘n’:4}
　　result = models.UserInfo.objects.aggregate(k=Count(n=Count('nid'),distinct=True)
　　去重后的數目

　　result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))

===> {'k': 3, 'n': 4}

# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
    # 獲取所有的數據對象

def filter(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def exclude(self, *args, **kwargs)
    # 條件查詢
    # 條件可以是：參數，字典，Q

def distinct(self, *field_names)
    # 用於distinct去重
    models.UserInfo.objects.values('nid').distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct進行去重

def order_by(self, *field_names)
    # 用於排序
    models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 構造額外的查詢條件或者映射，如：子查詢

    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse()
    # 注：如果存在order_by，reverse則是倒序，如果多個排序則一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer('username','id')
    或
    models.UserInfo.objects.filter(...).defer('username','id')
    #映射中排除某列數據

 def only(self, *fields):
    #僅取某個表中的數據
     models.UserInfo.objects.only('username','id')
     或
     models.UserInfo.objects.filter(...).only('username','id')

 def using(self, alias):
     指定使用的數據庫，參數為別名（setting中的設置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 執行原生SQL
    models.UserInfo.objects.raw('select * from userinfo')

    # 如果SQL是其他表時，必須將名字設置為當前UserInfo對象的主鍵列名
    models.UserInfo.objects.raw('select id as nid from 其他表')

    # 為原生SQL設置參數
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

    # 將獲取的到列名轉換為指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
    Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

    # 指定數據庫
    models.UserInfo.objects.raw('select * from userinfo', using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 獲取每行數據為字典格式

def values_list(self, *fields, **kwargs):
    # 獲取每行數據為元祖

def dates(self, field_name, kind, order='ASC'):
    # 根據時間進行某一部分進行去重查找並截取指定內容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 並獲取轉換后的時間
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
    # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換為指定時區時間
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo時區對象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet對象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def count(self): # 獲取個數 def get(self, *args, **kwargs): # 獲取單個對象 def create(self, **kwargs): # 創建對象 def bulk_create(self, objs, batch_size=None): # 批量插入 # batch_size表示一次插入的個數 objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs): # 如果存在，則獲取，否則，創建 # defaults 指定創建時，其他字段的值 obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs): # 如果存在，則更新，否則，創建 # defaults 指定創建時或更新時的其他字段 obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1}) def first(self): # 獲取第一個 def last(self): # 獲取最后一個 def in_bulk(self, id_list=None): # 根據主鍵ID進行查找 id_list = [11,21,31] models.DDD.objects.in_bulk(id_list)#等於models.DDD.objects.filter(id__in=id_list) def delete(self): # 刪除 def update(self, **kwargs): # 更新 def exists(self): # 是否有結果

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Django 源碼小剖: Django 對象關系映射(ORM) 對象關系映射（ORM）對象關系映射ORM ORM(對象關系映射) Python開發【第十八篇】Web框架之Django【基礎篇】 Python Web框架【Django框架第一篇基礎】 QxOrm使用教程(ORM for C++ 對象關系映射) Django-ORM框架 python的web框架---Django項目 java框架篇---hibernate(一對一)映射關系