Django - 模型（model）-- ORM

時間 2019-12-14

標籤 django 模型 model orm 欄目 Python 简体版

原文原文鏈接

1、ORM介紹

ORM概念

對象關係映射（Object Relational Mapping，簡稱ORM）模式是一種爲了解決面向對象與關係數據庫存在的互不匹配的現象的技術。mysql

簡單的說，ORM是經過使用描述對象和數據庫之間映射的元數據，將程序中的對象自動持久化到關係數據庫中。git

ORM在業務邏輯層和數據庫層之間充當了橋樑的做用程序員

ORM由來

讓咱們從O/R開始。字母O起源於"對象"(Object),而R則來自於"關係"(Relational)。sql

幾乎全部的軟件開發過程當中都會涉及到對象和關係數據庫。在用戶層面和業務邏輯層面，咱們是面向對象的。當對象的信息發生變化的時候，咱們就須要把對象的信息保存在關係數據庫中。數據庫

按照以前的方式來進行開發就會出現程序員會在本身的業務邏輯代碼中夾雜不少SQL語句用來增長、讀取、修改、刪除相關數據，而這些代碼一般都是重複的。django

ORM優點

ORM解決的主要問題是對象和關係的映射。它一般把一個類和一個表一一對應，類的每一個實例對應表中的一條記錄，類的每一個屬性對應表中的每一個字段。後端

ORM提供了對數據庫的映射，不用直接編寫SQL代碼，只需像操做對象同樣從數據庫操做數據。app

讓軟件開發人員專一於業務邏輯的處理，提升了開發效率。ide

ORM劣勢

ORM的缺點是會在必定程度上犧牲程序的執行效率。函數

ORM用多了SQL語句就不會寫了，關係數據庫相關技能退化...

ORM總結

ORM只是一種工具，工具確實能解決一些重複，簡單的勞動。這是不能否認的。

但咱們不能期望某個工具能一勞永逸地解決全部問題，一些特殊問題仍是須要特殊處理的。

可是在整個軟件開發過程當中須要特殊處理的狀況應該都是不多的，不然所謂的工具也就失去了它存在的意義。

2、Django中的ORM

Django項目使用MySQL數據庫

1. 在Django項目的settings.py文件中，配置數據庫鏈接信息：

 1 DATABASES = {
 2     "default": {
 3         "ENGINE": "django.db.backends.mysql",
 4         "NAME": "你的數據庫名稱",  # 須要本身手動建立數據庫
 5         "USER": "數據庫用戶名",
 6         "PASSWORD": "數據庫密碼",
 7         "HOST": "數據庫IP",
 8         "POST": 3306
 9     }
10 }

2. 在Django項目的__init__.py文件中寫以下代碼，告訴Django使用pymysql模塊鏈接MySQL數據庫:

1 import pymysql
2 
3 pymysql.install_as_MySQLdb()

Model

在Django中model是你數據的單1、明確的信息來源。它包含了你存儲的數據的重要字段和行爲。一般，一個模型（model）映射到一個數據庫表，

基本狀況：

每一個模型都是一個Python類，它是django.db.models.Model的子類。
模型的每一個屬性都表明一個數據庫字段。

綜上所述，Django爲您提供了一個自動生成的數據庫訪問API，詳詢官方文檔連接：https://docs.djangoproject.com/en/2.0/topics/db/queries/

快速入門

下面這個例子定義了一個 Person 模型，包含 first_name 和 last_name。

1 from django.db import models
2 
3 class Person(models.Model):
4     first_name = models.CharField(max_length=30)
5     last_name = models.CharField(max_length=30)

first_name 和 last_name 是模型的字段。每一個字段被指定爲一個類屬性，每一個屬性映射到一個數據庫列。

上面的 Person 模型將會像這樣建立一個數據庫表：

1 CREATE TABLE myapp_person (
2     "id" serial NOT NULL PRIMARY KEY,
3     "first_name" varchar(30) NOT NULL,
4     "last_name" varchar(30) NOT NULL
5 );

一些說明：

