數據庫與ORM

數據庫的配置

1　django默認支持sqlite，mysql, oracle,postgresql數據庫。

     <1> sqlite

            django默認使用sqlite的數據庫，默認自帶sqlite的數據庫驅動 。

　　　 引擎名稱：django.db.backends.sqlite3

     <2> mysql

            引擎名稱：django.db.backends.mysql

2　mysql驅動程序

•    MySQLdb(mysql python)
•    mysqlclient
•    MySQL
•    PyMySQL(純python的mysql驅動程序)

3　在django的項目中會默認使用sqlite數據庫，在settings里有如下設置：

如果我們想要更改數據庫，需要修改如下：

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的數據庫名稱

        'USER': 'root',   #你的數據庫用戶名

        'PASSWORD': '', #你的數據庫密碼

        'HOST': '', #你的數據庫主機，留空默認為localhost

        'PORT': '3306', #你的數據庫端口

    }

}

注意：

NAME即數據庫的名字，在mysql連接前該數據庫必須已經創建，而上面的sqlite數據庫下的db.sqlite3則是項目自動創建

USER和PASSWORD分別是數據庫的用戶名和密碼。

設置完后，再啟動我們的Django項目前，我們需要激活我們的mysql。

然后，啟動項目，會報錯：no module named MySQLdb

這是因為django默認你導入的驅動是MySQLdb，可是MySQLdb對於py3有很大問題，所以我們需要的驅動是PyMySQL

所以，我們只需要找到項目名文件下的__init__,在里面寫入：

import pymysql
pymysql.install_as_MySQLdb()

問題解決！

ORM表模型

表(模型)的創建：

實例：我們來假定下面這些概念，字段和關系

作者模型：一個作者有姓名。

作者詳細模型：把作者的詳情放到詳情表，包含性別，email地址和出生日期，作者詳情模型和作者模型之間是一對一的關系（one－to－one）（類似於每個人和他的身份證之間的關系），在大多數情況下我們沒有必要將他們拆分成兩張表，這里只是引出一對一的概念。

出版商模型：出版商有名稱，地址，所在城市，省，國家和網站。

書籍模型：書籍有書名和出版日期，一本書可能會有多個作者，一個作者也可以寫多本書，所以作者和書籍的關系就是多對多的關聯關系（many－to－many），一本書只應該由一個出版商出版，所以出版商和書籍是一對多關聯關系（one－to－many），也被稱作外鍵。

from django.db import models
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名稱")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

分析代碼：

       <1>  每個數據模型都是django.db.models.Model的子類，它的父類Model包含了所有必要的和數據庫交互的方法。並提供了一個簡介漂亮的定義數據庫字段的語法。

       <2>  每個模型相當於單個數據庫表（多對多關系例外，會多生成一張關系表），每個屬性也是這個表中的字段。屬性名就是字段名，它的類型（例如CharField）相當於數據庫的字段類型（例如varchar）。大家可以留意下其它的類型都和數據庫里的什么字段對應。

       <3>  模型之間的三種關系：一對一，一對多，多對多。

             一對一：實質就是在主外鍵（author_id就是foreign key）的關系基礎上，給外鍵加了一個UNIQUE＝True的屬性；

             一對多：就是主外鍵關系；（foreign key）

             多對多：(ManyToManyField) 自動創建第三張表(當然我們也可以自己創建第三張表：兩個foreign key)

1，ORM之增（create，save）

from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                            author.save()

    #save方式二:     author=Author()
                            author.name="alvin"
                            author.save()

重點來了－－－－－－－>那么如何創建存在一對多或多對多關系的一本書的信息呢？(如何處理外鍵關系的字段如一對多的publisher和多對多的authors)

#一對多(ForeignKey):

    #方式一: 由於綁定一對多的字段,比如publish,存到數據庫中的字段名叫publish_id,所以我們可以直接給這個
    #       字段設定對應值:
           Book.objects.create(title='php',
                               publisher_id=2,   #這里的2是指為該book對象綁定了Publisher表中id=2的行對象
                               publication_date='2017-7-7',
                               price=99)


    #方式二:
    #       <1> 先獲取要綁定的Publisher對象:
        pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
                state_province='河北',country='China',website='http://www.hbu.com')
    OR  pub_obj=Publisher.objects.get(id=1)

    #       <2>將 publisher_id=2 改為  publisher=pub_obj
　　　　　　　Book.objects.create(title='php',
                               publisher=pub_obj,   #添加的為出版社對象時不使用**_id了。
                               publication_date='2017-7-7',
                               price=99)
#多對多(ManyToManyField()):

    #方式一：
    #取出要添加的作者對象列表，通過一本書籍的<ManyToManyDescriptor object>  .add方法添加作者對象。

    author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name='alvin')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同於:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    #-------------------
    #方式二：
    #取出要添加的書籍對象列表，通過一個作者對象的.book_set.add(*book)添加書籍對象。
    book=models.Book.objects.filter(id__gt=1)
    authors=models.Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    #方式三：取出書籍或者作者對象，直接添加對應的id.

    book.authors.add(1)       #book.authors.add(1,2) 可一次添加多個id，已存在的id不會重復添加
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 如果第三張表是通過models.ManyToManyField()自動創建的,那么綁定關系只有上面一種方式
#     如果第三張表是自己創建的:
     class Book2Author(models.Model):
            author=models.ForeignKey("Author")
            Book=  models.ForeignKey("Book")
#     那么就還有一種方式:
            author_obj=models.Author.objects.filter(id=2)[0]
            book_obj  =models.Book.objects.filter(id=3)[0]

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()

2，ORM之刪（delete）

>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})

