ORM操做

今天閒來無事簡單談下ORM操做。

一：前言

1.什麼是ORM

    ORM，即Object-Relational Mapping（對象關係映射），它的做用是在關係型數據庫和業務實體對象之間做一個映射，這樣，咱們在具體的操做業務對象的時候，就不須要再去和複雜的SQL語句打交道，只需簡單的操做對象的屬性和方法。

2.爲何會出現ORM思想

    先從項目中數據流存儲形式這個角度提及.簡單拿MVC這種分層模式.來講. Model做爲數據承載實體. 在用戶界面層和業務邏輯層之間數據實現面向對象OO形式傳遞. 當咱們須要經過Control層分發請求把數據持久化時咱們會發現.  內存中的面向對象的OO如何持久化成關係型數據中存儲一條實際數據記錄呢？

     面向對象是從軟件工程基本原則(如耦合、聚合、封裝)的基礎上發展起來的，而關係數據庫則是從數學理論發展而來的.  二者之間是不匹配的.而ORM做爲項目中間件形式實現數據在不一樣場景下數據關係映射. 對象關係映射（Object Relational Mapping，簡稱ORM）是一種爲了解決面向對象與關係數據庫存在的互不匹配的現象的技術.ORM就是這樣而來的。

3.優缺點

優勢：

    第一：隱藏了數據訪問細節，「封閉」的通用數據庫交互，ORM的核心。他使得咱們的通用數據庫交互變得簡單易行，而且徹底不用考慮該死的SQL語句。快速開發，由此而來。

    第二：ORM使咱們構造固化數據結構變得簡單易行。在ORM年表的史前時代，咱們須要將咱們的對象模型轉化爲一條一條的SQL語句，經過直連或是DB helper在關係數據庫構造咱們的數據庫體系。而如今，基本上全部的ORM框架都提供了經過對象模型構造關係數據庫結構的功能。

缺點：

    第一：無可避免的，自動化意味着映射和關聯管理，代價是犧牲性能（早期，這是全部不喜歡ORM人的共同點）。如今的各類ORM框架都在嘗試使用各類方法來減輕這塊（LazyLoad，Cache），效果仍是很顯著的。

    第二：面向對象的查詢語言(X-QL)做爲一種數據庫與對象之間的過渡,雖然隱藏了數據層面的業務抽象,但並不能徹底的屏蔽掉數據庫層的設計,而且無疑將增長學習成本。

    第三：對於複雜查詢，ORM仍然力不從心。雖然能夠實現，可是不值的。視圖能夠解決大部分calculated column，case ，group，having,order by, exists，可是查詢條件(a and b and not c and (d or d))。

    世上沒有驢是不吃草的(又想好又想巧,買個老驢不吃草)，任何優點的背後都隱藏着缺點，這是不可避免的。問題在於，咱們是否能容忍缺點。

4.經常使用的ORM框架

   （1）Hibernate全自動須要些hql語句。

   （2）iBATIS半自動本身寫sql語句,可操做性強,小巧。

   （3）EclipseLink 一個可擴展的支持JPA的ORM框架，供強大的緩存功能，緩存支持集羣。

   （4）Apache OJB等等....

二：Django鏈接MySQL

1.建立數據庫 （注意設置 數據的字符編碼）

因爲Django自帶的orm是data_first類型的ORM，使用前必須先建立數據庫

 1 create database db1 default character set utf8 collate utf8_general_ci; 

2.修改project中的settings.py文件中設置  鏈接 MySQL數據庫（Django默認使用的是sqllite數據庫）

 1 DATABASES = {
 2     'default': {
 3     'ENGINE': 'django.db.backends.mysql',
 4     'NAME':'db1',
 5     'USER': 'root',
 6     'PASSWORD': '',
 7     'HOST': 'localhost',
 8     'PORT': '3306',
 9     }
10 }

擴展：查看orm操做執行的原生SQL語句在project中的settings.py文件增長

 1 LOGGING = {
 2     'version': 1,
 3     'disable_existing_loggers': False,
 4     'handlers': {
 5         'console':{
 6             'level':'DEBUG',
 7             'class':'logging.StreamHandler',
 8         },
 9     },
10     'loggers': {
11         'django.db.backends': {
12             'handlers': ['console'],
13             'propagate': True,
14             'level':'DEBUG',
15         },
16     }
17 }

