Django之模型ORM
ORM介紹
ORM概念
對象關係映射（Object Relational Mapping，簡稱ORM）模式是一種爲了解決面向對象與關係數據庫存在的互不匹配的現象的技術。php
簡單的說，ORM是經過使用描述對象和數據庫之間映射的元數據，將程序中的對象自動持久化到關係數據庫中。html
ORM在業務邏輯層和數據庫層之間充當了橋樑的做用。java
ORM總結
ORM只是一種工具，工具確實能解決一些重複，簡單的勞動。這是不能否認的。python
但咱們不能期望某個工具能一勞永逸地解決全部問題，一些特殊問題仍是須要特殊處理的。mysql
可是在整個軟件開發過程當中須要特殊處理的狀況應該都是不多的，不然所謂的工具也就失去了它存在的意義。linux
Django中的ORM
Model
在Django中model是你數據的單1、明確的信息來源。它包含了你存儲的數據的重要字段和行爲。一般，一個模型（model）映射到一個數據庫表，sql
基本狀況：數據庫
- 每一個模型都是一個Python類，它是django.db.models.Model的子類。
- 模型的每一個屬性都表明一個數據庫字段。
- 綜上所述，Django爲您提供了一個自動生成的數據庫訪問API，詳詢官方文檔連接。
建立一個ORM過程
總結詳細步驟：
1. 手動建立數據庫 2. 在app/models.py裏面寫上一個類,必須繼承models.Model這個類 （注意啓動Django項目） 3. 在Django 項目的settings.py 裏面 配置上數據庫的相關信息 4. 在Django項目裏的__init__.py裏面寫上 兩句話 import pymysql pymysql.install_as_MySQLdb() 5. 給Django發佈命令 1. python manage.py makemigrations # 至關於去你的models.py 裏面看一下有沒有改動 2. python manage.py migrate # 把改動翻譯成SQL語句，而後去數據庫執行 models.py --> Django翻譯成SQL --> pymysql --> MySQL(4p)
總結一下：django
models.py MySQL
類 對應 數據表
類的屬性 對應 數據庫裏面的字段（列）
對象 對應 一行數據（一條數據）
ORM究竟是什麼？ --> 對象關係映射性能優化
ORM操做
# 增 1. models.Tb1(表名).objects.create(c1='xx', c2='oo') # 增長一條數據，能夠接受字典類型數據 **kwargs
models.Tb1(表名).objects.create(**｛｝)
2.obj = models.Tb1(c1='xx', c2='oo')
obj.save()
# 查
models.Tb1.objects.get(id=123) # 獲取單條數據，不存在則報錯（不建議）
models.Tb1.objects.all() # 獲取所有
models.Tb1.objects.filter(name='seven') # 獲取指定條件的數據 ，不知足條件不報錯，可是返回的結果是一個對象的列表
models.User.objects.filter().first() # 獲取指定條件的數據 ，的第一個
models.User.objects.filter().last()# 獲取指定條件的數據，的最後一個
models.Tb1.objects.exclude(name='seven') # 去除指定條件的數據 # 刪 # models.Tb1.objects.filter(name='seven').delete() # 刪除指定條件的數據 （不區分model對象和queryset對象） # 改 1.models.Tb1.objects.filter(name='seven').update(gender='0') # 將指定條件的數據更新，均支持 **kwargs
2. obj = models.Tb1.objects.get(id=1) #不建議使用，它是對id=1的整條記錄都進行「更改」(除c1是對進行更改外，其他都是進行賦值) obj.c1 = '111'
obj.save()
單表查詢API彙總
返回的是QuerySet對象 <1> all(): 查詢全部結果【】 <2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象(queryset),返回的是一個列表，取一個值時須要用索引或切片， 何時使用filter()何時使用get() 當filter().後面繼續使用的是Queryset對象時， 當get(). 後面跟的能夠是字段或表名 <4> exclude(**kwargs): 它包含了與所給篩選條件不匹配的對象 <5> values(*要顯示的字段): 返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列model的實例化對象，而是一個可迭代的字典序列 【】
l=[]
for obj in Book.objects.all():
temp={}
temp["title"]=obj.title
temp["id"]=obj.id
temp["publish__name"]=obj.publish.name # QuerySet() []
l.append(temp)
<6> values_list(*field): 它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列 <7> order_by(*field): 對查詢結果排序 正序 order_by(-*field): 對查詢結果排序 反序 <8> reverse(): 對查詢結果反向排序 <9> distinct(): 從返回結果中剔除重複紀錄(必須是知足全部條件都重複) 返回bool值 <3> exists(): 若是QuerySet包含數據，就返回True，不然返回False 判斷表裏有沒有數據用exists(),減小數據查詢 返回數字的： <10> count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。 返回具體的數據(model)對象： <11> first(): 返回第一條記錄 <12> last(): 返回最後一條記錄 <13> get(**kwargs): 返回與所給篩選條件相匹配的對象，返回結果有且只有一個，若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤
注意：必定區分Object與QuerySet的區別 ！！！
QuerySet有update方法而Object默認沒有。
單表查詢之神奇的雙下劃線
models.Tb1.objects.filter(id__gt=1, id__lt=10) # 獲取 id 大於1的值 且 id 小於10的值 models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於十一、2二、33的數據 models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in models.Tb1.objects.filter(name__contains="ven") # 獲取name字段包含"ven"的 models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感 models.Tb1.objects.filter(id__range=[1, 3]) # id範圍是1到3的，等價於SQL的bettwen and 相似的還有：startswith，istartswith, endswith, iendswith date字段還能夠： models.Class.objects.filter(first_day__year=2017) date字段還能夠： models.Class.objects.filter(first_day__year=2017 查詢某字段(sname)爲空的: models.Class.objects.cname__isnull=True
ORM跨表查詢
基於對象查詢（sql：子查詢） 一對多的關係 多對多的關係 一對一的關係 正向查詢,按字段（外鍵）：
反向查詢，按表名小寫_set：
基於Queryset和 __（sql：join語句）:
一對多的關係 多對多的關係 一對一的關係
正向查詢,按字段(外鍵)
反向查詢，按表名小寫
verbose_name
verbose_name： 能夠經過在 ForeignKey() 和ManyToManyField的定義中設置 related_name 的值來覆寫 FOO_set 的名稱。例如，若是 Article model 中作一下更改： publish = ForeignKey(Blog, related_name='bookList')，那麼接下來就會如咱們看到這般： # 查詢 人民出版社出版過的全部書籍（反向:表名_set） publish=Publish.objects.get(name="人民出版社") book_list=publish.bookList.all() # 與人民出版社關聯的全部書籍對象集合
######################################################################
# print(type(obj._meta))# print(obj._meta.related_objects) #獲取關聯當前表(obj)的全部字段對象集合 from django.db.models.fields.reverse_related import ManyToOneRel for obj_related_field in obj._meta.related_objects: print(obj_related_field.field_name) # 關聯字段對象的to_field的值 print(obj_related_field.related_name) # 反向查詢別名，每張表中的名字惟一 print(obj_related_field.limit_choices_to) # 篩選條件（limit_choices_to=[條件]，對被關聯的表條件限制） print(obj_related_field.to) # 關聯字段關聯的表 print(obj_related_field.field.model._meta.model_name) # 關聯字段對應的model
ORM 跨表查詢 class Book(models.Model): title = models.CharField( max_length=32) publish=models.ForeignKey(to="Publish",to_field="id") authors=models.ManyToManyField(to='Author',related_name='bookList') class Publish(models.Model): name=models.CharField( max_length=32) class Author(models.Model): name=models.CharField( max_length=32) ad=models.OneToOneField("AuthorDetail") class AuthorDetail(models.Model): telephone=models.BigIntegerField() 基於對象查詢（sql：子查詢） 一對多的關係 (Publish--Book) 正向查詢,按字段（外鍵）： 查詢python這本書的出版社所在的名稱 book_obj=Book.objects.filter(title="python").first() #print(book_obj.publish.name) 反向查詢，按表名小寫_set： 人民出版社出版過的全部書籍名稱 publish_obj=Publish.objects.filter(name="人民出版社出版").first() print(publish_obj.book_set.all()) for obj in publish_obj.book_set.all(): print(obj.title) 多對多的關係 正向查詢,按字段： python這本書全部做者的名字 book_obj=Book.objects.filter(title="python").first() book_obj.authors.all() 反向查詢，按表名小寫_set： alex出版過的全部書籍名稱 alex=Author.objects.filter(name="alex").first() alex.bookList.all() 一對一的關係 正向查詢,按字段： 查詢alex的手機號 alex=Author.objects.filter(name="alex").first() alex.ad.telephone 反向查詢：按表名小寫 以151開頭的手機號的做者的名字 ad=AuthorDetail.objects.get(telephone__startswith="151") ad.author.name 基於Queryset和 __（sql：join語句）: 正向查詢,按字段(外鍵) 反向查詢，按表名小寫 一對多的關係 (Publish--Book) 查詢python這本書的所在出版社的名稱 Book.objects.filter(title="python").values("publish__name") #原理 for obj in Book.objects.filter(title="python"): temp={} temp["publish__name"]=obj.publish.name 人民出版社出版過的全部書籍名稱 Publish.objects.filter(name="人民出版社出版").values("book__title") 多對多的關係 python這本書全部做者的名字 Book.objects.filter(title="python").values("authors__name") alex出版過的全部書籍名稱 Author.objects.filter(name="alex").values("book__title") 一對一的關係 查詢alex的手機號 Author.objects.filter(name="alex").values("ad__telephone") 以151開頭的手機號的做者的名字 AuthorDetail.objects.filter(telephone__startswith="151").values("author__name") 擴展： 練習1： 查詢python這本書的所在出版社的名稱 Book.objects.filter(title="python").values("publish__name") Publish.objects.filter(book__title="python").values("name") 練習2： 手機號以151開頭的做者出版過的全部書籍名稱以及出版社名稱 Book.objects.filter(authors__ad__telephone__startswith="151").values("title","publish__name") 聚合： 計算全部圖書的平均價格： book.objects.all().aggregate(Avg("price")) 分組查詢： 查詢每個出版社出版過的書籍個數 Publish.objects.annotate(Count("book__id")) select count(*) from publish group by id SELECT "app01_publish"."name", COUNT("app01_book"."id") AS "c" FROM "app01_publish" LEFT OUTER JOIN "app01_book" ON ("app01_publish"."id" = "app01_book"."publish_id") GROUP BY "app01_publish"."id", "app01_publish"."name" publish: book: id name id title publish_id 1 A 1 python 1 2 B 2 go 1 3 C 3 linux 2 4 php 3 5 java 3 publish-book: nid publish_id publish_name book_id book_title publish_id 1 1 A 1 python 1 2 1 A 2 go 1 3 2 B 3 linux 2 4 3 C 4 php 3 5 3 C 5 java 3
ORM特殊查詢
#表名小寫 book.model._meta.model_name #book所在app名 book.model._meta.app_label #獲取book表下name字段對象，能夠對象.屬性（field_obj.verbose_name） field_obj=book.model._meta.get_field(name)
多對多對應關係建表方法
# 第一種 自定義第三張表，經過外鍵與其餘兩張表關聯 class TeacherToClass(models.Model): tid=models.ForeignKey("Teacher") cid=models.ForeignKey("Class") #聯合惟一，不能同時相等 class Meta: unique_together=[("tid","cid"),] # 第二種 老師表 經過ManyToManyField直接建立 # 自動建立第三張關係表，沒有相關類與其對應，不能使用ORM單獨操做 #可是可使用Django封裝的方式法 class Teacher(models.Model): tname=models.CharField(max_length=32) cid=models.ManyToManyField(to="Class",related_name="teacher") # Teaccher.cid 是Djando自帶的功能，是一箇中間橋樑(關聯表)，由於Teacher表和Class表沒有直接關係 #Django把關係包裝成一個具體的對象（Teaccher.cid.字段(class表中)） def __str__(self): return self.tname #第三種 經過外鍵和ManyToManyField 手動建立關聯表（中間模型） #能夠增長第三張表的字段，能夠單獨用第三張表進行相關操做 #不能用Django ORM 多對多操做的語法（add，set，remove，clear） class Teacher(models.Model): tname = models.CharField(max_length=32) cid = models.ManyToManyField(to="Class", through="Teacher2Class", through_fields=("tid", "cid")) class Teacher2Class(models.Model): tid = models.ForeignKey(to="Teacher") cid = models.ForeignKey(to="Class") class Meta: unique_together = ("tid", "cid")
注意事項
1.觸發Model中的驗證和錯誤提示有兩種方式： a. Django Admin中的錯誤信息會優先根據Admiin內部的ModelForm錯誤信息提示，若是都成功，纔來檢查Model的字段並顯示指定錯誤信息 b. 使用ModelForm c. 調用Model對象的 clean_fields 方法，如： # models.py class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) email = models.EmailField(error_messages={'invalid': '格式錯了.'}) # views.py def index(request): obj = models.UserInfo(username='11234', email='uu') try: print(obj.clean_fields()) except Exception as e: print(e) return HttpResponse('ok') # Model的clean方法是一個鉤子，可用於定製操做，如：上述的異常處理。 2.Admin中修改錯誤提示 # admin.py from django.contrib import admin from model_club import models from django import forms class UserInfoForm(forms.ModelForm): age = forms.IntegerField(initial=1, error_messages={'required': '請輸入數值.', 'invalid': '年齡必須爲數值.'}) class Meta: model = models.UserInfo # fields = ('username',) fields = "__all__" exclude = ['title'] labels = { 'name':'Writer', } help_texts = {'name':'some useful help text.',} error_messages={ 'name':{'max_length':"this writer name is too long"} } widgets={'name':Textarea(attrs={'cols':80,'rows':20})} class UserInfoAdmin(admin.ModelAdmin): form = UserInfoForm admin.site.register(models.UserInfo, UserInfoAdmin)
字段參數
null 數據庫中字段是否能夠爲空 db_column 數據庫中字段的列名 default 數據庫中字段的默認值 primary_key 數據庫中字段是否爲主鍵 db_index 數據庫中字段是否能夠創建索引 unique 數據庫中字段是否能夠創建惟一索引 unique_for_date 數據庫中字段【日期】部分是否能夠創建惟一索引 unique_for_month 數據庫中字段【月】部分是否能夠創建惟一索引 unique_for_year 數據庫中字段【年】部分是否能夠創建惟一索引 verbose_name Admin中顯示的字段名稱 blank Admin中是否容許用戶輸入爲空 editable Admin中是否能夠編輯 help_text Admin中該字段的提示信息 choices Admin中顯示選擇框的內容，用不變更的數據放在內存中從而避免跨表操做 如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1) error_messages 自定義錯誤信息（字典類型），從而定製想要顯示的錯誤信息； 字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date 如：{'null': "不能爲空.", 'invalid': '格式錯誤'} validators 自定義錯誤驗證（列表類型），從而定製想要的驗證規則 from django.core.validators import RegexValidator from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\ MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator 如： test = models.CharField( max_length=32, error_messages={ 'c1': '優先錯信息1', 'c2': '優先錯信息2', 'c3': '優先錯信息3', }, validators=[ RegexValidator(regex='root_\d+', message='錯誤了', code='c1'), RegexValidator(regex='root_112233\d+', message='又錯誤了', code='c2'), EmailValidator(message='又錯誤了', code='c3'), ] )
元信息
class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) class Meta: # 數據庫中生成的表名稱 默認 app名稱 + 下劃線 + 類名 db_table = "table_name" # 聯合索引 index_together = [ ("pub_date", "deadline"), ] # 聯合惟一索引 unique_together = (("driver", "restaurant"),) # admin中顯示的表名稱 verbose_name # verbose_name加s verbose_name_plural
多表關係和參數
ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要進行關聯的表名 to_field=None, # 要關聯的表中的字段名稱 on_delete=None, # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲 - models.CASCADE，刪除關聯數據，與之關聯也刪除 - models.DO_NOTHING，刪除關聯數據，引起錯誤IntegrityError - models.PROTECT，刪除關聯數據，引起錯誤ProtectedError - models.SET_NULL，刪除關聯數據，與之關聯的值設置爲null（前提FK字段須要設置爲可空） - models.SET_DEFAULT，刪除關聯數據，與之關聯的值設置爲默認值（前提FK字段須要設置默認值） - models.SET，刪除關聯數據， a. 與之關聯的值設置爲指定值，設置：models.SET(值) b. 與之關聯的值設置爲可執行對象的返回值，設置：models.SET(可執行對象) def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id" on_delete=models.SET(func),) related_name=None, # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操做時，使用的鏈接前綴，用於替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中顯示關聯數據時，提供的條件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') db_constraint=True # 是否在數據庫中建立外鍵約束 parent_link=False # 在Admin中是否顯示關聯數據 OneToOneField(ForeignKey) to, # 要進行關聯的表名 to_field=None # 要關聯的表中的字段名稱 on_delete=None, # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲 ###### 對於一對一 ###### # 1. 一對一其實就是 一對多 + 惟一索引 # 2.當兩個類之間有繼承關係時，默認會建立一個一對一字段 # 以下會在A表中額外增長一個c_ptr_id列且惟一： class C(models.Model): nid = models.AutoField(primary_key=True) part = models.CharField(max_length=12) class A(C): id = models.AutoField(primary_key=True) code = models.CharField(max_length=1) ManyToManyField(RelatedField) to, # 要進行關聯的表名 related_name=None, # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操做時，使用的鏈接前綴，用於替換【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中顯示關聯數據時，提供的條件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') symmetrical=None, # 僅用於多對多自關聯時，symmetrical用於指定內部是否建立反向操做的字段 # 作以下操做時，不一樣的symmetrical會有不一樣的可選字段 models.BB.objects.filter(...) # 可選字段有：code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可選字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定義第三張表時，使用字段用於指定關係表 through_fields=None, # 自定義第三張表時，使用字段用於指定關係表中那些字段作多對多關係表 from django.db import models class Person(models.Model): name = models.CharField(max_length=50) class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField( Person, through='Membership', through_fields=('group', 'person'), ) class Membership(models.Model): group = models.ForeignKey(Group, on_delete=models.CASCADE) person = models.ForeignKey(Person, on_delete=models.CASCADE) inviter = models.ForeignKey( Person, on_delete=models.CASCADE, related_name="membership_invites", ) invite_reason = models.CharField(max_length=64) db_constraint=True, # 是否在數據庫中建立外鍵約束 db_table=None, # 默認建立第三張表時，數據庫中表的名稱 多表關係和參數
進階操做
# 獲取個數 # # models.Tb1.objects.filter(name='seven').count() # 大於，小於 # # models.Tb1.objects.filter(id__gt=1) # 獲取id大於1的值 # models.Tb1.objects.filter(id__gte=1) # 獲取id大於等於1的值 # models.Tb1.objects.filter(id__lt=10) # 獲取id小於10的值 # models.Tb1.objects.filter(id__lte=10) # 獲取id小於10的值 # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值 # in # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於十一、2二、33的數據 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # isnull # Entry.objects.filter(pub_date__isnull=True) # contains # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感 # models.Tb1.objects.exclude(name__icontains="ven") # range # # models.Tb1.objects.filter(id__range=[1, 2]) # 範圍bettwen and # 其餘相似 # # startswith，istartswith, endswith, iendswith, # order by # # models.Tb1.objects.filter(name='seven').order_by('id') # asc # models.Tb1.objects.filter(name='seven').order_by('-id') # desc # group by # # from django.db.models import Count, Min, Max, Sum # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num')) # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset # # models.Tb1.objects.all()[10:20] # regex正則匹配，iregex 不區分大小寫 # # Entry.objects.get(title__regex=r'^(An?|The) +') # Entry.objects.get(title__iregex=r'^(an?|the) +') # date # # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1)) # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year # # Entry.objects.filter(pub_date__year=2005) # Entry.objects.filter(pub_date__year__gte=2005) # month # # Entry.objects.filter(pub_date__month=12) # Entry.objects.filter(pub_date__month__gte=6) # day # # Entry.objects.filter(pub_date__day=3) # Entry.objects.filter(pub_date__day__gte=3) # week_day # # Entry.objects.filter(pub_date__week_day=2) # Entry.objects.filter(pub_date__week_day__gte=2) # hour # # Event.objects.filter(timestamp__hour=23) # Event.objects.filter(time__hour=5) # Event.objects.filter(timestamp__hour__gte=12) # minute # # Event.objects.filter(timestamp__minute=29) # Event.objects.filter(time__minute=46) # Event.objects.filter(timestamp__minute__gte=29) # second # # Event.objects.filter(timestamp__second=31) # Event.objects.filter(time__second=2) # Event.objects.filter(timestamp__second__gte=31)
高級操做
# extra # 在QuerySet的基礎上繼續執行子語句 # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # select和select_params是一組，where和params是一組，tables用來設置from哪一個表 # 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']) 舉個例子： models.UserInfo.objects.extra( select={'newid':'select count(1) from app01_usertype where id>%s'}, select_params=[1,], where = ['age>%s'], params=[18,], order_by=['-age'], tables=['app01_usertype'] ) """ select app01_userinfo.id, (select count(1) from app01_usertype where id>1) as newid from app01_userinfo,app01_usertype where app01_userinfo.age > 18 order by app01_userinfo.age desc """ # 執行原生SQL # 更高靈活度的方式執行原生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()
QuerySet相關方法
################################################################## # 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 select_related(self, *fields) 性能相關：表之間進行join連表操做，一次性獲取關聯的數據。 總結： 1. select_related主要針一對一和多對一關係進行優化。 2. select_related使用SQL的JOIN語句進行優化，經過減小SQL查詢的次數來進行優化、提升性能。 def prefetch_related(self, *lookups) 性能相關：多表連表操做時速度會慢，使用其執行屢次SQL查詢在Python代碼中實現連表操做。 總結： 1. 對於多對多字段（ManyToManyField）和一對多字段，可使用prefetch_related()來進行優化。 2. prefetch_related()的優化方式是分別查詢每一個表，而後用Python處理他們之間的關係。 def annotate(self, *args, **kwargs) # 用於實現聚合group by查詢 from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # 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 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 aggregate(self, *args, **kwargs): # 聚合函數，獲取字典類型聚合結果 from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> {'k': 3, 'n': 4} 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) def delete(self): # 刪除 def update(self, **kwargs): # 更新 def exists(self): # 是否有結果 其餘操做
Dajngo數據庫操做
Django項目使用MySQL數據庫
1. 在Django項目的settings.py文件中，配置數據庫鏈接信息：
DATABASES = {
"default": {
"ENGINE": "django.db.backends.mysql",
"NAME": "你的數據庫名稱", # 須要本身手動建立數據庫
"USER": "數據庫用戶名",
"PASSWORD": "數據庫密碼",
"HOST": "數據庫IP",
"POST": 3306
}
}
2. 在Django項目的__init__.py文件中寫以下代碼，告訴Django使用pymysql模塊鏈接MySQL數據庫:
import pymysql pymysql.install_as_MySQLdb()
多數據庫操做
model.py
from django.db import models class UserType(models.Model): title = models.CharField(max_length=32) def __str__(self): return self.title class UserInfo(models.Model): name = models.CharField(max_length=32) email = models.CharField(max_length=32) ut = models.ForeignKey(to='UserType',db_constraint=False)
seetings.py
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), }, 'db1': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db1.sqlite3'), } }
數據化遷移：
一、python manage.py makemigraions
#將哪一個app下的表遷移到哪一個數據庫
二、python manage.py migrate app01 --database=db1
views.py
一、手動操做
using()選擇數據庫
#選擇哪一個數據庫插入數據 models.UserType.objects.using('db1').create(title='普通用戶')
#選擇查詢哪一個數據庫數據 result = models.UserType.objects.all().using('default')
二、自動操做
1、建立db_router.py文件 2、在settings.py中配置 DATABASE_ROUTERS = ['db_router.Router1',] db_router.py class Router1: #讀數據時選擇db1數據庫 def db_for_read(self, model, **hints): """ Attempts to read auth models go to auth_db. """ return 'db1' #寫數據時選擇default數據庫 def db_for_write(self, model, **hints): """ Attempts to write auth models go to auth_db. """ return 'default'
views.py
#寫操做
models.UserType.objects.create(title='VVIP')
#讀操做
result = models.UserType.objects.all()
補充：更細粒度的操做
class Router1:
def db_for_read(self, model, **hints):
#若是讀usertype表時，使用db1數據庫;讀其餘表時,使用default數據庫
if model._meta.model_name == 'usertype':
return 'db1'
else:
return 'default'
def db_for_write(self, model, **hints):
return 'default'
分庫
app01中的表在default數據庫建立
app02中的表在db1數據庫建立
# 第一步： python manage.py makemigraions # 第二步： app01中的表在default數據庫建立 python manage.py migrate app01 --database=default # 第三步： app02中的表在db1數據庫建立 python manage.py migrate app02 --database=db1
手動操做：
m1.UserType.objects.using('default').create(title='VVIP') m2.Users.objects.using('db1').create(name='VVIP',email='xxx')
自動操做：和上面步驟同樣
db_router.py
class Router1: def db_for_read(self, model, **hints):
#讀app01下的表時，使用default數據庫 if model._meta.app_label == 'app01': return 'default' else: return 'db1' def db_for_write(self, model, **hints):
#對app01下的表寫入數據時，使用defalut數據庫 if model._meta.app_label == 'app01': return 'default' else: return 'db1'
views.py
m1.UserType.objects.using('default').create(title='VVIP')
m2.Users.objects.using('db1').create(name='VVIP',email='xxx')
約束數據化遷移
class Router1: def allow_migrate(self, db, app_label, model_name=None, **hints):
#數據化遷移時，必須知足將app02下的表放入db1數據庫中，不然遷移不成功 if db=='db1' and app_label == 'app02': return True elif db == 'default' and app_label == 'app01': return True else: return False # 若是返回None，那麼表示交給後續的router，若是後續沒有router，則至關於返回True
def db_for_write(self, model, **hints):
pass
性能優化查詢
待續......
相關文章
- 1. Django之模型
- 2. 【django系列學習筆記】Django 模型（M）- (2)模型的操做
- 3. 【django系列學習筆記】Django 模型（M）- (1)模型的定義
- 4. django 之MTV模型
- 5. Django之模型層
- 6. Django之ORM模型
- 7. ThinkPHP---thinkphp模型（M）
- 8. G-P-M 模型
- 9. Django-MVT之M層總結
- 10. Django之模型層（1）
- 更多相關文章...
- • ASP.NET MVC - 模型 - ASP.NET 教程
- • Scala 模式匹配 - Scala教程
- • 委託模式
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
