Django基礎mysql多表操做

時間 2020-06-09

標籤 django 基礎 mysql 欄目 Python 简体版

原文原文鏈接

一建立模型

　表和表之間的關係python

　　　　一對1、多對1、多對多　，用book表和publish表本身來想一想關係，想一想裏面的操做，加外鍵約束和不加外鍵約束的區別，一對一的外鍵約束是在一對多的約束上加上惟一約束。mysql

　　實例：咱們來假定下面這些概念，字段和關係git

　　做者模型：一個做者有姓名和年齡。sql

　　做者詳細模型：把做者的詳情放到詳情表，包含生日，手機號，家庭住址等信息。做者詳情模型和做者模型之間是一對一的關係（one-to-one）數據庫

　　出版商模型：出版商有名稱，所在城市以及email。django

　　書籍模型：書籍有書名和出版日期，一本書可能會有多個做者，一個做者也能夠寫多本書，因此做者和書籍的關係就是多對多的關聯關係(many-to-many);一本書只應該由一個出版商出版，因此出版商和書籍是一對多關聯關係(one-to-many)。api

　　模型創建以下：app

from django.db import models # Create your models here.


class Author(models.Model): #比較經常使用的信息放到這個表裏面
    nid = models.AutoField(primary_key=True) name=models.CharField( max_length=32) age=models.IntegerField() # 與AuthorDetail創建一對一的關係，一對一的這個關係字段寫在兩個表的任意一個表裏面均可以
    authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE) #就是foreignkey+unique，只不過不須要咱們本身來寫參數了，而且orm會自動幫你給這個字段名字拼上一個_id，數據庫中字段名稱爲authorDetail_id。在django 1.xx的版本不須要加（to_field="nid",on_delete=models.CASCADE）默認是級聯的
，若是on_delete=models.SET_NULL默認爲空。(to="AuthorDetail"）要加字符串（引號用反射查找） class AuthorDetail(models.Model):#不經常使用的放到這個表裏面
 nid = models.AutoField(primary_key=True) birthday=models.DateField() # telephone=models.BigIntegerField() 
    telephone=models.CharField() addr=models.CharField( max_length=64) class Publish(models.Model): nid = models.AutoField(primary_key=True) name=models.CharField( max_length=32) city=models.CharField( max_length=32) email=models.EmailField()   #CharField--xx@xx.com

#多對多的表關係，咱們學mysql的時候是怎麼創建的，是否是手動建立一個第三張表，而後寫上兩個字段，每一個字段外鍵關聯到另外兩張多對多關係的表，orm的manytomany自動幫咱們建立第三張表，兩種方式創建關係均可以，之後的學習咱們暫時用orm自動建立的第三張表，由於手動建立的第三張表咱們進行orm操做的時候，不少關於多對多關係的表之間的orm語句方法沒法使用 #若是你想刪除某張表，你只須要將這個表註銷掉，而後執行那兩個數據庫同步指令就能夠了，自動就刪除了。
class Book(models.Model): nid = models.AutoField(primary_key=True) title = models.CharField( max_length=32) publishDate=models.DateField() price=models.DecimalField(max_digits=5,decimal_places=2) # 與Publish創建一對多的關係,外鍵字段創建在多的一方，字段publish若是是外鍵字段，那麼它自動是int類型
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE) #foreignkey裏面能夠加不少的參數，都是須要我們學習的，慢慢來，to指向表，to_field指向你關聯的字段，不寫這個，默認會自動關聯主鍵字段，on_delete級聯刪除
　　 字段名稱不須要寫成publish_id，orm在翻譯foreignkey的時候會自動給你這個字段拼上一個_id,這個字段名稱在數據庫裏面就自動變成了publish_id # 與Author表創建多對多的關係,ManyToManyField能夠建在兩個模型中的任意一個，自動建立第三張表，而且注意一點，你查看book表的時候，你看不到這個字段，由於這個字段就是建立第三張表的意思，不是建立字段的意思，因此只能說這個book類裏面有authors這個字段屬性
    authors=models.ManyToManyField(to='Author',) #注意不論是一對多仍是多對多，寫to這個參數的時候，最後後面的值是個字符串，否則你就須要將你要關聯的那個表放到這個表的上面

表操做

python提供admin後臺管理系統

在django項目下的urlide

訪問網頁http://127.0.0.1:8000/admin/函數

