ORM查詢

目錄

[toc]

# 概要
## ORM經常使用字段
```
經常使用字段
1 AutoFile( primary_key=Ture)

2 Charfiled(max_length= 12)

3 IntgerFile ()

4 DateFile()

5 DatetimeFlie

ROM 經常使用13個操做
( 1 ) 返回QuerySet對象的有
1 all( )
2 filter( )
3 values( )
4 values_list( )
5 exclude( )
6 order_by( )
7 distinct( )
8 reverse( )
( 2 ) 返回對象的有
1 all( ).get( )
2 all( ).first( )
3 all( ).last( )

( 3 ) 返回布爾值的
1 exists ( )

( 4 ) 返回具體數據的
1 count( )

條件查詢
1 id__gt= 大於 id__lt( 小於)
2 id__in= 在[1,2,21,12,221]

3 id__contains="lc" 包含內容的
4 id__startwith="錢" 以錢開頭的
5 id__endswitch= "娜" ....
6 date__year=2017 年份是2017的(day month)
7 3 id__icontains="lc" 不區分大小寫

 

跨表查詢
( 1 ) 基於對象查詢
book_obj = models.Book.object.get( id = 1)
name = book.pubilish.nam

( 2 ) 基於雙下劃綫查找

聚合查詢 avg sum
```
# ORM基礎
## 自定義一個插入類型,即固定長度
```
class FixedCharField(models.Field): #繼承models.field
"""
自定義的char類型的字段類
"""
def __init__(self, max_length, *args, **kwargs): #
super().__init__(max_length=max_length, *args, **kwargs) #繼承父類的方法,長度爲傳進來的長度
self.length = max_length

def db_type(self, connection): #定義函數返回類的方法
"""
限定生成數據庫表的字段類型爲char，長度爲length指定的值
"""
return 'char(%s)' % self.length

class Class(models.Model):
id = models.AutoField(primary_key=True)

title = models.CharField(max_length=25)
# 使用上面自定義的char類型的字段

cname = FixedCharField(max_length=25)
```
## 建立類終極版

- **注意多對多關係中的主表設置在正向查找比較多的表,如圖書館中通常經過書名查找比較多,所以主表就是書表,做者表就是外鍵表**

```

# 自定義varchar類型數據
class FixedCharField(models.Field): #繼承models.field
"""
自定義的char類型的字段類
"""
def __init__(self, max_length, *args, **kwargs): #
super().__init__(max_length=max_length, *args, **kwargs) #繼承父類的方法,長度爲傳進來的長度
self.length = max_length

def db_type(self, connection): #定義函數返回類的方法
"""
限定生成數據庫表的字段類型爲char，長度爲length指定的值
"""
return 'char(%s)' % self.length

 

class Class(models.Model):
id = models.AutoField(primary_key=True) # 主鍵能夠不設置,系統自動添加

title = models.CharField(max_length=40, unique=True, null=False) # 不爲空,必須有最大長度限制,想要有固定差高度,則須要本身自定義類

author = models.ManyToManyField(to='Author',related_name="author") # to_file表的某一個 字段

num = models.IntegerField() #int

data=models.DateField(auto_now=datetime.datetime.now()) # 時間格式,自定義

add=models.ForeignKey(to=Addr,on_delete=models.CASCADE)

publish=models.ForeignKey(to='Publish',on_delete=models.CASCADE)

detail= models.OneToOneField(to="Person_Detail",on_delete=models.CASCADE,related_name="Person") # 一對一,給外鍵設定了惟一屬性

book = models.CharField(max_length=25)
# 使用上面自定義的char類型的字段


def __str__(self):
return "<當提取該對象時,返回數去,如print(class時),顯示的就是此裏面的內容>"
# 也能夠理解爲該對象的描述,默認返回的是對象的地址



class Meta: # 此類方法是設定該類查詢的默認值,如排序的默認值

ordering = ('title',) # 以title的名字進行排序,注意這是一個元祖
unique_together = ("author","add","data") # 聯合惟一設置
db_table = "app" # 自定義命名

 

```
### 多對多關係表建立