表myapp_person的名稱是自動生成的，若是你要自定義表名，須要在model的Meta類中指定 db_table 參數，強烈建議使用小寫表名，特別是使用MySQL做爲後端數據庫時。
id字段是自動添加的，若是你想要指定自定義主鍵，只需在其中一個字段中指定 primary_key=True 便可。若是Django發現你已經明確地設置了Field.primary_key，它將不會添加自動ID列。
本示例中的CREATE TABLE SQL使用PostgreSQL語法進行格式化，但值得注意的是，Django會根據配置文件中指定的數據庫後端類型來生成相應的SQL語句。
Django支持MySQL5.5及更高版本。

字段

  1   AutoField(Field)
  2         - int自增列，必須填入參數 primary_key=True
  3 
  4     BigAutoField(AutoField)
  5         - bigint自增列，必須填入參數 primary_key=True
  6 
  7         注：當model中若是沒有自增列，則自動會建立一個列名爲id的列
  8         from django.db import models
  9 
 10         class UserInfo(models.Model):
 11             # 自動建立一個列名爲id的且爲自增的整數列
 12             username = models.CharField(max_length=32)
 13 
 14         class Group(models.Model):
 15             # 自定義自增列
 16             nid = models.AutoField(primary_key=True)
 17             name = models.CharField(max_length=32)
 18 
 19     SmallIntegerField(IntegerField):
 20         - 小整數 -32768 ～ 32767
 21 
 22     PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
 23         - 正小整數 0 ～ 32767
 24     IntegerField(Field)
 25         - 整數列(有符號的) -2147483648 ～ 2147483647
 26 
 27     PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
 28         - 正整數 0 ～ 2147483647
 29 
 30     BigIntegerField(IntegerField):
 31         - 長整型(有符號的) -9223372036854775808 ～ 9223372036854775807
 32 
 33     BooleanField(Field)
 34         - 布爾值類型
 35 
 36     NullBooleanField(Field):
 37         - 能夠爲空的布爾值
 38 
 39     CharField(Field)
 40         - 字符類型
 41         - 必須提供max_length參數， max_length表示字符長度
 42 
 43     TextField(Field)
 44         - 文本類型
 45 
 46     EmailField(CharField)：
 47         - 字符串類型，Django Admin以及ModelForm中提供驗證機制
 48 
 49     IPAddressField(Field)
 50         - 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制
 51 
 52     GenericIPAddressField(Field)
 53         - 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6
 54         - 參數：
 55             protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
 56             unpack_ipv4， 若是指定爲True，則輸入::ffff:192.0.2.1時候，可解析爲192.0.2.1，開啓此功能，須要protocol="both"
 57 
 58     URLField(CharField)
 59         - 字符串類型，Django Admin以及ModelForm中提供驗證 URL
 60 
 61     SlugField(CharField)
 62         - 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下劃線、鏈接符（減號）
 63 
 64     CommaSeparatedIntegerField(CharField)
 65         - 字符串類型，格式必須爲逗號分割的數字
 66 
 67     UUIDField(Field)
 68         - 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證
 69 
 70     FilePathField(Field)
 71         - 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能
 72         - 參數：
 73                 path,                      文件夾路徑
 74                 match=None,                正則匹配
 75                 recursive=False,           遞歸下面的文件夾
 76                 allow_files=True,          容許文件
 77                 allow_folders=False,       容許文件夾
 78 
 79     FileField(Field)
 80         - 字符串，路徑保存在數據庫，文件上傳到指定目錄
 81         - 參數：
 82             upload_to = ""      上傳文件的保存路徑
 83             storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage
 84 
 85     ImageField(FileField)
 86         - 字符串，路徑保存在數據庫，文件上傳到指定目錄
 87         - 參數：
 88             upload_to = ""      上傳文件的保存路徑
 89             storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage
 90             width_field=None,   上傳圖片的高度保存的數據庫字段名（字符串）
 91             height_field=None   上傳圖片的寬度保存的數據庫字段名（字符串）
 92 
 93     DateTimeField(DateField)
 94         - 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
 95 
 96     DateField(DateTimeCheckMixin, Field)
 97         - 日期格式      YYYY-MM-DD
 98 
 99     TimeField(DateTimeCheckMixin, Field)