建立用戶

用戶名：degang

Email：能夠爲空

Password:密碼要求要有複雜度（要有數字，字母，很多於八位）輸入兩次密碼

在django項目下把models導入到admin中，而後重啓項目

orm 經常使用字段和參數

字段

AutoField  # 主鍵
CharField  # 字符串
TextField  # 大字符串
IntegerField  # 整形
DateTimeField   DateField   # 日期 日期時間
BooleanField  # 布爾
DecimalField  max_digits=5  decimal_places=2   999.99

參數

null=True 數據庫該字段能夠爲空 blank=True 校驗時能夠爲空 default 默認值 unique 惟一索引 verbose_name 顯示的名稱 choices=((True, '男'), (False, '女'))    可選擇的參數

class Meta（在models設置）

class Meta: # 數據庫中生成的表名稱 默認 app名稱 + 下劃線 + 類名
        db_table = "person"

        # admin中顯示的表名稱
        verbose_name = '我的信息'

        # verbose_name加s
        verbose_name_plural = '全部用戶信息'

        # 聯合索引
        index_together = [ ("name", "age"),  # 應爲兩個存在的字段
 ] # 聯合惟一索引
        unique_together = (("name", "age"),)  # 應爲兩個存在的字段

關於多對多表的三種建立方式(目前你先做爲了解)

方式一：自行建立第三張表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="書名")


class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="做者姓名")


# 本身建立第三張表，分別經過外鍵關聯書和做者
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")

方式二：經過ManyToManyField自動建立第三張表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="書名")


# 經過ORM自帶的ManyToManyField自動建立第三張表
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="做者姓名")
    books = models.ManyToManyField(to="Book", related_name="authors")

方式三：設置ManyTomanyField並指定自行建立的第三張表

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="書名")


# 本身建立第三張表，並經過ManyToManyField指定關聯
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="做者姓名")
    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
    # through_fields接受一個2元組（'field1'，'field2'）：
    # 其中field1是定義ManyToManyField的模型外鍵的名（author），field2是關聯目標模型（book）的外鍵名。


class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")

注意：

　　當咱們須要在第三張關係表中存儲額外的字段時，就要使用第三種方式。

　　可是當咱們使用第三種方式建立多對多關聯關係時，就沒法使用orm提供的set、add、remove、clear方法來管理多對多的關係了，須要經過第三張表的model來管理多對多關係。

to 設置要關聯的表。 to_field 設置要關聯的字段。 on_delete 同ForeignKey字段。

建立一對一關係字段時的一些參數

to 設置要關聯的表 to_field 設置要關聯的表的字段 related_name 反向操做時，使用的字段名，用於代替原反向查詢時的'表名_set'。 related_query_name 反向查詢操做時，使用的鏈接前綴，用於替換表名。 on_delete 當刪除關聯表中的數據時，當前表與其關聯的行的行爲。

建立一對多關係字段時的一些參數

多對多的參數： to 設置要關聯的表 related_name 同ForeignKey字段。 related_query_name 同ForeignKey字段。 through 在使用ManyToManyField字段時，Django將自動生成一張表來管理多對多的關聯關係。 但咱們也能夠手動建立第三張表來管理多對多關係，此時就須要經過 through來指定第三張表的表名。 through_fields 設置關聯的字段。 db_table 默認建立第三張表時，數據庫中表的名稱。

建立多對多字段時的一些參數

元信息 ORM對應的類裏面包含另外一個Meta類，而Meta類封裝了一些數據庫的信息。主要字段以下: class Author2Book(models.Model): author = models.ForeignKey(to="Author") book = models.ForeignKey(to="Book") class Meta: unique_together = ("author", "book") db_table ORM在數據庫中的表名默認是 app_類名，能夠經過db_table能夠重寫表名。db_table = 'book_model' index_together 聯合索引。 unique_together 聯合惟一索引。 ordering 指定默認按什麼字段排序。 ordering = ['pub_date',] 只有設置了該屬性，咱們查詢到的結果才能夠被reverse()，不然是能對排序了的結果進行反轉(order_by()方法排序過的數據)

建立表時的一些元信息設置

增刪改查

增

一對一

obj=models.AuthorDetail.objects.create( birthday='1979-12-12', telephone='13838338', addr='黑龍江' ) models.Author.objects.create( name='王濤', age=72, # authorDetail=obj,
)