- **本身指定第三張表多對多的關係**
```
class Man(models.Model):
name = models.CharField(max_length=40)
phone = models.IntegerField(max_length=30)
def __str__(self):
return "name:{},phone{}".format(self.name,self.phone)

class Meta:
ordering = ("id",)
unique_together = ("name","phone",)

class Wonman(models.Model):
name = models.CharField(max_length=40)
phone = models.IntegerField(max_length=30)
man = models.ManyToManyField(to='Man', related_name="wonman",through="Man_to_Wonman",through_fields=("woman","man"))
def __str__(self):
return "name:{},phone{}".format(self.name,self.phone)

class Meta:
ordering = ("id",)
unique_together = ("name","phone",)

class Man_to_Wonman(models.Model):
addr = models.CharField(max_length=50)
time_date = models.DateTimeField(auto_now_add=datetime.datetime.now())
man = models.ForeignKey(to="Man",on_delete=models.CASCADE)
woman= models.ForeignKey(to="Wonman",on_delete=models.CASCADE)
def __str__(self):
return
class Meta:
ordering = ("id",)
```

( 1 ) ORM自動幫我關聯第三張表,
```
author = models.ManyToManyField(to='Author',related_name="book")

```
( 2 ) 本身經過ForeignKey手動添加第三張表,不用 ManyToManyField
```
publish=models.ForeignKey(to='Publish',on_delete=models.CASCADE,related_name="book")


# 查詢時只能在第三張表中查詢出id,

```
( 3 ) **前面兩種方法的結合,指定第三張表,而且指定關聯第三張表那張數據,要想刪除外鍵只可以經過第三張表刪除**
```
查找的方法還保留有ORM的方法

第三張表還能夠記錄其餘信息,而不僅僅是隻有主鍵和外鍵的id,所以刪除修改數據則在第三張表進行刪除

第三張表.object.all( ).get(id=主鍵表_id,id = 外鍵表_id) 拿到對應行對象進行增刪改
```

## 經常使用幾個代碼

- **其是用來和數據庫交互用的,進行數據的增刪改查表,原名是Object Relational Mapping**
- **原理是把類映射成表,對象映射成數據行,屬性映射成字段**


## 參數
官方網址 https://docs.djangoproject.com/en/2.0/ref/models/options/

# ORM與數據庫代碼對應的關係

- **ORM代碼與數據庫的對應關係**
```
'AutoField': 'integer AUTO_INCREMENT',
'BigAutoField': 'bigint AUTO_INCREMENT',
'BinaryField': 'longblob',
'BooleanField': 'bool',
'CharField': 'varchar(%(max_length)s)',
'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
'DateField': 'date',
'DateTimeField': 'datetime',
'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
'DurationField': 'bigint',
'FileField': 'varchar(%(max_length)s)',
'FilePathField': 'varchar(%(max_length)s)',
'FloatField': 'double precision',
'IntegerField': 'integer',
'BigIntegerField': 'bigint',
'IPAddressField': 'char(15)',
'GenericIPAddressField': 'char(39)',
'NullBooleanField': 'bool',
'OneToOneField': 'integer',
'PositiveIntegerField': 'integer UNSIGNED',
'PositiveSmallIntegerField': 'smallint UNSIGNED',
'SlugField': 'varchar(%(max_length)s)',
'SmallIntegerField': 'smallint',
'TextField': 'longtext',
'TimeField': 'time',
'UUIDField': 'char(32)',
```

## 外鍵使用分表很麻煩,要先刪除主表後,再刪除
## 不經常使用的數據類型

