Django之操作数据库

1：数据库：

2：MySQL驱动程序的安装

3：Django配置连接数据库

4：在Django中操作数据库

　　（1）原生SQL语句操作

　　（2）ORM模型操作

5：ORM模型的介绍

6：创建一个ORM模型并映射模型到数据库中

7：模型常用的属性

　　（1）常用的Field字段

　　（2）Field字段常用的参数

　　（3）模型中Meta的配置

8：外键

9：表关系

　　（1）一对一

　　（2）一对多（多对一）

　　（3）多对多

10：模型的操作

　　（1）数据的增删改查

　　（2）聚合函数

　　（3）aggregate和annotate的区别

　　（4）F表达式和Q表达式

11：查询集（QuerySet）

12：ORM模型迁移

-------------------------------------------------------------------------------------------------------------------------------

1数据库：简而言之就是存放数据的一个库，用户可以对数据进行增删改查；是网站重要的一个组成部分，只有提供了数据库，网站才能动态的展示。常用的数据库有MySQL，Oracle等。

2MySQL驱动程序的安装：我们使用Django来操作mysql，实际上底层使用的还是python；因此如果我们想要操作数据库首先要安装一个驱动；python3中有多个驱动可供选择如下；

　　（1）MySql-python :也就是MySQLdb 。是对C语言操作mysql的一个简单封装；只支持python2，不支持python3，运行速度最快。

　　（2）mysqlclient：是MySql-python的另一个分支，支持python3。

　　（3）pymsql：纯python实现的一个驱动，效率不高，可以和python无缝连接。

　　（4）mysql-connector-python:mysql官方推出的，纯python开发的，效率不高

本文使用的是mysqlclient:   安装方式： pip install mysqlclient

3：Django配置连接数据库:在操作数据库之前需要Django先连接上数据库，不需要单独创建一个连接对象，只需要在setting中做好相关的配置即可。

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',   #数据库引擎（mysql还是Oracle）
        'NAME': "my01",  #数据库的名字
        "USER":"root",　　　　#数据库的用户名
        "PASSWORD":"qwe123",　　　　#数据库密码
        "HOST":"localhost",   #数据库的主机地址
        "PORT":"3306"      #数据库的端口号
    }
}

4：在Django中操作数据库：Django操作数据库有两种方式。第一种是原生的SQL语句操作，另一种是ORM模型操作

　　（1）原生SQL语句操作

　　　　缺点：（1）重复利用率不高（2）不易修改（3）安全问题（SQL注入）

　　（2）ORM模型操作

5：ORM模型的介绍

　　（1）ORM，全称Object Relational Mapping,中文叫做对象-关系映射。

　　（2）通过ORM我们可以通过类的方式来操作数据库，通过把类映射成表，把实例映射为行，把属性映射为字段；ORM在执行对象操作的时候最终还是会把对应的操作转换为SQL语句。

6：创建一个ORM模型并映射模型到数据库中

　　第一步：创建一个User模型类（在数据库中的表现：类--表名（app的名字_类名（小写）），属性--字段，实例-行）

class User(models.Model):
    username = models.CharField(max_length=10)
    telephone = models.CharField(max_length=11)
    email = models.EmailField()
    sex = models.BooleanField()

　　第二步：执行makemigrations [app_name]       #后面可以跟APP的名字,生成迁移脚本文件

　　第三步：执行migrate [app_name]     #映射到数据库中

7：模型常用的属性

　　（1）常用的Field字段

　　　　AutoField：int类型，自动增长

　　　　BigAutoField：类似于AutoField，范围1-9223372036854775807

　　　　BooleanField：tinyint类型，True/False 

　　　　CharField:  varchar类型，使用时必须指定最大长度，即max_length参数必须传递

　　　　DateField： 日期类型；两个参数auto_now：每次保存的时候都是用当前的时间，比如记录一个记录修改的日期；auto_now_add：在数据第一次创建的时候用当前的时间，比如记录第一次入库的时间。

　　　　DateTimeField：日期时间类型；不仅可以存储日期还可以存储时间。两个参数（auto_now和auto_now_add）