增長方式一

obj1=models.AuthorDetail.objects.filter(addr='山西').first() #取得對象
 models.Author.objects.create( name='b哥', age=63, authorDetail_id=obj1.id )

增長方式二

一對多

new_pu=models.Publish.objects.get(id=1) obj=models.Book.objects.create( title='亞索的故事', publishDate='2013-09-12', price=11.1, publish=new_pu, ) print(obj)

方式一

new_pu=models.Publish.objects.get(id=2) models.Book.objects.create( title="簫曲", publishDate='2011-07-04', price=96, publish_id=new_pu.id )

方式二

多對多

book_obj=models.Book.objects.get(nid=1) print(book_obj) book_obj.authors.add(*[1,2])

方式一

author1 = models.Author.objects.get(id=1) author2 = models.Author.objects.get(id=3) book_obj = models.Book.objects.get(nid=2) book_obj.authors.add(*[author1,author2])

方式二

刪

models.AuthorDetail.objects.get(id=6).delete()

一對一

models.Publish.objects.get(id=2).delete() models.Book.objects.get(pk=5).delete()

一對多

book_obj = models.Book.objects.get(nid=4) print(book_obj) book_obj.authors.remove(2) # book_obj.authors.remove(*[5,6]) # book_obj.authors.clear() # book_obj.authors.add(*[1,]) # book_obj.authors.set('1') # book_obj.authors.set(['5','6'])

多對多

多表刪除

URL下

url(r'(\w+)_del/(\d+)/$', views.delete, name='delete')

VIEWS下

def delete(request,table,pk):                      #table 表名 pk 刪除的id
    print(table,pk) model_cls=getattr(models,table.capitalize(),)  #capitalize 首字母大寫
    model_cls.objects.filter(pk=pk).delete() return redirect(table)

HTML下

<a  class="btn btn-danger btn-sm" id="{{ i.nid }}" href="{% url 'delete' 'author' i.nid %}" >刪除</a>

改

models.Author.objects.filter(id=3).update( name='壯壯', age=80, authorDetail_id=7, )

一對一

models.Book.objects.filter(pk=1).update( title='b哥的往事3', publishDate='2019-01-01', price='100', publish_id=1. )

一對多

多對多

book_obj.authors.remove()      # 將某個特定的對象從被關聯對象集合中去除。    ======   book_obj.authors.remove(*[1，2])，將多對多的關係數據刪除
book_obj.authors.clear()       #清空被關聯對象集合
book_obj.authors.set()         #先清空再設置　　 =====

查（重點）

關係屬性(字段)寫在哪一個類(表)裏面,從當前類(表to)的數據去查詢它關聯類(表)的數據叫作正向查詢,反之叫作反向查詢

# 查詢
    # 一對一
    # 正向查詢
    # 1 查詢崔老師的電話號
    author_obj = models.Author.objects.filter(name='崔老師').first() print(author_obj.authorDetail) #遼寧峨眉山
    print(author_obj.authorDetail.telephone) #444
        #2 反向查詢
        #2 查詢一下這個444電話號是誰的.
    author_detail_obj = models.AuthorDetail.objects.get(telephone='444') print(author_detail_obj.author) #崔老師
    print(author_detail_obj.author.name) #崔老師

    ''' 正向查詢:Authorobj.authorDetail,對象.關聯屬性名稱 Author----------------------------------->AuthorDetail <----------------------------------- 反向查詢:AuthorDetailobj.author ,對象.小寫類名 '''

    # 一對多
    # 查詢一下李帥的牀頭故事這本書的出版社是哪一個
    # 正向查詢
    book_obj = models.Book.objects.get(title='李帥的牀頭故事') print(book_obj.publishs)  # B哥出版社
    print(book_obj.publishs.name)  # B哥出版社

    # B哥出版社出版社出版了哪些書
    # 反向查詢
    pub_obj = models.Publish.objects.get(name='B哥出版社') print(pub_obj.book_set.all())  # <QuerySet [<Book: 李帥的牀頭故事>, <Book: 李帥的牀頭故事2>]>

    ''' 正向查詢 book_obj.publishs 對象.屬性 Book ---------------------------------------------> Publish <---------------------------------------------- 反向查詢 publish_obj.book_set.all() 對象.表名小寫_set '''

    # 多對多
    # 李帥的牀頭故事這本書是誰寫的
    # 正向查詢
    book_obj = models.Book.objects.get(title='李帥的牀頭故事') print(book_obj.authors.all()) # 高傑寫了哪些書
    author_obj = models.Author.objects.get(name='高傑') print(author_obj.book_set.all()) ''' 正向查詢 book_obj.authors.all() 對象.屬性 Book ---------------------------------------------> Author <---------------------------------------------- 反向查詢 author_obj.book_set.all() 對象.表名小寫_set '''