```
AutoField(Field)
- int自增列，必須填入參數 primary_key=True

BigAutoField(AutoField)
- bigint自增列，必須填入參數 primary_key=True

注：當model中若是沒有自增列，則自動會建立一個列名爲id的列
from django.db import models

class UserInfo(models.Model):
# 自動建立一個列名爲id的且爲自增的整數列
username = models.CharField(max_length=32)

class Group(models.Model):
# 自定義自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)

SmallIntegerField(IntegerField):
- 小整數 -32768 ～ 32767

PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整數 0 ～ 32767
IntegerField(Field)
- 整數列(有符號的) -2147483648 ～ 2147483647

PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整數 0 ～ 2147483647

BigIntegerField(IntegerField):
- 長整型(有符號的) -9223372036854775808 ～ 9223372036854775807

BooleanField(Field)
- 布爾值類型

NullBooleanField(Field):
- 能夠爲空的布爾值

CharField(Field)
- 字符類型
- 必須提供max_length參數， max_length表示字符長度

TextField(Field)
- 文本類型

EmailField(CharField)：
- 字符串類型，Django Admin以及ModelForm中提供驗證機制

IPAddressField(Field)
- 字符串類型，Django Admin以及ModelForm中提供驗證 IPV4 機制

GenericIPAddressField(Field)
- 字符串類型，Django Admin以及ModelForm中提供驗證 Ipv4和Ipv6
- 參數：
protocol，用於指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
unpack_ipv4， 若是指定爲True，則輸入::ffff:192.0.2.1時候，可解析爲192.0.2.1，開啓此功能，須要protocol="both"

URLField(CharField)
- 字符串類型，Django Admin以及ModelForm中提供驗證 URL

SlugField(CharField)
- 字符串類型，Django Admin以及ModelForm中提供驗證支持 字母、數字、下劃線、鏈接符（減號）

CommaSeparatedIntegerField(CharField)
- 字符串類型，格式必須爲逗號分割的數字

UUIDField(Field)
- 字符串類型，Django Admin以及ModelForm中提供對UUID格式的驗證

FilePathField(Field)
- 字符串，Django Admin以及ModelForm中提供讀取文件夾下文件的功能
- 參數：
path, 文件夾路徑
match=None, 正則匹配
recursive=False, 遞歸下面的文件夾
allow_files=True, 容許文件
allow_folders=False, 容許文件夾

FileField(Field)
- 字符串，路徑保存在數據庫，文件上傳到指定目錄
- 參數：
upload_to = "" 上傳文件的保存路徑
storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage

ImageField(FileField)
- 字符串，路徑保存在數據庫，文件上傳到指定目錄
- 參數：
upload_to = "" 上傳文件的保存路徑
storage = None 存儲組件，默認django.core.files.storage.FileSystemStorage
width_field=None, 上傳圖片的高度保存的數據庫字段名（字符串）
height_field=None 上傳圖片的寬度保存的數據庫字段名（字符串）

DateTimeField(DateField)
- 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

DateField(DateTimeCheckMixin, Field)
- 日期格式 YYYY-MM-DD

TimeField(DateTimeCheckMixin, Field)
- 時間格式 HH:MM[:ss[.uuuuuu]]

DurationField(Field)
- 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值爲datetime.timedelta類型

FloatField(Field)
- 浮點型

DecimalField(Field)
- 10進制小數
- 參數：
max_digits，小數總長度
decimal_places，小數位長度

BinaryField(Field)
- 二進制類型
```

## 索引參數

 

# 進階版
## **根目錄下運行腳本**
**項目根目錄下調用並運行腳本的內的函數方法,須要特殊的方法,由於配置都在項目內,須要特別的方式,才能調用函數內的環境,通常用在調試上**==即環境配置==
```
import os,django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_name.settings")# project_name 項目名稱
django.setup()
from app66 import models # 必定要放在以上的後面,即django啓動後纔可以調用

# 以上代碼必須放在頭部,

if __name__ == '__main__':

# import app66.urls

ret= models.Book.objects.all()

```

## **queryset結果集和具體對象區別**

**在views中取值方式不同,==對象查找的是屬性經過.來查詢,而queryset則用values進行取值==**


**在反向查詢時也有所區別**


**==在html中佈局取值方式是同樣的,計數用.all再進行計數==**
```

反向計數
article=models.Article.objects.get(pk=1)
&ensp;{{ article.comment_set.all.count }}

反向取值( 詳情表 onetoone 文章表)
對象在HTML中取值
article= models.Article.objects.filter(pk=pk).first()
{{ article.articledetail.content }}


queryset在HTML中取值(要具體到兌現,不然取不到值)
article= models.Article.objects.filter(pk=pk).first()
{{ article.0.articledetail.content }}

```

**查詢方式不同,queryset用的是連表查詢,而get則是基於子查詢**
```
select * from my_stu where class_id in (select id from my_class);

SELECT student_id,student.sname,avg1 as '平均分',sum1 as '總分' FROM
(select score.student_id,avg(score.num) AS avg1 ,SUM(score.num) as sum1 from score GROUP BY student_id) AS a
LEFT JOIN student on student.sid=a.student_id ;
```