　　　　TimeField：时间类型；

　　　　EmailField：varchar类型；最大长度254

　　　　FileField：用来存储文件的

　　　　FloatField：浮点类型

　　　　ImageField：存储图片

　　　　IntegerField:整型，-2147483648 - 2147483647

　　　　BigIntegerField：大整形，

　　　　PositiveIntegerField：正整型；0-2147483647

　　　　SmallIntegerField:小整型，-32768 - 32767

　　　　TextField：大量的文本类型，longtext

　　　　UUIDField:存储uuid格式的字符串，是一个32位的全球唯一的字符串，一般做主键

　　　　URLField：存储url格式的字符串，max_length默认是200

　　（2）Field字段常用的参数

　　　　null:表示映射为表的时候是否可以为空，默认为False（不能为空）；在使用字符串相关的Field时（CharField、TextField）一般保持默认的False，因为即便是Flase，Django也会创建一个空字符串 " "作为默认值传递进去，如果再设置为True的话，就会用null来存储空值，默认值就变为了两个（""和null）

　　　　blank:表示验证的时候是否可以为空，默认是False。（和null的区别：null是一个数据库级别的，blank是表单验证级别的）

　　　　db_column：表示字段在数据库中的名字

　　　　default：默认值，可以是一个值或者函数，不支持lambda表达式，并且不支持列表、字典。集合等可变的数据结构

　　　　primary_key:默认值false，是否为主键

　　　　unique：是否唯一，一般手机号或者邮箱用

　　（3）模型中Meta的配置

　　　　对于一些模型级别的配置，我们可以在模型中定义一个类，叫做Meta，然后在这个类中添加一些类属性来控制模型。比如在映射到数据库中表的名字使用自己定义的。

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=10)
    telephone = models.CharField(max_length=11)
    email = models.EmailField()
    sex = models.BooleanField(db_column="sex_a")
    create_time = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        db_table = "User",      //表的名字
        ordering = ["create_time"]   //在查找数据的时候根据添加的时间排序

 8：外键

 　　如果一张表中非主键的某个字段指向了另一张表中的主键，那么这个字段就是该表的外键。

　　外键的作用是：防止一张表过于复杂（比如一个需求是一个名字对应一张照片，如果保存在同一种表中数据可能有些乱，最好是分开两张表，一种保存名字，另一张保存图片，同时两张表又有一种制约，可以通过名字找到这张图片，或者通过图片找到这个名字）。

　　在mysql中，表有两种引擎，一种是InnoDB，支持外键的使用；另一种是myisam，暂时不支持外键的使用。

　　Django中的外键使用ForeignKey（to,on_delete,**options）,第一个参数是引用的是哪个模型，第二个参数是使用外键引用的模型被删除的时候，这个字段该如何处理。

　　注意：如果引用的模型在另一个APP中，则第一个参数需要添加app_name.模型名；如果引用的是模型本身自己可以用self或者模型自己的名字

from django.db import models
 
class User(models.Model):         //用户模型
    username = models.CharField(max_length=10)
    password = models.CharField(max_length=20)


class Article(models.Model):   //文章模型
    title = models.CharField(max_length=20)
    content = models.TextField()
    author = models.ForeignKey("User",on_delete=models.CASCADE)         //外键
    category = models.ForeignKey("login.Tags",on_delete=models.CASCADE)  //另一个app，login中model的Tags模型


class Comment(models.Model):
    content = models.TextField()
    origin_comment = models.ForeignKey("self",on_delete=models.CASCADE,null=True)   //外键是模型自己
    # origin_comment = models.ForeignKey("Comment",on_delete=models.CASCADE,null=True)

　　外键删除操作：

　　如果一个模型引用了外键，在对方那个模型被删除掉，该进行什么样的操作；通过on_delete来指定：

　　　　CASCADE:级联操作，如果外键对应的那条数据被删除，那么这条数据也被删除。

　　　　PROTECT:受保护，即只要这条数据引用了外键的那条数据，那么就不能删除外键的那条数据。