100         - 時間格式      HH:MM[:ss[.uuuuuu]]
101 
102     DurationField(Field)
103         - 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值爲datetime.timedelta類型
104 
105     FloatField(Field)
106         - 浮點型
107 
108     DecimalField(Field)
109         - 10進制小數
110         - 參數：
111             max_digits，小數總長度
112             decimal_places，小數位長度
113 
114     BinaryField(Field)
115         - 二進制類型

字段

自定義字段

自定義一個無符號整數字段

 1 class UnsignedIntegerField(models.IntegerField):
 2     def db_type(self, connection):
 3         return 'integer UNSIGNED'
 4 
 5 PS: 返回值爲字段在數據庫中的屬性，Django字段默認的值爲：
 6     'AutoField': 'integer AUTO_INCREMENT',
 7     'BigAutoField': 'bigint AUTO_INCREMENT',
 8     'BinaryField': 'longblob',
 9     'BooleanField': 'bool',
10     'CharField': 'varchar(%(max_length)s)',
11     'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
12     'DateField': 'date',
13     'DateTimeField': 'datetime',
14     'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
15     'DurationField': 'bigint',
16     'FileField': 'varchar(%(max_length)s)',
17     'FilePathField': 'varchar(%(max_length)s)',
18     'FloatField': 'double precision',
19     'IntegerField': 'integer',
20     'BigIntegerField': 'bigint',
21     'IPAddressField': 'char(15)',
22     'GenericIPAddressField': 'char(39)',
23     'NullBooleanField': 'bool',
24     'OneToOneField': 'integer',
25     'PositiveIntegerField': 'integer UNSIGNED',
26     'PositiveSmallIntegerField': 'smallint UNSIGNED',
27     'SlugField': 'varchar(%(max_length)s)',
28     'SmallIntegerField': 'smallint',
29     'TextField': 'longtext',
30     'TimeField': 'time',
31     'UUIDField': 'char(32)',

自定義char類型字段：

 1 class FixedCharField(models.Field):
 2     """
 3     自定義的char類型的字段類
 4     """
 5     def __init__(self, max_length, *args, **kwargs):
 6         self.max_length = max_length
 7         super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)
 8 
 9     def db_type(self, connection):
10         """
11         限定生成數據庫表的字段類型爲char，長度爲max_length指定的值
12         """
13         return 'char(%s)' % self.max_length
14 
15 
16 class Class(models.Model):
17     id = models.AutoField(primary_key=True)
18     title = models.CharField(max_length=25)
19     # 使用自定義的char類型的字段
20     cname = FixedCharField(max_length=25)

建立的表結構：

注意事項

    1.觸發Model中的驗證和錯誤提示有兩種方式：

        a. Django Admin中的錯誤信息會優先根據Admiin內部的ModelForm錯誤信息提示，若是都成功，纔來檢查Model的字段並顯示指定錯誤信息

        b. 使用ModelForm

        c. 調用Model對象的 clean_fields 方法，如：

 # models.py

 1             class UserInfo(models.Model):
 2                 nid = models.AutoField(primary_key=True)
 3                 username = models.CharField(max_length=32)
 4 
 5                 email = models.EmailField(error_messages={'invalid': '格式錯了.'})
 6 
 7             # views.py
 8             def index(request):
 9                 obj = models.UserInfo(username='11234', email='uu')
10                 try:
11                     print(obj.clean_fields())
12                 except Exception as e:
13                     print(e)
14                 return HttpResponse('ok')
15 
16            # Model的clean方法是一個鉤子，可用於定製操做，如：上述的異常處理。

    2.Admin中修改錯誤提示

        # admin.py

 1         from django.contrib import admin
 2         from model_club import models
 3         from django import forms
 4 
 5 
 6         class UserInfoForm(forms.ModelForm):
 7             age = forms.IntegerField(initial=1, error_messages={'required': '請輸入數值.', 'invalid': '年齡必須爲數值.'})
 8 
 9             class Meta:
10                 model = models.UserInfo
11                 # fields = ('username',)
12                 fields = "__all__"
13                 exclude = ['title']
14                 labels = { 'name':'Writer', }
15                 help_texts = {'name':'some useful help text.',}
16                 error_messages={ 'name':{'max_length':"this writer name is too long"} }
17                 widgets={'name':Textarea(attrs={'cols':80,'rows':20})}
18 
19         class UserInfoAdmin(admin.ModelAdmin):
20             form = UserInfoForm
21 
22         admin.site.register(models.UserInfo, UserInfoAdmin)