**細節比較**
```
try:
ret = models.Book.objects.get(author=9)
print("這是get查詢結果{}".format(ret))
except:
pass
ret1 = models.Book.objects.filter(author=9)

print("這是filter查詢結果{}".format(ret1))

filter可以查詢多個,查找不到也不會報錯,返回QuerySet<>空列表,取值必須用索引取值
返回的是列表,所以經過經過索引取值 ret[0]

即性能更好一些,默認通常狀況下咱們都是使用該方法,返回的是查詢結果集
-------------------------------------
結果以下:QuerySet查詢結果集

這是filter查詢結果<QuerySet [<Book: Book object (132660)>, <Book: Book object (132664)>, <Book: Book object (132665)>, <Book: Book object (132666)>]>

```
- **打印居中的方法**
```
print( 1 ,center("*",100))
```

## 經常使用的13個操做

```
models.Classname.objects.|前綴
<1> all(): 查詢全部結果,

<2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象,能夠查找多個

<3> get(**kwargs): 只能返回一個結果，符合條件的有多個或者沒有都會拋出異常。

<4> exclude(**kwargs): 反向查找(not in **kwargs),它包含了與所給篩選條件不匹配的對象,

<5> values(*field): 返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列model的實例化對象，而是一個可迭代的字典序列

<6> values_list(*field): 它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列

<7> order_by(*field): 對查詢結果排序

<8> reverse(): 對查詢結果反向排序，請注意reverse()一般只能在具備已定義順序的QuerySet上調用(在model類的Meta中指定ordering或調用order_by()方法)。

<9> distinct(): 從返回結果中剔除重複紀錄(若是你查詢跨越多個表，可能在計算QuerySet時獲得重複的結果。此時可使用distinct()，注意只有在PostgreSQL中支持按字段去重。)

<10> count(): 返回數據庫中匹配查詢(QuerySet)的對象數量。

<11> first(): 返回第一條記錄

<12> last(): 返回最後一條記錄

<13> exists(): 若是QuerySet包含數據，就返回True，不然返回False
```

### 時間查詢

**data_form,對日期進行規範,mysql內置方法格式是**
```
date_format(字段名,"%Y-%m")
```

### 查詢字段 values(字段名,字段名),返回數據類型==[{},{},{} ]==

### values_list 返回的是==列表==,只拿到值[(字段值,),(字段值,)]
```
ret1= models.Book.objects.values("id","title")[0:3]

ret =models.Book.objects.values_list("id","title")[0:3]

-----------------------------------
<QuerySet [(132654, '了凡四訓'), (132655, '論語'), (132656, '史記')]>
<QuerySet [{'id': 132654, 'title': '了凡四訓'}, {'id': 132655, 'title': '論語'}, {'id': 132656, 'title': '史記'}]>

```
### exclude(**kwargs)至關於 not in **kwargs
### order_by(字段名字),排序(-num),則是倒序排序
### reverse()和order_by結合實現倒序查詢
- **必須是有序的數字,不然反轉不成功**
- **方法一:在建立時定義排列方式**
```
class Meta:
ordering = ("id",) #切記必定是元祖類型,後面須要添加,
```
- **方法二 用order_by進行排序,再進行反轉**
```
ret1 = models.Book.objects.filter(author=9).reverse()
```
### distinct():去重
```
在查詢結果中添加,能夠去重,

倒序 若是字段是int 類型的,能夠用order_by("-price")
```
### count(),first(),last()計數,第一
### exists():判斷表中有沒有數據

### 返回對象的是如下幾種
## filter條件查詢(雙下劃綫匹配條件)
- **==雙下劃綫表示跨一張表==**
- **前面都是字段名字前綴,id_lt,即表的id起始值,另外括號裏面的數據都要用雙引號引發來**
```
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值 能夠分開寫

models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於十一、2二、33的數據 where id in [ ]

models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in

 

models.Tb1.objects.filter(name__contains="ven") # 獲取name字段包含"ven"的 where name like "lc%"
#在2.0中自動添加那個屬性,本身選擇那張表或者字段進行帥選

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)
```
# 跨表查詢(外鍵)
**valuses跨表取值,必須肯定是某一個對象才能夠**