　　　　SET_NULL:设置为空，如果外键的那条数据被删除，那么本条数据设置为空，前提是这个字段可以为空。

　　　　SET_DEFAULT:设置为默认值，如果外键的那条数据被删除，那么本条数据设置默认值，前提是要指定一个默认值。

　　　　SET():如果外键那条数据被删除，则调用set函数的值，作为外键的值

　　　　DO_NOTHING：不采取任何行为，看数据库级别的约束。

 

9：表关系：表之间的关系都是通过外键进行关联的，三种关系，一对一，一对多（多对一），多对多

　　（1）一对一

　　　　应用场景：一个用户和一个用户信息表

　　　　实现方式：通过OneToOneField来实现　

　　（2）一对多（多对一）

　　　　应用场景：比如作者和文章之间的关系，一个作者可以有多篇文章，但是一篇文章只能有一个作者

　　　　实现方式：一对多或者多对一，都是通过ForeignKey来实现的　　　　

　　（3）多对多

　　　　应用场景：比如文章和标签之间的关系；一篇文章可以有多个标签，一个标签可以被多篇文章引用

　　　　实现方式：通过ManyToManyField来实现

　　表之间的查询方式：related_name和related_query_name;我们依然使用上面的User模型和Article模型来举例：

　　（1）如果我们想要通过文章获取该作者：

 article = Article.objects.first()   //获取这篇文章
 print(article.author.username)    //直接通过author获取作者

　　（2）如果想要通过作者获取其下的所有文章方式有两种：

#方式一：Django默认每个主表都有一个默认的属性来获取子表的信息，这个属性就是子表模型的小写加上_set(),默认返回一个querydict对象，可以进一步操作 
author = User.objects.first()
 print(author.article_set.all())

#方式二：在默认中添加related_name，以后主表直接通过这个值来获取子表的信息，得到的也是一个querydict对象。
author = models.ForeignKey("User",on_delete=models.CASCADE,related_name="article")

#我们可以直接使用这个值
print(author.article.first().title)

　　（3）relate_name=“+”，表示禁止使用反向查询

10：模型的操作:在ORM框架中，所有的模型操作其实都是映射到数据库中一条数据的操作，因此模型操作也就是数据库表中数据的操作。

　　（1）数据的增删改查

　　　　　　一：以上面表User为例：

　　　　　　　　(1)增加数据：

User.objects.create(username="王三",password="123")

　　　　　　　（2）查数据：（all(),get(),filter()）

　　#查找所有的数据：返回的是一个queryset集合，没有满足条件返回空列表
    users = User.objects.all()
    for user in users:
        print(user.username)
    print(users)

    #查找单个的对象,返回一个对象，没有满足条件时报错
    user = User.objects.get(username="张帆")
    print(user.username)

    #数据过滤查找filter;查询的时候有时需要对数据进行过滤再查询，返回所有满足条件的QuerySet集合
    user = User.objects.filter(username="张帆",password="213123")
    print(user)

    #数据排序；查找数据的时候都是无序的，如果想对某个数据进行排序使用order_by，反向排序加个减号
    users = User.objects.order_by("username")

　　　　　　　（3）改数据：

 #修改数据：获取这条数据，对属性修改，然后保存
    user = User.objects.get(username="张帆")
    user.username = "李四"
    user.save()

　　　　　　　（4）删除数据

 #删除数据；获取数据，然后执行delete（）函数
    user = User.objects.get(username="李四")
    user.delete()

　　　　　　二：查询条件：查找的时候一般使用filter，get，exclude三个方法来实现，我们可以对其传递不同的参数，来实现不同的需求。格式（约束条件_查找条件）

　　　　　　　　第一组：精确和like

　　　　　　　　　　exact：使用精确 = 进行查找 ; User.objects.get(id_exact = 2),如果提供一个None值，sql层面被解释为null

　　　　　　　　　　iexact:  使用like进行查找

　　　　　　　　第二组：包含(title_contains = "hello")

　　　　　　　　　　contains:大小写敏感