3.修改project 中的__init__py 文件設置 Django默認鏈接MySQL的方 

 import pymysql pymysql.install_as_MySQLdb() 

4.setings文件註冊APP

 1 INSTALLED_APPS = [
 2     'django.contrib.admin',
 3     'django.contrib.auth',
 4     'django.contrib.contenttypes',
 5     'django.contrib.sessions',
 6     'django.contrib.messages',
 7     'django.contrib.staticfiles',
 8     'app01.apps.App01Config',
 9    
10 ]

5.models.py建立表

 1 from django.db import models
 2 class UserType(models.Model):
 3     """
 4     用戶類型
 5     """
 6     title = models.CharField(max_length=32)
 7 
 8 
 9 class UserInfo(models.Model):
10     """
11     用戶表
12     """
13     name = models.CharField(max_length=32)
14     age = models.IntegerField()
15     ut = models.ForeignKey('UserType',on_delete=models.CASCADE)

6.進行數據遷移

6.1在winds cmd或者Linux shell的項目的manage.py目錄下執行

 python manage.py makemigrations      python manage.py migrate 

擴展：修改表以後常見報錯

這個報錯：由於表建立好以後，新增字段沒有設置默認值，或者原來表中字段設置了不能爲空參數，修改後的表結構和目前的數據衝突致使；

三：modles.py建立表

ORM字段介紹

Django提供了不少字段類型，好比URL/Email/IP/ 可是mysql數據沒有這些類型，這類型存儲到數據庫上本質是字符串數據類型,其主要目的是爲了封裝底層SQL語句；

1.字符串類（如下都是在數據庫中本質都是字符串數據類型，此類字段只是在Django自帶的admin中生效）

 

 1 name=models.CharField(max_length=32)
 2 
 3 
 4 EmailField(CharField)：
 5 IPAddressField(Field)
 6 URLField(CharField)
 7 SlugField(CharField)
 8 UUIDField(Field)
 9 FilePathField(Field)
10 FileField(Field)
11 ImageField(FileField)
12 CommaSeparatedIntegerField(CharField)

 

擴展

models.CharField  對應的是MySQL的varchar數據類型

char 和 varchar的區別 :

char和varchar的共同點是存儲數據的長度，不能 超過max_length限制，

不一樣點是varchar根據數據實際長度存儲，char按指定max_length（）存儲數據；全部前者更節省硬盤空間；

 

2.時間字段

models.DateTimeField(null=True)

date=models.DateField()

 

3.數字字段

(max_digits=30,decimal_places=10)總長度30小數位 10位）

 

1 數字：
2 num = models.IntegerField()
3 num = models.FloatField() 浮點
4 price=models.DecimalField(max_digits=8,decimal_places=3) 精確浮點

 

4.枚舉字段

1 choice=(
2         (1,'男人'),
3         (2,'女人'),
4       5     )
6 lovely=models.IntegerField(choices=choice) #枚舉類型

擴展

在數據庫存儲枚舉類型，比外鍵有什麼優點？

1.無需連表查詢性能低，省硬盤空間(選項不固定時用外鍵)

2.在modle文件裏不能動態增長（選項一成不變用Django的choice）

3.ForeignKey用於動態選項。

    

其餘字段

 1 db_index = True 表示設置索引
 2 unique(惟一的意思) = True 設置惟一索引
 3 
 4 聯合惟一索引
 5 class Meta:
 6 unique_together = (
 7  ('email','ctime'),
 8 )
 9 聯合索引（不作限制）
10 index_together = (
11 ('email','ctime'),
12 )
13 
14 ManyToManyField(RelatedField)  #多對多操做

字段參數介紹