## 正向查詢(從主表查詢外鍵表對應的屬性)
- **由書查詢到外鍵對象的具體值,在後面直接添加values(字段名稱__字段名稱對應的屬性)**
- 
```

 

ret2=models.Book.objects.filter(author__name__contains="錢").values("title") # 一共有四個,在多對多狀況下 #條件查詢可能有多個,所以要for循環,而,字段裏面也可能有多個值,還須要字段,所以就有雙重for循環



print(models.Book.objects.filter(author__name__contains="錢").values("publish__id"))
#直接跟人家的方法,方便,省代碼
```
## 反向查找,從外鍵表查找對應的數據
```
p_obj = models.Publish.objects.first()
p_obj_name = p_obj.book.all()
p_obj_name=p_obj_name.values_list("title")
print(p_obj_name)

還有一種是跨表查詢
p_obj1 = models.Publish.objects.filter(id=1).values_list("book__title")
```


## 正向和反向查詢注意點
```
p_obj = models.Publish.objects.first() all.get() #拿到的是一個具體的對象後面加點要麼表示對象內的方法或者屬性,沒有就報錯
AttributeError: 'Publish' object has no attribute 'values'

filter .all 拿到的是封裝的結果集,能夠調用values的方法

```

## 多對多相關方法
&emsp;&emsp;**表格數據能夠其餘表複製粘貼數據,前提是複製有多少行數據,粘貼表也要有幾行空數據**

## 對象操做
&emsp;&emsp;對於全部類型的關聯字段，add()、create()、remove()和clear(),set()都會立刻更新數據庫。換句話說，在關聯的任何一端，都不須要再調用save()方法。
### create()建立
&emsp;&emsp;如做者是書外鍵,能夠經過書的某個對象經過create方法建立一個做者,並關聯上**經過主表添加外鍵和書籍,括號內填屬性等於便可,即關鍵字傳參**
```
book_obj = models.Book.objects.first() # 找到第一個數據對象
book_obj.author.create(name="李世光",id=12) # 添加一個關聯數據,沒有就建立,
```
### add( )則是添加
```
book_obj = models.Book.objects.first()
book_obj.author.add(*[1,2,6]) # 列表前面加*表示把列表打散開

 

author_objs = models.Author.objects.filter(id__lt=3) # 經過查詢找到相應的對象,也是能夠插入的
models.Book.objects.first().authors.add(*author_objs) # 用 * 表示把數據打散成單個數據
```
### set()更新
```
book_obj = models.Book.objects.first()
book_obj.authors.set([2, 3])
```
### remove和clear
對於ForeignKey對象，clear()和remove()方法僅在null=True時存在。某字段爲空刪除後會報錯

```
book_obj = models.Book.objects.first()
book_obj.authors.remove(3)

book_obj.authors.clear()
```

 

## 組合查詢(兩個字段之間作比較)用F()和update(),對象字段更新

- 字段對比
```
from django.db.models import F
models.Book.objects.filter(字段名__gt=F('字段名')) # gt表示大於

```
- 字段更新,注意update只能在QuerySet結果集中調用,返回的是具體對象調用不了
```
models.Book.objects.all().update(price=F("price")+30) #注意update只有返回的是結果集的時候纔可以用返回某一個對象則用 對象.屬性名= XX 對象名.save() 進行修改

 

ret= models.Book.objects.filter(add__id__gt=F("num")*3) # 地址的id大於num字段*3的數值,注意加減乘除要在F()以後
```
### 字符串追加內容也用到update
```
from django.db.models.functions import Concat #對字符串拼接,
from django.db.models import Value # 對值進行轉換,像時間轉化後才能進行加減

ret= models.Book.objects.filter(add__id__gt=F("num")*3).update(title=Concat(F("title"),
Value("("),
Value("初版"),
Value(")")))
value 能夠有多個值,最後拼接成 book(初版)

```

### filter(條件1,條件2) 其中都是表示而且的關係

## Q查詢即或關係查詢