字段參數

 1    null                數據庫中字段是否能夠爲空
 2     db_column           數據庫中字段的列名
 3     default             數據庫中字段的默認值
 4     primary_key         數據庫中字段是否爲主鍵
 5     db_index            數據庫中字段是否能夠創建索引
 6     unique              數據庫中字段是否能夠創建惟一索引
 7     unique_for_date     數據庫中字段【日期】部分是否能夠創建惟一索引
 8     unique_for_month    數據庫中字段【月】部分是否能夠創建惟一索引
 9     unique_for_year     數據庫中字段【年】部分是否能夠創建惟一索引
10 
11     verbose_name        Admin中顯示的字段名稱
12     blank               Admin中是否容許用戶輸入爲空
13     editable            Admin中是否能夠編輯
14     help_text           Admin中該字段的提示信息
15     choices             Admin中顯示選擇框的內容，用不變更的數據放在內存中從而避免跨表操做
16                         如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
17 
18     error_messages      自定義錯誤信息（字典類型），從而定製想要顯示的錯誤信息；
19                         字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
20                         如：{'null': "不能爲空.", 'invalid': '格式錯誤'}
21 
22     validators          自定義錯誤驗證（列表類型），從而定製想要的驗證規則
23                         from django.core.validators import RegexValidator
24                         from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
25                         MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
26                         如：
27                             test = models.CharField(
28                                 max_length=32,
29                                 error_messages={
30                                     'c1': '優先錯信息1',
31                                     'c2': '優先錯信息2',
32                                     'c3': '優先錯信息3',
33                                 },
34                                 validators=[
35                                     RegexValidator(regex='root_\d+', message='錯誤了', code='c1'),
36                                     RegexValidator(regex='root_112233\d+', message='又錯誤了', code='c2'),
37                                     EmailValidator(message='又錯誤了', code='c3'), ]

元信息

 1 class UserInfo(models.Model):
 2         nid = models.AutoField(primary_key=True)
 3         username = models.CharField(max_length=32)
 4         class Meta:
 5             # 數據庫中生成的表名稱 默認 app名稱 + 下劃線 + 類名
 6             db_table = "table_name"
 7 
 8             # 聯合索引
 9             index_together = [
10                 ("pub_date", "deadline"),
11             ]
12 
13             # 聯合惟一索引
14             unique_together = (("driver", "restaurant"),)
15 
16             # admin中顯示的表名稱
17             verbose_name
18 
19             # verbose_name加s
20             verbose_name_plural

多表關係和參數

  1 ForeignKey(ForeignObject) # ForeignObject(RelatedField)
  2         to,                         # 要進行關聯的表名
  3         to_field=None,              # 要關聯的表中的字段名稱
  4         on_delete=None,             # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲
  5                                         - models.CASCADE，刪除關聯數據，與之關聯也刪除
  6                                         - models.DO_NOTHING，刪除關聯數據，引起錯誤IntegrityError
  7                                         - models.PROTECT，刪除關聯數據，引起錯誤ProtectedError
  8                                         - models.SET_NULL，刪除關聯數據，與之關聯的值設置爲null（前提FK字段須要設置爲可空）
  9                                         - models.SET_DEFAULT，刪除關聯數據，與之關聯的值設置爲默認值（前提FK字段須要設置默認值）
 10                                         - models.SET，刪除關聯數據，
 11                                                       a. 與之關聯的值設置爲指定值，設置：models.SET(值)
 12                                                       b. 與之關聯的值設置爲可執行對象的返回值，設置：models.SET(可執行對象)
 13 
 14                                                         def func():
 15                                                             return 10
 16 
 17                                                         class MyModel(models.Model):
 18                                                             user = models.ForeignKey(
 19                                                                 to="User",
 20                                                                 to_field="id"
 21                                                                 on_delete=models.SET(func),)
 22         related_name=None,          # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all()
 23         related_query_name=None,    # 反向操做時，使用的鏈接前綴，用於替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
 24         limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯數據時，提供的條件：
 25                                     # 如：
 26                                             - limit_choices_to={'nid__gt': 5}
 27                                             - limit_choices_to=lambda : {'nid__gt': 5}
 28 
 29                                             from django.db.models import Q
 30                                             - limit_choices_to=Q(nid__gt=10)
 31                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
 32                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
 33         db_constraint=True          # 是否在數據庫中建立外鍵約束
 34         parent_link=False           # 在Admin中是否顯示關聯數據
 35 
 36 
 37     OneToOneField(ForeignKey)
 38         to,                         # 要進行關聯的表名
 39         to_field=None               # 要關聯的表中的字段名稱
 40         on_delete=None,             # 當刪除關聯表中的數據時，當前表與其關聯的行的行爲
 41 
 42                                     ###### 對於一對一 ######
 43                                     # 1. 一對一其實就是 一對多 + 惟一索引
 44                                     # 2.當兩個類之間有繼承關係時，默認會建立一個一對一字段
 45                                     # 以下會在A表中額外增長一個c_ptr_id列且惟一：
 46                                             class C(models.Model):
 47                                                 nid = models.AutoField(primary_key=True)
 48                                                 part = models.CharField(max_length=12)
 49 
 50                                             class A(C):
 51                                                 id = models.AutoField(primary_key=True)
 52                                                 code = models.CharField(max_length=1)
 53 
 54     ManyToManyField(RelatedField)
 55         to,                         # 要進行關聯的表名
 56         related_name=None,          # 反向操做時，使用的字段名，用於代替 【表名_set】 如： obj.表名_set.all()
 57         related_query_name=None,    # 反向操做時，使用的鏈接前綴，用於替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
 58         limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯數據時，提供的條件：
 59                                     # 如：
 60                                             - limit_choices_to={'nid__gt': 5}
 61                                             - limit_choices_to=lambda : {'nid__gt': 5}
 62 
 63                                             from django.db.models import Q
 64                                             - limit_choices_to=Q(nid__gt=10)
 65                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
 66                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
 67         symmetrical=None,           # 僅用於多對多自關聯時，symmetrical用於指定內部是否建立反向操做的字段
 68                                     # 作以下操做時，不一樣的symmetrical會有不一樣的可選字段
 69                                         models.BB.objects.filter(...)
 70 
 71                                         # 可選字段有：code, id, m1
 72                                             class BB(models.Model):
 73 
 74                                             code = models.CharField(max_length=12)
 75                                             m1 = models.ManyToManyField('self',symmetrical=True)
 76 
 77                                         # 可選字段有: bb, code, id, m1
 78                                             class BB(models.Model):
 79 
 80                                             code = models.CharField(max_length=12)
 81                                             m1 = models.ManyToManyField('self',symmetrical=False)
 82 
 83         through=None,               # 自定義第三張表時，使用字段用於指定關係表
 84         through_fields=None,        # 自定義第三張表時，使用字段用於指定關係表中那些字段作多對多關係表
 85                                         from django.db import models
 86 
 87                                         class Person(models.Model):
 88                                             name = models.CharField(max_length=50)
 89 
 90                                         class Group(models.Model):
 91                                             name = models.CharField(max_length=128)
 92                                             members = models.ManyToManyField(
 93                                                 Person,
 94                                                 through='Membership',
 95                                                 through_fields=('group', 'person'),
 96                                             )
 97 
 98                                         class Membership(models.Model):
 99                                             group = models.ForeignKey(Group, on_delete=models.CASCADE)
100                                             person = models.ForeignKey(Person, on_delete=models.CASCADE)
101                                             inviter = models.ForeignKey(
102                                                 Person,
103                                                 on_delete=models.CASCADE,
104                                                 related_name="membership_invites",
105                                             )
106                                             invite_reason = models.CharField(max_length=64)
107         db_constraint=True,         # 是否在數據庫中建立外鍵約束
108         db_table=None,              # 默認建立第三張表時，數據庫中表的名稱

多表關係和參數

3、ORM操做

基本操做

增

1 models.Tb1.objects.create(c1='xx', c2='oo')   # 增長一條數據，能夠接受字典類型數據 **kwargs
2 obj = models.Tb1(c1='xx', c2='oo')
3 obj.save()

查

1 models.Tb1.objects.get(id=123)  # 獲取單條數據，不存在則報錯（不建議）
2 models.Tb1.objects.all()  # 獲取所有
3 models.Tb1.objects.filter(name='seven')  # 獲取指定條件的數據
4 models.Tb1.objects.exclude(name='seven')  # 去除指定條件的數據

刪

1 models.Tb1.objects.filter(name='seven').delete()  # 刪除指定條件的數據

改

1 models.Tb1.objects.filter(name='seven').update(gender='0')   # 將指定條件的數據更新，均支持 **kwargs
2 obj = models.Tb1.objects.get(id=1)
3 obj.c1 = '111'
4 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等於十一、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)