1.數據庫級別生效

  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     自定義無符號整數字段
 34 
 35         class UnsignedIntegerField(models.IntegerField):
 36             def db_type(self, connection):
 37                 return 'integer UNSIGNED'
 38 
 39         PS: 返回值爲字段在數據庫中的屬性，Django字段默認的值爲：
 40             'AutoField': 'integer AUTO_INCREMENT',
 41             'BigAutoField': 'bigint AUTO_INCREMENT',
 42             'BinaryField': 'longblob',
 43             'BooleanField': 'bool',
 44             'CharField': 'varchar(%(max_length)s)',
 45             'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
 46             'DateField': 'date',
 47             'DateTimeField': 'datetime',
 48             'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
 49             'DurationField': 'bigint',
 50             'FileField': 'varchar(%(max_length)s)',
 51             'FilePathField': 'varchar(%(max_length)s)',
 52             'FloatField': 'double precision',
 53             'IntegerField': 'integer',
 54             'BigIntegerField': 'bigint',
 55             'IPAddressField': 'char(15)',
 56             'GenericIPAddressField': 'char(39)',
 57             'NullBooleanField': 'bool',
 58             'OneToOneField': 'integer',
 59             'PositiveIntegerField': 'integer UNSIGNED',
 60             'PositiveSmallIntegerField': 'smallint UNSIGNED',
 61             'SlugField': 'varchar(%(max_length)s)',
 62             'SmallIntegerField': 'smallint',
 63             'TextField': 'longtext',
 64             'TimeField': 'time',
 65             'UUIDField': 'char(32)',
 66 
 67     BooleanField(Field)
 68         - 布爾值類型
 69 
 70     NullBooleanField(Field):
 71         - 能夠爲空的布爾值
 72 
 73     CharField(Field)
 74         - 字符類型
 75         - 必須提供max_length參數， max_length表示字符長度
 76 
 77     TextField(Field)
 78         - 文本類型
 79 
 80     EmailField(CharField)：
 81         - 字符串類型，Django Admin以及ModelForm中提供驗證機制
 82 
 83     IPAddressField(Field)
 84         - 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制
 85 
 86     GenericIPAddressField(Field)
 87         - 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6
 88         - 參數：
 89             protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
 90             unpack_ipv4， 若是指定爲True，則輸入::ffff:192.0.2.1時候，可解析爲192.0.2.1，開啓刺功能，須要protocol="both"
 91 
 92     URLField(CharField)
 93         - 字符串類型，Django Admin以及ModelForm中提供驗證 URL
 94 
 95     SlugField(CharField)
 96         - 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下劃線、鏈接符（減號）
 97 
 98     CommaSeparatedIntegerField(CharField)
 99         - 字符串類型，格式必須爲逗號分割的數字
100 
101     UUIDField(Field)
102         - 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證
103 
104     FilePathField(Field)
105         - 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能
106         - 參數：
107                 path,                      文件夾路徑
108                 match=None,                正則匹配
109                 recursive=False,           遞歸下面的文件夾
110                 allow_files=True,          容許文件
111                 allow_folders=False,       容許文件夾
112 
113     FileField(Field)
114         - 字符串，路徑保存在數據庫，文件上傳到指定目錄
115         - 參數：
116             upload_to = ""      上傳文件的保存路徑
117             storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage
118 
119     ImageField(FileField)
120         - 字符串，路徑保存在數據庫，文件上傳到指定目錄
121         - 參數：
122             upload_to = ""      上傳文件的保存路徑
123             storage = None      存儲組件，默認django.core.files.storage.FileSystemStorage
124             width_field=None,   上傳圖片的高度保存的數據庫字段名（字符串）
125             height_field=None   上傳圖片的寬度保存的數據庫字段名（字符串）
126 
127     DateTimeField(DateField)
128         - 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
129 
130     DateField(DateTimeCheckMixin, Field)
131         - 日期格式      YYYY-MM-DD
132 
133     TimeField(DateTimeCheckMixin, Field)
134         - 時間格式      HH:MM[:ss[.uuuuuu]]
135 
136     DurationField(Field)
137         - 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值爲datetime.timedelta類型
138 
139     FloatField(Field)
140         - 浮點型
141 
142     DecimalField(Field)
143         - 10進制小數
144         - 參數：
145             max_digits，小數總長度
146             decimal_places，小數位長度
147 
148     BinaryField(Field)
149         - 二進制類型

View Code

2.Django admin級別生效

針對 dango_admin生效的參數（正則匹配）（使用Django admin就須要關心如下參數！！））

 1 blanke (是否爲空)
 2 editable=False 是否容許編輯
 3 
 4 help_text="提示信息"提示信息
 5 choices=choice 提供下拉框
 6 error_messages="錯誤信息" 錯誤信息
 7 
 8 validators  自定義錯誤驗證（列表類型），從而定製想要的驗證規則
 9                         from django.core.validators import RegexValidator