```
models.Book.objects.filter( Q(authors__name="小仙女") | Q(authors__name="小魔女"),title__id__gt=5 )

注意,表示且的關係,此外Q條件,必須放在最前面
```

## aggregate聚合查詢sum,max min count,只計算一個字段全部值
```
from django.db.models import Avg, Sum, Max, Min, Count

models.Book.objects.all().aggregate(Avg("price"))

models.Book.objects.aggregate(average_price=Avg('price')) # 對結果從新起名字

models.Book.objects.all().aggregate( Avg("price") , Max("price")) 能夠查詢多個和Value插入相似
```
## annotate分組,分類 求該類中的相關的各種值
- **,並對該組進行數據處理,**
```
from django.db.models import Avg

book_list = models.Book.objects.all().annotate(author_num=Count("author")).values_list("author_num")
# 本表的author爲依據進行組合,並把結果拼接到最後

# 分組用annotate,而聚合aggregate

book_list = models.Book.objects.all().annotate(author_num=Count("組合字段名字")) # 經過某字段組合,拿到的是一個從新組合表,中全部對象結果集
for obj in book_list:
... print(obj.author_num)
```
- 對組合依據是a列,而計數的且是b列,則用外鍵表進行組合便可
```
book_list = models.Author.objects.all().annotate(author_num=Count("book__title")).values_list("name","author_num")

# 當是外鍵時就至關於以author爲組合依據,計算他重複的個數,另一張表的任意字段均可以
```

- **注意.annotate前面拿到的數據是組合依據,annotate內知識組合取值,==這是同表==**

```
.annotate 括號參數至關於
select count( a ) from ---------------

而.annotate以前至關於
select count( a ) from table_name group_by models.Author.objects.all()

所以須要對某一個字段進行組合,取字段便可
select count( a ) from table_name group_by models.Author.objects.values(author)

count(a)就會對組合類進行計算,而其餘項沒法取捨,可是要是是數據則能夠進行加減,情平均值

終極例子
book_list = models.Author.objects.values("組合字段名").annotate(author_num=Count("book__title")).values_list("name","author_num")
```
- **==外鍵組合,和上面用法同樣,想要去外鍵表值,則經過雙下劃綫取值便可==**
```
book_list = models.book.objects.values("外鍵字段名").annotate(author_num=Count("任意字段")).values_list("外鍵__想要去的字段","author_num")
```
- **博客項目中應用**
- 
```
我的文章
user1= models.UserInfo.objects.filter(username=user).first()
if not user1: #若是用戶不存在則,---
HttpResponse("用戶不存在")
# 若是用戶存在就給頁面返回一個blog對象
user_blog=user1.blog

#我的文章
article_list=models.Article.objects.filter(user__username=user) #做者全部文章

我的文章分類
category = models.Article.objects.filter(user__username=user).values("category").annotate(count=Count("category")).values_list("count","category__title")
# 注意在跨表查詢時,計算那個字段就用那個字段查詢,不然數據出錯

tag=models.Tag.objects.filter(blog=user_blog).annotate(count=Count("article")).values_list("title","count")
# 注意前面是以誰爲判斷依據,後面是計算誰,不可以用1 代替,不然結果不許,在跨表計算時,


時間取值須要先格式化後再進行組合
time= models.Article.objects.extra(
select={"c":"date_format(create_time,'%%Y-%%m')"}
).values("c").annotate(count=Count('title')).values_list("c","count")
```
## 鎖
```

select_for_update(nowait=False, skip_locked=False)

返回一個鎖住行直到事務結束的查詢集，若是數據庫支持，它將生成一個 SELECT ... FOR UPDATE 語句。

舉個例子：

entries = Entry.objects.select_for_update().filter(author=request.user)
全部匹配的行將被鎖定，直到事務結束。這意味着能夠經過鎖防止數據被其它事務修改。

通常狀況下若是其餘事務鎖定了相關行，那麼本查詢將被阻塞，直到鎖被釋放。 若是這不想要使查詢阻塞的話，使用select_for_update(nowait=True)。 若是其它事務持有衝突的鎖, 那麼查詢將引起 DatabaseError 異常。你也可使用select_for_update(skip_locked=True)忽略鎖定的行。 nowait和skip_locked是互斥的，同時設置會致使ValueError。

目前，postgresql，oracle和mysql數據庫後端支持select_for_update()。 可是，MySQL不支持nowait和skip_locked參數。

使用不支持這些選項的數據庫後端（如MySQL）將nowait=True或skip_locked=True轉換爲select_for_update()將致使拋出DatabaseError異常，這能夠防止代碼意外終止。

 

```