　　　　　　　　　　icontains:大小写不敏感

　　　　　　　   第三组：提供包含在容器中值，容器可以是列表，元组，任意一个可迭代的对象

　　　　　　　　　　in：User.objects.get(id_in=[1,2,3])

　　　　　　　　　　也可以传递一个queryset对象进去：获取标题中包含张三的文章

　　　　　　　　　　username = User.objects.filter(username_contains = "张三")

　　　　　　　　　　user = Article.objects.filter(title_in = username)

　　　　　　　　第四组：(id__gt = 3)

　　　　　　　　　　gt:大于

　　　　　　　　　　gte:大于等于

　　　　　　　　　　lt：小于

　　　　　　　　　　lte：小于等于

　　　　　　　　第五组：判断某个字段是否以某个值为开始（结束） (title_startwith = "hello")

　　　　　　　　　　startwith:

　　　　　　　　　　istartwith:

　　　　　　　　　　endswith:

　　　　　　　　　　iendswith:

　　　　　　　　第六组：

　　　　　　　　　　range：判断是否在某个区间;(create_time = range(start,end))

　　　　　　　　第七组：根据时间查询

　　　　　　　　　　date：年月日  （create_time_date=date(2018,3,23)）

　　　　　　　　　　year:年（create_time_year = 2108）

　　　　　　　　　　month:月（同上）

　　　　　　　　　　day：天（同上）

　　　　　　　　　　wek_day：星期几（1表示星期天，7表示星期六）

　　　　　　　　　　time：时分秒（create_time= datetime_time(2,2,2)）,2点2分2秒

　　　　　　　　第八组：是否为空

　　　　　　　　　　isnull:(title_isnull = False) 不为空

　　　　　　　　第九组：正则

　　　　　　　　　　regex：大小写敏感：（title_regex=r"hello"）

　　　　　　　　　　iregex：大小写不敏感：（title_regex=r"hello"）

　　　　　三：关联表查询　

　　　　　　　　比如有两个模型，一个是User，一个是Article；想要获取文章标题中带有“中国”的用户

　　　　　　　　user = User.objects.filter(article_title_contains = "hello")　　　　

　　（2）聚合函数:聚合函数是同aggregate方法来实现的。

　　　　　　（1）Avg:求平均值

　　　　　　（2）Count：获取指定对象的个数

　　　　　　（3）Max和Min：获取最大值最小值

　　　　　　（4）Sum：求和

假设有这样一个模型：

class BookOrder(models.Model):
    book_name = models.CharField(max_length=12)
    price = models.FloatField()

数据表为：

　　# result = BookOrder.objects.aggregate(Avg("price"))    //所有书的平均价格，名字规则为field_avg组成
    result = BookOrder.objects.aggregate(book_price = Avg("price"))    //给这个价格指定一个名字
    print(result)
 
    result = BookOrder.objects.aggregate(book_num = Count("id"))   //求所有的书
    print(result)

    result = BookOrder.objects.aggregate(book_price_max = Max("price"))  //求最大值
    print(result)

    result = BookOrder.objects.aggregate(book_price_min=Min("price"))  //求最小值
    print(result)

    result = BookOrder.objects.aggregate(books_price = Sum("price"))  //求最和
    print(result)

　　（3）aggregate和annotate的区别

 

　　（4）F表达式和Q表达式

 　　F表达式是用来优化ORM模型操作数据库的，并不会立刻去数据库中获取数据，而是在生成SQL语句的时候，动态的获取传给F表达式的值

BookOrder.objects.update(price = F("price")+100)            //更新图书的价格

　　Q表达式：一般查询条件比较多的时候使用，可以使用与或非，&，|，~

books = BookOrder.objects.filter(Q(id=3) | Q(book_name__contains="记"))

11：查询集（QuerySet）

 

　　（1）查询集就是通过查询后得到的一个对象集合。

　　Django中查询操作都是通过 模型名.objects的方式进行；这个objects是一个Manager对象，而这个Manager这个类是一个空壳的类，它本身没有任何的属性和方法；都是通过Python从QuerySet类中动态的添加过来的。