正向查詢和反向查詢

Django 還提供了一種直觀而高效的方式在查詢(lookups)中表示關聯關係，它能自動確認 SQL JOIN 聯繫。要作跨關係查詢，就使用兩個下劃線來連接模型(model)間關聯字段的名稱，直到最終連接到你想要的model 爲止。

'''
    基於雙下劃線的查詢就一句話：正向查詢按字段,反向查詢按表名小寫用來告訴ORM引擎join哪張表,一對1、一對多、多對多都是一個寫法，注意，咱們寫orm查詢的時候，哪一個表在前哪一個表在後都沒問題，由於走的是join連表操做。
'''

一對一查詢

# 查詢yuan的手機號
    
# 正向查詢
    ret=Author.objects.filter(name="yuan").values("authordetail__telephone") # 反向查詢
    ret=AuthorDetail.objects.filter(author__name="yuan").values("telephone")

一對一查詢

一對多查詢

# 練習: 查詢蘋果出版社出版過的全部書籍的名字與價格(一對多) 

# 正向查詢 按字段:publish
 queryResult=Book.objects 　　　　　　　　　　　　.filter(publish__name="蘋果出版社")  #經過__告訴orm將book表和publish表進行join，而後找到全部記錄中publish.name='蘋果出版社'的記錄（注意publish是屬性名稱），而後select book.title,book.price的字段值
　　　　　　　　　　　　.values_list("title","price") #values或者values_list

# 反向查詢 按表名:book
 queryResult=Publish.objects 　　　　　　　　　　　　　　.filter(name="蘋果出版社") 　　　　　　　　　　　　　　.values_list("book__title","book__price")

一對多查詢

多對多查詢　　

# 練習: 查詢yuan出過的全部書籍的名字(多對多)

# 正向查詢 按字段:authors:
    queryResult=Book.objects 　　　　　　　　　　　　.filter(authors__name="yuan") 　　　　　　　　　　　　.values_list("title") # 反向查詢 按表名:book
    queryResult=Author.objects 　　　　　　　　　　　　　　.filter(name="yuan") 　　　　　　　　　　　　　　.values_list("book__title","book__price")

多對多查詢

進階練習(連續跨表)

# 練習: 查詢人民出版社出版過的全部書籍的名字以及做者的姓名


    # 正向查詢
    queryResult=Book.objects 　　　　　　　　　　　　.filter(publish__name="人民出版社") 　　　　　　　　　　　　.values_list("title","authors__name") # 反向查詢
    queryResult=Publish.objects 　　　　　　　　　　　　　　.filter(name="人民出版社") 　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name") # 練習: 手機號以151開頭的做者出版過的全部書籍名稱以及出版社名稱


    # 方式1:
    queryResult=Book.objects 　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="151") 　　　　　　　　　　　　.values_list("title","publish__name") # 方式2: 
    ret=Author.objects .filter(authordetail__telephone__startswith="151") .values("book__title","book__publish__name")

進階練習(連續跨表)

related_name

只能反向查找用

反向查詢時，若是定義了related_name ，則用related_name替換表名，例如：

publish = ForeignKey(Blog, related_name='bookList')

# 練習: 查詢人民出版社出版過的全部書籍的名字與價格(一對多)

# 反向查詢 再也不按表名:book,而是related_name:bookList
 queryResult=Publish.objects 　　　　　　　　　　　　　　.filter(name="人民出版社") 　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price")

related_name

聚合查詢、分組查詢、F查詢和Q查詢

聚合