## 原子性操做(事務)
```
import os

if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()

import datetime
from app01 import models

try:
from django.db import transaction
with transaction.atomic(): # with 裏面代碼都是原子性操做
new_publisher = models.Publisher.objects.create(name="火星出版社")
models.Book.objects.create(title="橘子物語", publish_date=datetime.date.today(), publisher_id=10) # 指定一個不存在的出版社id
except Exception as e:
print(str(e))
```

# 一對一關聯(外鍵字段有惟一關聯)
- **使用場景**

( 1 )　　**即原本應該就能夠放在一張表的信息,如今放在兩張表如不經常使用的消息放在一張表中,而經常使用的也放在一張表,好比qq中的基本信息和詳細信息時分開的,當第三方工具想要提取時,就把基本信息發送便可**
```
detail= models.OneToOneField(to="Person_Detail",on_delete=models.CASCADE,related_name="Person")
```
( 2 )　　**保證搜索引擎的快速性,由於不須要提取所有信息**

- **查詢和 外鍵查詢是同樣的**
```

```
# 其餘方法
```
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 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 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):
# 是否有結果
```
## select_related和prefetch_related(面試常問),
- **把數據也加載到對象中,製做一次查詢,和all的 用法同樣**
```
book = Book.objects.select_related('person').filter(pk=1) #select_related("字段名字")

# 假設Person模型中有另一個外鍵city,可做以下查詢
book = Book.objects.select_related('person__city').filter(pk=1)
```
- **二者做用是**:

&emsp;&emsp;在Django中，全部的Queryset都是惰性的，意思是當建立一個查詢集的時候，並無跟數據庫發生任何交互。所以咱們能夠對查詢集進行級聯的filter等操做，只有在訪問Queryset的內容的時候，Django纔會真正進行數據庫的訪問。而多頻率、複雜的數據庫查詢每每是性能問題最大的根源。
&emsp;&emsp;當咱們經過外鍵獲取一個關聯對象的時候，實際上默認獲取的是關聯對象的ID。若是按照默認的查詢方式去遍歷取值，那麼會形成屢次的數據庫查詢，效率可想而知。

- **查找方式**

( 1 )&emsp;&emsp;select_related:用的是連表查詢方式,進而減小查詢次數,最終達到優化和提升性能效果
( 2 )&emsp;&emsp;prefetch_related:用分表查詢方式,把查詢結果進行必定邏輯處理,克服了多對多連表致使表臃腫過長,增長運行時間和內存佔用.

- **應用場景**

( 1 )&emsp;&emsp;**select_related主要針一對一和多對一關係進行優化。即對外鍵一對一和foreignkey的正向查詢使用**
( 2 )&emsp;&emsp;** prefetch_related()的優化方式是分別查詢每一個表，而後用Python處理他們之間的關係,能夠理解爲用在反向查詢比較多**
```
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
```
## get_or_create和update_or_create
```
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})
```
## 批量建立bulk_create,減小數據庫的連接次數
```
obj=[models.Book( [print(i) for i in range(10) ] 相似 語句for循環
title="韓非子第{}部".format(i),
price=i,publisher_id=1,
id = 20+i,publish_date=2017-12-8,
memo="上海{}街".format(i))
for i in range(20)]

models.Book.objects.bulk_create(obj,10) # 10 一次性插入10次

```
## in_bulk根據主鍵id查找
```
# 根據主鍵ID進行查找
id_list = [11,21,31]
models.DDD.objects.in_bulk(id_list)
```
# 在腳本中調用Django環境
```
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
import django
django.setup()
from app01 import models # 注意必定要導入django環境後才能導入項目裏面的模塊,不然會報錯

if __name__ == '__main__':

 

books = models.Book.objects.all()
print(books)
```
# 練習
```
# 書
class Book(models.Model):
title = models.CharField(max_length=32)
publish_date = models.DateField(auto_now_add=True)
price = models.DecimalField(max_digits=5, decimal_places=2)
memo = models.TextField(null=True)
# 建立外鍵，關聯publish
publisher = models.ForeignKey(to="Publisher")
# 建立多對多關聯author
author = models.ManyToManyField(to="Author")

def __str__(self):
return self.title

# 出版社
class Publisher(models.Model):
name = models.CharField(max_length=32)
city = models.CharField(max_length=32)

def __str__(self):
return self.name

# 做者
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
phone = models.CharField(max_length=11)
detail = models.OneToOneField(to="AuthorDetail")

def __str__(self):
return self.name

# 做者詳情
class AuthorDetail(models.Model):
addr = models.CharField(max_length=64)
email = models.EmailField()
```

 