進階操做

高級操做

 1 # extra
 2 # 在QuerySet的基礎上繼續執行子語句
 3 # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
 4 
 5 # select和select_params是一組，where和params是一組，tables用來設置from哪一個表
 6 # Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
 7 # Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
 8 # Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
 9 # Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
10 
11 舉個例子：
12 models.UserInfo.objects.extra(
13                     select={'newid':'select count(1) from app01_usertype where id>%s'},
14                     select_params=[1,],
15                     where = ['age>%s'],
16                     params=[18,],
17                     order_by=['-age'],
18                     tables=['app01_usertype']
19                 )
20                 """
21                 select 
22                     app01_userinfo.id,
23                     (select count(1) from app01_usertype where id>1) as newid
24                 from app01_userinfo,app01_usertype
25                 where 
26                     app01_userinfo.age > 18
27                 order by 
28                     app01_userinfo.age desc
29                 """
30 
31 
32 # 執行原生SQL
33 # 更高靈活度的方式執行原生SQL語句
34 # from django.db import connection, connections
35 # cursor = connection.cursor()  # cursor = connections['default'].cursor()
36 # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
37 # row = cursor.fetchone()

QuerySet相關方法

  1 ##################################################################
  2 # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
  3 ##################################################################
  4 
  5 def all(self)
  6     # 獲取全部的數據對象
  7 
  8 def filter(self, *args, **kwargs)
  9     # 條件查詢
 10     # 條件能夠是：參數，字典，Q
 11 
 12 def exclude(self, *args, **kwargs)
 13     # 條件查詢
 14     # 條件能夠是：參數，字典，Q
 15 
 16 def select_related(self, *fields)
 17     性能相關：表之間進行join連表操做，一次性獲取關聯的數據。
 18 
 19     總結：
 20     1. select_related主要針一對一和多對一關係進行優化。
 21     2. select_related使用SQL的JOIN語句進行優化，經過減小SQL查詢的次數來進行優化、提升性能。
 22 
 23 def prefetch_related(self, *lookups)
 24     性能相關：多表連表操做時速度會慢，使用其執行屢次SQL查詢在Python代碼中實現連表操做。
 25 
 26     總結：
 27     1. 對於多對多字段（ManyToManyField）和一對多字段，可使用prefetch_related()來進行優化。
 28     2. prefetch_related()的優化方式是分別查詢每一個表，而後用Python處理他們之間的關係。
 29 
 30 def annotate(self, *args, **kwargs)
 31     # 用於實現聚合group by查詢
 32 
 33     from django.db.models import Count, Avg, Max, Min, Sum
 34 
 35     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
 36     # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
 37 
 38     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
 39     # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
 40 
 41     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
 42     # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
 43 
 44 def distinct(self, *field_names)
 45     # 用於distinct去重
 46     models.UserInfo.objects.values('nid').distinct()
 47     # select distinct nid from userinfo
 48 
 49     注：只有在PostgreSQL中才能使用distinct進行去重
 50 
 51 def order_by(self, *field_names)
 52     # 用於排序
 53     models.UserInfo.objects.all().order_by('-id','age')
 54 
 55 def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
 56     # 構造額外的查詢條件或者映射，如：子查詢
 57 
 58     Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
 59     Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
 60     Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
 61     Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
 62 
 63  def reverse(self):
 64     # 倒序
 65     models.UserInfo.objects.all().order_by('-nid').reverse()
 66     # 注：若是存在order_by，reverse則是倒序，若是多個排序則一一倒序
 67 
 68 
 69  def defer(self, *fields):
 70     models.UserInfo.objects.defer('username','id')
 71     或
 72     models.UserInfo.objects.filter(...).defer('username','id')
 73     #映射中排除某列數據
 74 
 75  def only(self, *fields):
 76     #僅取某個表中的數據
 77      models.UserInfo.objects.only('username','id')
 78      或
 79      models.UserInfo.objects.filter(...).only('username','id')
 80 
 81  def using(self, alias):
 82      指定使用的數據庫，參數爲別名（setting中的設置）
 83 
 84 
 85 ##################################################
 86 # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
 87 ##################################################
 88 
 89 def raw(self, raw_query, params=None, translations=None, using=None):
 90     # 執行原生SQL
 91     models.UserInfo.objects.raw('select * from userinfo')
 92 
 93     # 若是SQL是其餘表時，必須將名字設置爲當前UserInfo對象的主鍵列名
 94     models.UserInfo.objects.raw('select id as nid from 其餘表')
 95 
 96     # 爲原生SQL設置參數
 97     models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])
 98 
 99     # 將獲取的到列名轉換爲指定列名