　aggregate(*args, **kwargs) # 計算全部圖書的平均價格
    >>> from django.db.models import Avg >>> Book.objects.all().aggregate(Avg('price')) #或者給它起名字：aggretate(a=Avg('price'))
    {'price__avg': 34.35} 　　aggregate()是QuerySet 的一個終止子句，意思是說，它返回一個包含一些鍵值對的字典。鍵的名稱是聚合值的標識符，值是計算出來的聚合值。鍵的名稱是按照字段和聚合函數的名稱自動生成出來的。若是你想要爲聚合值指定一個名稱，能夠向聚合子句提供它。 >>> Book.objects.aggregate(average_price=Avg('price')) {'average_price': 34.35} 　　若是你但願生成不止一個聚合，你能夠向aggregate()子句中添加另外一個參數。因此，若是你也想知道全部圖書價格的最大值和最小值，能夠這樣查詢： >>> from django.db.models import Avg, Max, Min >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))  #count('id'),count(1)也能夠統計個數,Book.objects.all().aggregete和Book.objects.aggregate()，均可以
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

aggregate

分組

 annotate() 爲調用的QuerySet中每個對象都生成一個獨立的統計值（統計方法用聚合函數）。 models.Publish.objects.annotate(a=Avg('book__price')).values('a') models.Book.objects.values('publish_id','id').annotate(a=Avg('price')) {'pulish_id':1,'a':11.11} 總結 ：跨表分組查詢本質就是將關聯表join成一張表，再按單表的思路進行分組查詢,，既然是join連表，就可使用我們的雙下劃線進行連表了。

annotate

F查詢

from django.db.models import F,Q F 針對本身單表中字段的比較和處理 # good（點贊）comment（評論）

#比較
models.Book.objects.filter(good__gt=F('comment')*2) #修改
models.Book.objects.all().update(price=F('price')+1)

F比較和修改

Q查詢

Q 對象可使用&(與) 、|（或）、~（非） 操做符組合起來。當一個操做符在兩個Q 對象上使用時，它產生一個新的Q 對象。 bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon")) 你能夠組合& 和|  操做符以及使用括號進行分組來編寫任意複雜的Q 對象。同時，Q 對象可使用~ 操做符取反，這容許組合正常的查詢和取反(NOT) 查詢： bookList=Book.objects.filter(Q(authors__name="yuan") & ~Q(publishDate__year=2017)).values_list("title") bookList=Book.objects.filter(Q(Q(authors__name="yuan") & ~Q(publishDate__year=2017))&Q(id__gt=6)).values_list("title") #能夠進行Q嵌套，多層Q嵌套等，其實工做中比較經常使用
 　查詢函數能夠混合使用Q 對象和關鍵字參數。全部提供給查詢函數的參數（關鍵字參數或Q 對象）都將"AND」在一塊兒。可是，若是出現Q 對象，它必須位於全部關鍵字參數的前面。例如：
 bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python"  #也是and的關係，可是Q必須寫在前面
                             )

Q查詢

ORM執行原生sql語句(瞭解)

在模型查詢API不夠用的狀況下，咱們還可使用原始的SQL語句進行查詢。

　　Django 提供兩種方法使用原始SQL進行查詢：一種是使用raw()方法，進行原始SQL查詢並返回模型實例；另外一種是徹底避開模型層，直接執行自定義的SQL語句。

　　執行原生查詢

　　　　raw()管理器方法用於原始的SQL查詢，並返回模型的實例：

　　　　注意：raw()語法查詢必須包含主鍵。

　　　　這個方法執行原始的SQL查詢，並返回一個django.db.models.query.RawQuerySet 實例。這個RawQuerySet 實例能夠像通常的QuerySet那樣，經過迭代來提供對象實例。

　　　　舉個例子：

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

　　能夠像下面這樣執行原生SQL語句

>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
...     print(p)

　　raw()查詢能夠查詢其餘表的數據。

　　　　舉個例子：

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

　　raw()方法自動將查詢字段映射到模型字段。還能夠經過translations參數指定一個把查詢的字段名和ORM對象實例的字段名互相對應的字典

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

　　原生SQL還可使用參數，注意不要本身使用字符串格式化拼接SQL語句，防止SQL注入！

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

　　直接執行自定義SQL

　　　　有時候raw()方法並不十分好用，不少狀況下咱們不須要將查詢結果映射成模型，或者咱們須要執行DELETE、 INSERT以及UPDATE操做。在這些狀況下，咱們能夠直接訪問數據庫，徹底避開模型層。

　　　　咱們能夠直接從django提供的接口中獲取數據庫鏈接，而後像使用pymysql模塊同樣操做數據庫。

from django.db import connection, connections
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()