```
查找全部書名裏包含番茄的書
查找出版日期是2017年的書
查找出版日期是2017年的書名
查找價格大於10元的書
查找價格大於10元的書名和價格
查找memo字段是空的書

查找在北京的出版社
查找名字以沙河開頭的出版社

查找做者名字裏面帶「小」字的做者
查找年齡大於30歲的做者
查找手機號是155開頭的做者
查找手機號是155開頭的做者的姓名和年齡

查找書名是「番茄物語」的書的出版社
查找書名是「番茄物語」的書的出版社所在的城市
查找書名是「番茄物語」的書的出版社的名稱

查找書名是「番茄物語」的書的全部做者
查找書名是「番茄物語」的書的做者的年齡
查找書名是「番茄物語」的書的做者的手機號碼

查找書名是「番茄物語」的書的做者的地址
查找書名是「番茄物語」的書的做者的郵箱
```
```
print(models.Book.objects.filter(publish_date__year=2020))
print(models.Book.objects.filter(publish_date__year=2020).values_list("title")[0])
print(models.Book.objects.filter(publisher__book__price__gt=60))
print(models.Book.objects.filter(memo=""))
print(models.Book.objects.filter(publisher__city="北京"))
print(models.Book.objects.filter(publisher__name__startswith="廣西"))
print(models.Author.objects.filter(name__contains="三"))
print(models.Author.objects.filter(age__gt=53))
print(models.Author.objects.filter(phone__startswith="15"))
print(models.Author.objects.filter(phone__startswith="15").values_list("name","age"))
print(models.Author.objects.filter(phone__startswith="15").values_list("name","age"))
print(models.Book.objects.filter(title="西遊記").values("publisher"))
print(models.Publisher.objects.filter(book__title="韓非子").values("city"))
print(models.Publisher.objects.filter(book__title="韓非子").values("name"))

```

# distinct
```
在查詢結果中添加,能夠去重,

倒序 若是字段是int 類型的,能夠用order_by("-price")
```
# 本身寫SQL語句查詢

## 子查詢
也就是給表添加一個字段,查詢工資大於0,通常用在增長字段後查詢,組合
```
查詢大於某數的
Book.objects.all().extra(
{"gt":"salary > 2000" }
)
select (salary > 2000) as "gt",id--- from Book # 至關於多加一個字段,並返回0或者1
```

對時間格式化後分組
```
格式化時間
ret =models.Article.objects.extra(
select={"c":"date_format(create_time,'%%Y-%%m')"}
).

格式化時間再進行組合
ret =models.Article.objects.extra(
select={"c":"date_format(create_time,'%%Y-%%m')"}
).values("c").annotate(count=Count('title')).values_list("c","count")
```
**注意date_format()中的字段參數是沒有括號的,組合前面查詢出來的字段就是組合依據,查詢表就是返回對象**

 

```

Book.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'])
```

## 原生查詢(在插入數據或者更新時效率高)有時候raw()方法並不十分好用，不少狀況下咱們不須要將查詢結果映射成模型，或者咱們須要執行DELETE、 INSERT以及UPDATE操做。在這些狀況下，咱們能夠直接訪問數據庫，徹底避開模型層。```# 直接導入connection,不用本身鏈接,其餘方法都是同樣的from django.db import connection, connectionscursor = connection.cursor() # cursor = connections['default'].cursor()cursor.execute("""SELECT * from auth_user where id = %s""", [1])ret = cursor.fetchone()```