10                         from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
11                         MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
12                         如：
13                             test = models.CharField(
14                                 max_length=32,
15                                 error_messages={
16                                     'c1': '優先錯信息1',
17                                     'c2': '優先錯信息2',
18                                     'c3': '優先錯信息3',
19                                 },
20                                 validators=[
21                                     RegexValidator(regex='root_\d+', message='錯誤了', code='c1'),
22                                     RegexValidator(regex='root_112233\d+', message='又錯誤了', code='c2'),
23                                     EmailValidator(message='又錯誤了', code='c3'), ]

View Code

四：ORM連表操做

 

 

五：ORM   F和Q操做

 當通常的查詢語句已經沒法知足咱們的需求時，Django爲咱們提供了F和Q複雜查詢語句。假設場景一：對數據庫中全部人的年齡加一歲，你該怎麼作？場景二：我要查詢一個名字叫xxx，年齡是18歲，或者名字是yyy，年齡是19歲的人，你該怎麼寫你的ORM語句？

一.F查詢 

1 from app01 import models
2 
3 from django.db.models import F
4 models.UserInfo.objects.all().update(age=F("age")+1)   只要一刷新數據庫全部人的年齡均加一歲

  就這樣一條簡單的語句就完成了對錶中所人的年齡更新，是否是很方便！F查詢專門對對象中某列值的操做，不可以使用__雙下劃線！

 

二.Q查詢

    Q查詢能夠組合使用 「&」, 「|」 操做符，當一個操做符是用於兩個Q的對象,它產生一個新的Q對象，Q對象能夠用 「~」 操做符放在前面表示否認，也可容許否認與不否認形式的組合。Q對象能夠與關鍵字參數查詢一塊兒使用，不過必定要把Q對象放在關鍵字參數查詢的前面。

1 from django.db.models import Q
2     models.UserInfo.objects.filter(Q(id=1))
3     models.UserInfo.objects.filter(Q(id=1) | Q(id=2))
4     models.UserInfo.objects.filter(Q(id=1) & Q(id=2))

 1 from django.db.models import Q
 2  
 3 con = Q()
 4 q1 = Q()
 5 q1.connector = "AND"
 6 q1.children.append(("email", "123@qq.com"))
 7 q1.children.append(("password", "abc123"))
 8  
 9 q2 = Q()
10 q2.connector = "AND"
11 q2.children.append(("username", "abc"))
12 q2.children.append(("password", "xyz123"))
13  
14 con.add(q1, "OR")
15 con.add(q2, "OR")
16  
17 obj = models.UserInfo.objects.filter(con).first()

 上面的例子就是一個典型的複雜查詢，經過將Q對象實例化來而後增長各個條件之間的關係，並且這種寫法用在你不知道用戶到底會傳入多少個參數的時候很方便！

三.extra

extra內部的有：

extra內部的有：

    select select_params

    where params

    tables

    order_by

1 models.UserInfo.objects.extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

extra是針對複雜的SQL語句

   select select_params

1 v = models.UserInfo.objects.all().extra(select={
2         'n': "select count(1) from app01_userinfo WHERE id>%s"
3     },
4     select_params=[1,] # 有多個% 內部就有多個參數
5     )
6     print(v)
7     for item in v:
8         print(item.id,item.name,item.n)# 這裏使用n

 where params

1 models.UserInfo.objects.extra(
2         where=["id=1","name='aaa'"]
3     )
4     models.UserInfo.objects.extra(
5         where=["id=1 or id=%s ","name=%s"],
6         params=[1,"aaa"]
7     )

tables

1 models.UserInfo.objects.extra(
2         tables=['app01_usertype'],
3     )
4 # """select * from app01_userinfo,app01_usertype"""

總結：

 1 # a. 映射
 2     # select 
 3     # select_params=None
 4     # select 此處 from 表
 5 
 6 # b. 條件
 7     # where=None
 8     # params=None,
 9     # select * from 表 where 此處
10 
11 # c. 表
12     # tables
13     # select * from 表,此處
14     
15 # c. 排序
16     # order_by=None
17     # select * from 表 order by 此處

1 models.UserInfo.objects.extra(
2                     select={'newid':'select count(1) from app01_usertype where id>%s'},
3                     select_params=[1,],
4                     where = ['age>%s'],
5                     params=[18,],
6                     order_by=['-age'],
7                     tables=['app01_usertype']
8                 )

最終的SQL：

1 select 
2     app01_userinfo.id,
3     (select count(1) from app01_usertype where id>1) as newid
4 from app01_userinfo,app01_usertype
5 where 
6     app01_userinfo.age > 18
7 order by 
8     app01_userinfo.age desc

原生SQL

Django內部提供了寫原生SQL的方法

   在setting中配置

   connection.cursor()默認是default數據庫

   cursor = connections['db2'].cursor() 能夠定義本身的數據庫

　

1 from django.db import connection, connections
2 
3 cursor = connection.cursor() #默認 connection=default數據庫
4 cursor = connections['db2'].cursor()
5 
6 cursor.execute("""SELECT * from auth_user where id = %s""", [1])# 寫原生SQL
7 
8 row = cursor.fetchone()
9 row = cursor.fetchall()   

 

六：model多對多操做

在數據庫表中的多對多,有兩種方式:

1.自定義第三張表

 1 #建立兩張表男生表和女生表
 2 class Boy(models.Model):
 3     name = models.CharField(max_length=32)
 4 
 5 class Girl(models.Model):
 6     nick = models.CharField(max_length=32)
 7 #建立男生和女生關係表
 8 class Love(models.Model):
 9     b = models.ForeignKey('Boy', on_delete=models.CASCADE,)
10     g = models.ForeignKey('Girl', on_delete=models.CASCADE,)

 1 #多對多
 2     objs = {
 3         models.Boy(name='小韓'),
 4         models.Boy(name='小全'),
 5         models.Boy(name='小你'),
 6         models.Boy(name='小及'),
 7         models.Boy(name='小可'),
 8     }
 9     models.Boy.objects.bulk_create(objs,5)
10     objss = {
11         models.Girl(nick='大四'),
12         models.Girl(nick='大五'),
13         models.Girl(nick='大六'),
14         models.Girl(nick='大七'),
15     }
16     models.Girl.objects.bulk_create(objss,5)
17 
18     models.Love.objects.create(b_id=1,g_id=1),
19     models.Love.objects.create(b_id=1,g_id=4),
20     models.Love.objects.create(b_id=2,g_id=4),
21     models.Love.objects.create(b_id=2,g_id=2),
22 
23     #和小韓有關聯的女孩子
24     obj = models.Boy.objects.filter(name='小韓').first()
25     love_list = obj.love_set.all()
26     for row in love_list:
27         print(row.g.nick)
28     
29     
30     love_list = models.Love.objects.filter(b__name='小韓')    
31     for row in love_list:
32         print(row.g.nick)
33 
34     love_list = models.Love.objects.filter(b__name='小韓').values('g__nick')
35     for item in love_list:
36         print(item['g__nick'])
37         
38         
39     love_list = models.Love.objects.filter(b__name='小韓').select_related('g')
40     for obj in love_list:
41         print(obj.g.nick)

2.使用models中自帶的ManytoManyFiled自動建立第三張表

1 #建立兩張表男生表和女生表
2 class Boy(models.Model):
3     name = models.CharField(max_length=32)
4     # m = models.ManyToManyField('Girl')
5 
6 class Girl(models.Model):
7     nick = models.CharField(max_length=32)
8     # g = models.ManyToManyField('Boy')
9     

咱們重點討論第二中方式,有一點能夠確認的是:

• 使用多對多自動建立後,會建立一張第三張表,三張表中會將操做的前兩張表中的ID作對應
• 在沒有作ManyToMany 對應的那張表中,會有一列 xx_set 的數據,其中xx爲正向的表名,而且爲小寫

3.多對多之增刪改查

 1    #增
 2     obj = models.Boy.objects.filter(name='小韓').first()
 3     print(obj.id,obj.name)
 4     obj.m.add(2)
 5     obj.m.add(2,4)
 6     obj.m.add(*[3,])
 7         #刪
 8     obj.m.remove(2)
 9     obj.m.remove(2,3)
10     obj.m.remove(*[1,])
11         #重置
12     obj.m.set([1,])  #填可迭代的對象
13 
14         # 獲取
15     q = obj.m.all()
16     #[Gril對象]
17     print(q)
18 
19     obj = models.Boy.objects.filter(name='小韓').first()
20     girl_list = obj.m.all()
21 
22     obj = models.Boy.objects.filter(name='小韓').first()
23     girl_list = obj.m.filter(nick='大四')
24 
25     obj = models.Boy.objects.filter(name='小韓').first()
26     obj.m.clear()