我們表面上刪除了一條信息，實際卻刪除了三條，因為我們刪除的這本書在Book_authors表中有兩條相關信息，這種刪除方式就是django默認的級聯刪除。

3，ORM之改（update，save）

實例：

注意：

<1> 第二種方式修改不能用get的原因是：update是QuerySet對象的方法，get返回的是一個model對象，它沒有update方法，而filter返回的是一個QuerySet對象(filter里面的條件可能有多個條件符合，比如name＝'alvin',可能有兩個name＝'alvin'的行數據)。

<2>在“插入和更新數據”小節中，我們有提到模型的save()方法，這個方法會更新一行里的所有列。 而某些情況下，我們只需要更新行里的某幾列。

#---------------- update方法直接設定對應屬性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)


#--------------- save方法會將所有屬性重新設定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;

此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你可以同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。

注意，這里因為update返回的是一個整形，所以沒法用query屬性；對於每次創建一個對象，想顯示對應的raw sql，需要在settings加上日志記錄部分：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

4，ORM之查（filter，value）

4.1 必知必會13條

# 查詢相關API：

#  <1>filter(**kwargs):      它包含了與所給篩選條件相匹配的對象

#  <2>all():                 查詢所有結果

#  <3>get(**kwargs):         返回與所給篩選條件相匹配的對象，返回結果有且只有一個，如果符合篩選條件的對象超過一個或者沒有都會拋出錯誤。

#-----------下面的方法都是對查詢的結果再進行處理:比如 objects.filter.values()--------

#  <4>values(*field):        返回一個ValueQuerySet——一個特殊的QuerySet，運行后得到的並不是一系列 model的實例化對象，而是一個可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     它包含了與所給篩選條件不匹配的對象

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

#  <7>reverse():             對查詢結果反向排序

#  <8>distinct():            從返回結果中剔除重復紀錄

#  <9>values_list(*field):   它與values()非常相似，它返回的是一個元組序列，values返回的是一個字典序列

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

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

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

#  <13>exists():             如果QuerySet包含數據，就返回True，否則返回False


---------------了不起的雙下划線(__)之單表條件查詢----------------

# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 獲取id大於1 且 小於10的值
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 獲取id等於11、22、33的數據
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小寫不敏感
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范圍bettwen and
#
# startswith，istartswith, endswith, iendswith,

雙下划線（__）單表查詢

4.2 QrerySet的惰性機制

所謂惰性機制：Publisher.objects.all()或者.filter()等都只是返回了一個QuerySet（查詢結果集對象），它並不會馬上執行sql，而是當調用QuerySet的時候才執行。

QuerySet特點：

       <1>  可迭代的

       <2>  可切片

#objs=models.Book.objects.all()#[obj1,obj2,ob3...]

    #QuerySet:   可迭代

    # for obj in objs:#每一obj就是一個行對象
    #     print("obj:",obj)
    # QuerySet:  可切片

    # print(objs[1])
    # print(objs[1:4])
    # print(objs[::-1])

QuerySet的高效使用：

<1>Django的queryset是惰性的

     Django的queryset對應於數據庫的若干記錄（row），通過可選的查詢來過濾。例如，下面的代碼會得到數據庫中名字為‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
     上面的代碼並沒有運行任何的數據庫查詢。你可以使用person_set，給它加上一些過濾條件，或者將它傳給某個函數，這些操作都不會發送給數據庫。這是對的，因為數據庫查詢是顯著影響web應用性能的因素之一。

<2>要真正從數據庫獲得數據，你可以遍歷queryset或者使用if queryset,總之你用到數據時就會執行sql.為了驗證這些,需要在settings里加入 LOGGING(驗證方式)
        obj=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)

        # if obj:
        #     print("ok")

<3>queryset是具有cache的當你遍歷queryset時，所有匹配的記錄會從數據庫獲取，然后轉換成Django的model。這被稱為執行（evaluation）.這些model會保存在queryset內置的cache中，這樣如果你再次遍歷這個queryset，你不需要重復運行通用的查詢。
        obj=models.Book.objects.filter(id=3)

        # for i in obj:
        #     print(i)
                          ## models.Book.objects.filter(id=3).update(title="GO")
                          ## obj_new=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)   #LOGGING只會打印一次

<4>簡單的使用if語句進行判斷也會完全執行整個queryset並且把數據放入cache，雖然你並不需要這些數據！為了避免這個，可以用exists()方法來檢查是否有數據：

            obj = Book.objects.filter(id=4)
            #  exists()的檢查可以避免數據放入queryset的cache。
            if obj.exists():
                print("hello world!")

<5>當queryset非常巨大時，cache會成為問題處理成千上萬的記錄時，將它們一次裝入內存是很浪費的。更糟糕的是，巨大的queryset可能會鎖住系統進程，讓你的程序瀕臨崩潰。要避免在遍歷數據的同時產生queryset cache，可以使用iterator()方法來獲取數據，處理完數據就將其丟棄。
        objs = Book.objects.all().iterator()
        # iterator()可以一次只從數據庫獲取少量數據，這樣可以節省內存
        for obj in objs:
            print(obj.name)
        #BUT,再次遍歷沒有打印,因為迭代器已經在上一次遍歷(next)到最后一次了,沒得遍歷了
        for obj in objs:
            print(obj.name)

     #當然，使用iterator()方法來防止生成cache，意味着遍歷同一個queryset時會重復執行查詢。所以使用iterator()的時候要當心，確保你的代碼在操作一個大的queryset時沒有重復執行查詢。

總結:
    queryset的cache是用於減少程序對數據庫的查詢，在通常的使用下會保證只有在需要的時候才會查詢數據庫。使用exists()和iterator()方法可以優化程序對內存的使用。不過，由於它們並不會生成queryset cache，可能會造成額外的數據庫查詢。