class Manager(BaseManager.from_queryset(QuerySet)):
    pass


class BaseManager:
    @classmethod
    def from_queryset(cls, queryset_class, class_name=None):
        if class_name is None:
            class_name = '%sFrom%s' % (cls.__name__, queryset_class.__name__)
        return type(class_name, (cls,), {
            '_queryset_class': queryset_class,
            **cls._get_queryset_methods(queryset_class),
        })

   

class QuerySet:
    """Represent a lazy database lookup for a set of objects."""

    def __init__(self, model=None, query=None, using=None, hints=None):
        self.model = model
        self._db = using
        self._hints = hints or {}
        self.query = query or sql.Query(self.model)
        self._result_cache = None
        self._sticky_filter = False
        self._for_write = False
        self._prefetch_related_lookups = ()
        self._prefetch_done = False
        self._known_related_objects = {}  # {rel_field: {pk: rel_obj}}
        self._iterable_class = ModelIterable
        self._fields = None

　　　　............(后面省略)

　　（2）两大特性:

　　　　惰性执行：创建查询集不会立刻执行，只到调用数据时才会去数据库中查询，调用数据包括：迭代，使用步长做切片操作，调用len函数，调用list函数，判断

　　　　缓存：使用同一个查询集，第一次会发生数据库查询，然后django会把数据缓存起来，以后再使用的时候不会去数据库查询而是直接使用

　　（3）常用的API：

　　　　1.filter：将满足条件的数据提取出来，返回一个queryset对象

　　　　2.exclude：排除满足条件的对象，返回一个queryset对象

　　　　3.annotate：

　　　　4.order_by：排序（倒序加减号），多个order_by链式使用时，会把前面的打乱，以后面的为准

　　　　5.values:规定提取那些字段，返回的是一个字典类型。默认会把所有字段都提取出来

　　　　6.values_list:同上，不过返回的是一个元组

　　　　7.defer:过滤掉一些字段，返回的是一个模型

　　　　8.only：只保留这个字段（和上面相反）

　　　　9.all:返回queryset对象

　　　　10.select_related：

　　　　11.prefetch_related:

　　　　12.get：只返回一条满足条件的数据，如果是多条或者没有都会报错

　　　　13.create：创建一条数据，并保存

　　　　14.get_or_create：如果数据库中存在这个数据就返回，不存在就创建；返回一个元组（第一个参数是这个对象，第二个参数是boolean类型）

　　　　15.bulk_create:一次创建多个数据；bulk_create（[book_name="111",book_name="222"]）

　　　　16.count:获取数据的个数，比len函数高效

　　　　17.first和last：返回queryset中的第一条和最后一条

　　　　18.aggregate：使用聚合函数

　　　　19.exists：判断是否存在

　　　　20.distinct：去掉重复的数据；

　　　　21.update：更新

　　　　22.delete：删除数据

　　　　23.切片：Books.objects.all()[1:3];切片不是把数据都提取出来再做切片，而是在底层直接使用LIMIE和OFFSET

 12：ORM模型迁移

　　（1）makemigrations：将模型生成迁移脚本

　　　　　　app_label:后面跟一个或者多个app，只会针对这几个app生成迁移脚本，如果没有写就是针对所有都生成

　　　　　　--name：给这个迁移脚本生成一个名字

　　　　　　--empty：生成一个空的迁移脚本

　　（2）migrate：将生成的迁移脚本映射到数据库中

　　　　　　app_label:规定那几个app

　　　　　　app_label migrationname;将某个app下指定名字的migration文件映射到数据库中

　　　　　　--fake:可以将指定的迁移脚本文件名字添加到数据库中，但是并不会把迁移脚本文件转换为sql语句，修改数据库中的表

　　　　　　--fake-initial:将第一次生成的迁移文件版本号记录在数据库中，但并不会执行迁移脚本

　　（3）showmigrations:查看某个app的迁移文件；如果后面没有app将查看所有的

　　（4）sqlmigrate:查看某个迁移文件映射到数据库中转换的SQL语句