100     name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
101     Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)
102 
103     # 指定數據庫
104     models.UserInfo.objects.raw('select * from userinfo', using="default")
105 
106     ################### 原生SQL ###################
107     from django.db import connection, connections
108     cursor = connection.cursor()  # cursor = connections['default'].cursor()
109     cursor.execute("""SELECT * from auth_user where id = %s""", [1])
110     row = cursor.fetchone() # fetchall()/fetchmany(..)
111 
112 
113 def values(self, *fields):
114     # 獲取每行數據爲字典格式
115 
116 def values_list(self, *fields, **kwargs):
117     # 獲取每行數據爲元祖
118 
119 def dates(self, field_name, kind, order='ASC'):
120     # 根據時間進行某一部分進行去重查找並截取指定內容
121     # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
122     # order只能是："ASC"  "DESC"
123     # 並獲取轉換後的時間
124         - year : 年-01-01
125         - month: 年-月-01
126         - day  : 年-月-日
127 
128     models.DatePlus.objects.dates('ctime','day','DESC')
129 
130 def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
131     # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換爲指定時區時間
132     # kind只能是 "year", "month", "day", "hour", "minute", "second"
133     # order只能是："ASC"  "DESC"
134     # tzinfo時區對象
135     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
136     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))
137 
138     """
139     pip3 install pytz
140     import pytz
141     pytz.all_timezones
142     pytz.timezone(‘Asia/Shanghai’)
143     """
144 
145 def none(self):
146     # 空QuerySet對象
147 
148 
149 ####################################
150 # METHODS THAT DO DATABASE QUERIES #
151 ####################################
152 
153 def aggregate(self, *args, **kwargs):
154    # 聚合函數，獲取字典類型聚合結果
155    from django.db.models import Count, Avg, Max, Min, Sum
156    result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
157    ===> {'k': 3, 'n': 4}
158 
159 def count(self):
160    # 獲取個數
161 
162 def get(self, *args, **kwargs):
163    # 獲取單個對象
164 
165 def create(self, **kwargs):
166    # 建立對象
167 
168 def bulk_create(self, objs, batch_size=None):
169     # 批量插入
170     # batch_size表示一次插入的個數
171     objs = [
172         models.DDD(name='r11'),
173         models.DDD(name='r22')
174     ]
175     models.DDD.objects.bulk_create(objs, 10)
176 
177 def get_or_create(self, defaults=None, **kwargs):
178     # 若是存在，則獲取，不然，建立
179     # defaults 指定建立時，其餘字段的值
180     obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})
181 
182 def update_or_create(self, defaults=None, **kwargs):
183     # 若是存在，則更新，不然，建立
184     # defaults 指定建立時或更新時的其餘字段
185     obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})
186 
187 def first(self):
188    # 獲取第一個
189 
190 def last(self):
191    # 獲取最後一個
192 
193 def in_bulk(self, id_list=None):
194    # 根據主鍵ID進行查找
195    id_list = [11,21,31]
196    models.DDD.objects.in_bulk(id_list)
197 
198 def delete(self):
199    # 刪除
200 
201 def update(self, **kwargs):
202     # 更新
203 
204 def exists(self):
205    # 是否有結果
206 
207 其餘操做