Django

阅读目录

        一、多表 sql 

        二、创建模型

        三、多表 - 添加

        四、查询 - 基于对象 - 跨表

        五、查询 - 基于双下划线（join）- 跨表

        六、聚合查询 - 分组查询

        七、F查询 - Q查询

        八、关联管理器

        九、补充知识

一、多表 sql 

一对多
Book
　　id 　 title 　 price 　 publish 　 email 　 addr
　　1　   php     100    人民出版社    111       北京
　　2    python   120    沙河出版社    222       沙河
　　3       go       110    人民出版社    119       北京
　　4      java     300    人民出版社    111        北京

Book多
　　id 　 title 　 price 　 publish_id
　　1      php      100            1
　　2    python   120            1
　　3       go       110            2
　　4      java     300            1

Publish一
　　id 　 name 　 email 　 addr
　　1  人民出版社  111        北京
　　2  沙河出版社  222        沙河

查询python这本书的出版社的邮箱(子查询）
　　select   publish_id   from  Book   where   title="python"
　　select   email   from   Publish   where   id=1   id=(上边的)

一旦确定是一对多的表关系：建立一对多的关系------->在多的表中建立关联字段（publish_id）

######################################################################

多对多：
Book
　　id 　 title 　 price 　 publish_id
　　1      php      100             1
　　2    python   120             1
　　3       go       110             2
　　4      java     300             1

Author
　　id 　 name 　 age 　 addr
　　1       alex        34       北京
　　2       egon       55       南京

Book2Author
　　id 　 book_id 　 author_id
　　1          2 　　　　   1
　　2　　   2 　　　　   2
　　3　　   3　　　　    2

alex出版过的书籍名称(子查询)
　　select   id   form   Author   where   name='alex' （拿到alex这个id）
　　select   book_id   from   Book2Author   where  author_id=1
　　select   title   from   Book id=book_id

一旦确定表关系是多对多：创建第三张表：
　　　　id　　book_id　　author_id

######################################################################

一对一：
Author
　　id 　 name 　 age　 Authordetail_id(unique)
　　1　　alex 　   34 　　　　 1
　　2　　egon 　  55 　　　　 2

AuthorDetail
　　id 　 addr　 gender 　 tel 　 gf_name
　　1　   北京 　  male      110      小花
　　2　　南京　  male       911      小红

######################################################################

一旦确定是一对多的关系：建立一对多的关系------->在多的表中建立关联字段 （一个出版社可以出版多本书）
一旦确定多对多的关系：建立多对多的关系--------->创建第三张表（关联表）：id和两个关联字段 （一本书可以有多个作者，一个作者可以出版多本书；）
一旦确定一对一的关系：建立一对一的关系---------->在两张表中的任意一张表中建立关联字段+unique （一个作者只有一个详细信息）

######################################################################

Publish
Book
Author
AuthorDetail
Book2Author

对应的sql语句

######################################################################

CREATE  TABLE  publish（
　　id  INT  PRIMARY  KEY  auto_increment,
　　name  VARCHAR(20)
);

CREATE  TABLE  book(
　　id  INT  PRIMARY  KEY  auto_increment,
　　title  VARCHAR (20),
　　price  DECIMAL (8,2),
　　pub_date  DATE,
　　publish_id  INT,
　　FOREIGN  KEY (publish_id) REFERENCES publish(id) 一个出版社可以出版多本书
);

CREATE  TABLE  authordetail(
　　id  INT  PRIMARY  KEY  auto_increment,
　　tel  VARCHAR(20)
);
CREATE  TABLE  author(
　　id  INT  PRIMARY  KEY  auto_increment,
　　name  VARCHAR(20),
　　age  INT,
　　authordetail_id  INT  UNIQUE,
　　FOREIGN  KEY(authordetail_id)  REFERENCES  authordetail(id) 一个作者只有一个详细信息
);
CREATE  TABLE  book2author(
　　id  INT  PRIMARY  KEY  auto_increment,
　　book_id  INT,
　　author_id  INT,
　　FOREIGN  KEY(book_id)  REFERENCES  book(id),
　　FOREIGN  KEY(author_id)  REFERENCES  author(id) 一个书可以有多个作者，一个作者可以出版多本书
);

二、创建模型

model.py

# -*- encoding:utf-8 -*-
from django.db import models

# Create your models here.

'''
Book
Publish
Author
AuthorDetail
Book2Author  会自定生成

Book    --   Publish        一对多
Author  --   AuthorDetail   一对一
Book    --   Author         多对多  Book2Author

'''

# 作者详情表
class AuthorDetail(models.Model):
    # id字段是自动添加的，如果不加主键数据库迁移的时候它也会给你默认生成一个id的字段，可以不写nid，写了就用你写的。
    nid = models.AutoField(primary_key=True)
    birthday = models.DateField()
    telephone = models.BigIntegerField()
    addr = models.CharField(max_length=64)

# 作者表
class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntegerField()

    # 与AuthorDetail建立一对一的关系
    # to_field="nid"这个可加可不加，它会默认去关联主键
    # on_delete=models.CASCADE这句不写会报错
    authorDetail = models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)

    def __str__(self):

        return self.name

# 出版社表
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()

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建立一对多的关系,外键字段建立在多的一方；django会自动给你补全publish_id; to就是foreign key哪个;加上引号就会在全局里边找；

    publish = models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,null=True)
    # 关联主键nid；这句话相当于下面两句;在django2.0要加上on_delete=models.CASCADE;null=True是允许这个字段为空
    '''         
        publish_id INT,
        FOREIGN KEY（publish_id)REFERENCES publish(id)   to_field这个字段的nid主键；上边的publish在数据库迁移的时候就是这两句话
    '''

    # 多对多,会自动生成第三张表；下面的几个意思是一样的
    authors = models.ManyToManyField(to="Author")

    def __str__(self):

        return  self.title

    '''
        CREATE TABLE book2author(      上边那一句话执行的结果就相当于会生成这个；book_authors它就是这样拼的
            id INT PRIMARY KEY auto_increment,
            book_id INT,
            author_id INT,
            FOREIGN KEY(book_id)REFERENCES book(id),
            FOREIGN KEY(author_id)REFERENCES author(id),
        )
    '''
    # class Book2Author(models.Model):  这是自己写的第三张表
    #     nid = models.AutoField(primary_key=True)
    #     book = models.ForeignKey(to="Book") to_field="nid"
    #     author = models.ForeignKey(to="Author")

'''
数据库迁移
    python manage.py makemigrations
    python manage.py migrate
'''

注意事项：

•  表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　
•  id 字段是自动添加的
•  对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名 如  authordetail_id   、 publish_id   、book_id   、author_id
•  这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
•  定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。
• 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。

一对一就是oneToOneField;一对多就是ForeignKey;它俩是一样的，会在那张表里边多生成一个字段，加一个_id+一个约束关系；多对多就是ManyToManyField，会生成一个第三张关系表；

三、多表 - 添加

# -*- encoding:utf-8 -*-
from django.shortcuts import render,HttpResponse

# Create your views here.

from app01.models import *

def add(request):
    '''
    绑定关系视图
    :param request:
    :return:
    '''

    # pub = Publish.objects.create(name="人民出版社",email="123@qq.com",city="北京")

    ################################### 一对多添加记录 ###################################

    # 方式1：
    # 为book表绑定出版社：book  ----- publish
    # book_obj = Book.objects.create(title="红楼梦",price=80,publishDate="2008-7-7",publish_id=1)
    # print(book_obj)  #  Book object (3)
    # print(book_obj.title)   # 红楼梦
    # print(book_obj.price)   # 80

    # 方式2：
    # pub_obj= Publish.objects.filter(nid=1).first()
    #
    # book_obj = Book.objects.create(title="西游记", price=80, publishDate="2008-7-7", publish=pub_obj)
    # print(book_obj.title)  # 西游记
    # print(book_obj.price)  # 80
    # print(book_obj.publishDate)  # 2008-7-7
    # print(book_obj.publish)  # Publish object (1)   # 与这本书籍关联的出版社对象
    # print(book_obj.publish_id) # 1

    ################################### 一对多查询记录 ###################################
    # 查询西游记的出版社对应的邮箱
    # 太繁琐！！！
    # obj_id = Book.objects.filter(title="西游记").first().publish_id
    # pub_obj = Publish.objects.filter(nid=obj_id).first()
    # print(pub_obj.email)

    # 通过这本书的对象可以直接得到出版社的对象:book_obj.publish
    # book_obj = Book.objects.filter(title="西游记").first()
    # print(book_obj.publish.email)

    ################################### 多对多添加记录 ###################################
    # book_obj = Book.objects.create(title="水浒传", price=80, publishDate="2008-7-7", publish_id=1)
    #
    # mm = Author.objects.get(name='mm')
    # tt = Author.objects.get(name='tt')

    # 由于app01_book_authors表不是我们代码生成的，是在创建多对多的关系的时候创建的，所以不能直接使用这个表来写书籍和
    # 作者的关系,需要使用一个接口

    # 绑定多对多的API
    # book_obj.authors.add(mm,tt)
    # # 其他写法
    # book_obj.authors.add(1,2)
    # book_obj.authors.add(*[1,2])

    # 可以单独绑定一个author
    # book_obj = Book.objects.filter(nid=6).first()
    # book_obj.authors.add(2)


    # 解除多对多的关系
    # book_obj = Book.objects.filter(nid=6).first()
    # book_obj.authors.remove(2)  # 2表示的是nid=2的author
    # book_obj.authors.remove(1,2)
    # book_obj.authors.remove(*[1,2])

    # book_obj.authors.clear() # 清空

    # print(book_obj.authors.all()) # [obj1,obj2...] queryset:与这本书关联的所有作者对象的集合
    # <QuerySet [<Author: Author object (1)>, <Author: Author object (2)>]>

    # 查询主键为6的书籍的所有作者的名字
    # ret = book_obj.authors.all().values("name")
    # print(ret) # <QuerySet [{'name': 'mm'}, {'name': 'tt'}]>

    return HttpResponse("OK")

四、查询 - 基于对象 - 跨表

'''
A-B
正向查询：关联属性在A表中,A查B
反向查询：关联属性在A表中,B查A

1.基于对象的跨表查询(子查询)

# 一对多查询
    正向查询按字段
    反向查询按表名小写_set.all()

                                   book_obj.publish
        Book(关联属性:publish)对象 -------------------> Publish对象
        Book(关联属性:publish)对象 <------------------- Publish对象
                               publish_obj.book_set.all() # queryset()


# 多对多查询
    正向查询按字段
    反向查询按表名小写_set.all()

                                book_obj.authors.all()
        Book(关联属性:authors)对象 -------------------> Author对象
        Book(关联属性:authors)对象 <------------------- Author对象
                               aurhors_obj.book_set.all() # queryset()

# 一对一查询
    正向查询按字段
    反向查询按表名小写

                                        author_obj.authorDetail
        Author(关联属性:authorDetail)对象 -------------------> AuthorDetail对象
        Author(关联属性:authorDetail)对象 <------------------- AuthorDetail对象
                                        authorDetail_obj.author 
'''

def query(request):
    '''
    跨表查询：
        1.基于对象查询
        2.基于双下划线查询
        3.聚合与分组查询
        4.F 与 Q查询
    :param request:
    :return:
    '''
    #--------------------------------------- 1.基于对象的跨表查询(子查询) ---------------------------------------

    # 一对多正向查询
    # 查询水浒传这本书的出版社的名字
    # book_obj = Book.objects.filter(title="水浒传").first()
    # print(book_obj.publish.name)  # 与这本书关联的出版社对象 # 人民出版社

    # 一对多反向查询
    # 查询人民出版社出版过的书籍名称
    # publish_obj = Publish.objects.filter(name="人民出版社").first()
    # print(publish_obj.book_set.all())


    # 多对多正向查询
    # 查询水浒传这本书的所有作者的名字
    # book_obj = Book.objects.filter(title="水浒传").first()
    # print(book_obj.authors.all())  # queryset对象 # <QuerySet [<Author: mm>, <Author: tt>]>

    # author_list = book_obj.authors.all()
    # for author in author_list:
    #     print(author.name)
    # mm
    # tt

    # 多对多反向查询
    # 查询作者mm写的所有书的名字
    # author_obj = Author.objects.filter(name="mm").first()
    # book_list = author_obj.book_set.all()
    # for book in book_list:
    #     print(book.title)
    # 水浒传

    # 一对一正向查询
    # 查询mm的手机号
    # author_obj = Author.objects.filter(name="mm").first()
    # print(author_obj.authorDetail.telephone)  # 110

    # 一对一反向查询
    # 查询手机号为911的作者姓名和年龄
    # authorDetail = AuthorDetail.objects.filter(telephone="911").first()
    # print(authorDetail.author.name,authorDetail.author.age) # tt 20

五、查询 - 基于双下划线（join）- 跨表

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要做跨关系查询，就使用两个下划线来链接模型(model)间关联字段的名称，直到最终链接到你想要的 model 为止。

关键点：正向查询按字段，反向查询按表名。

'''
A-B
正向查询：关联属性在A表中,A查B
反向查询：关联属性在A表中,B查A

2.基于双下划线的跨表查询(join查询)

    正向查询按字段
    反向查询按表名小写

'''
def query(request):
    # --------------------------------------- 2.基于双下划线的跨表查询(join查询) ---------------------------------------
    '''
    正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表
    '''

    # 一对多查询
    # 查询水浒传这本书的出版社的名字

    # 方式一：正向查询
    # ret = Book.objects.filter(title="水浒传").values("publish__name")  # values相当于sql中的select
    # print(ret) # <QuerySet [{'publish__name': '人民出版社'}]>

    # 方式二：反向查询
    # ret = Publish.objects.filter(book__title="水浒传").values("name")
    # print(ret)  # <QuerySet [{'name': '人民出版社'}]>

    '''
    sql写法：
    SELECT app01_publish.name FROM app01_book INNER JOIN app01_publish
    ON app01_book.publish_id = app01_publish.nid
    WHERE app01_book.title="水浒传"
    '''

    # 多对多查询
    # 查询水浒传这本书的所有作者的名字

    # 方式一：正向查询,按字段authors通知ORM引擎join book_authors与author表
    # 需求：通过Book表join与其关联的Author表,

    # ret = Book.objects.filter(title="水浒传").values("authors__name")
    # print(ret)  # <QuerySet [{'authors__name': 'mm'}, {'authors__name': 'tt'}]>

    # 方式二：反向查询,按表名小写book通知ORM引擎join book_authors与book表
    # 需求：通过Author表join与其关联的Book表,

    # ret = Author.objects.filter(book__title="水浒传").values("name")
    # print(ret)  # <QuerySet [{'authors__name': 'mm'}, {'authors__name': 'tt'}]>

    '''
    sql写法：
    SELECT app01_author.name FROM app01_book INNER JOIN app01_book_authors
    ON app01_book.nid = app01_book_authors.book_id
    INNER JOIN app01_author
    ON app01_book_authors.author_id = app01_author.nid
    WHERE app01_book.title="水浒传"
    '''

    # 一对一查询
    # 查询mm的手机号

    # 方式一：正向查询

    # ret = Author.objects.filter(name="mm").values("authorDetail__telephone")
    # print(ret)  # <QuerySet [{'authorDetail__telephone': 110}]>

    # 方式二：反向查询
    # ret = AuthorDetail.objects.filter(author__name="mm").values("telephone")
    # print(ret)  # <QuerySet [{'telephone': 110}]>

    # 进阶练习：

    # 练习：手机号以110开头的作者出版过的所有书籍名称以及书籍出版社名称

    # book表为基表：
    # 方式一：
    # 需求：通过Book表join AuthorDetail表，Book与AuthorDetail无关联，所以必须连续跨表

    # ret = Book.objects.filter(authors__authorDetail__telephone__startswith="110").values("title","publish__name")
    # print(ret)  # <QuerySet [{'publish__name': '人民出版社', 'title': '水浒传'}]>

    # 方式二：
    # 需求：通过AuthorDetail表
    # ret = AuthorDetail.objects.filter(telephone__startswith="110").values("author__book__title","author__book__publish__name")
    # print(ret)  # <QuerySet [{'author__book__title': '水浒传', 'author__book__publish__name': '人民出版社'}]>

    # 方式三：
    # 需求：通过Author表
    # ret = Author.objects.filter(authorDetail__telephone__startswith="110").values("book__title","book__publish__name")
    # print(ret)  # <QuerySet [{'book__publish__name': '人民出版社', 'book__title': '水浒传'}]>

六、聚合查询 - 分组查询

models.py（增加一个emp表）

class Emp(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
    salary=models.DecimalField(max_digits=8,decimal_places=2)
    dep=models.CharField(max_length=32)
    province=models.CharField(max_length=32)

def query(request):

    # --------------------------------------- 3.聚合与分组查询 ---------------------------------------

    # --------------------------------------->聚合 aggregate:聚合统计函数,返回值是一个字典，不再是queryset
    # 查询所有书籍的平均价格
    from django.db.models import Avg,Max,Min,Count

    # ret = Book.objects.all().aggregate(Avg("price"))
    # print(ret)  # {'price__avg': 80.0}

    # --------------------------------------->分组查询 annotate:返回值依然是queryset

    # ---------------------->单表分组查询：

    # 示例1：
    # 查询每一个部门的名称以及员工的平均薪水

    # sql:SELECT dep,Avg(salary) FROM app01_emp GROUP BY dep

    # ret = Emp.objects.values("dep").annotate(avg_salary=Avg("salary"))
    # print(ret)  # <QuerySet [{'dep': '教学部', 'avg_salary': 51000.0}, {'dep': '保安部', 'avg_salary': 5000.0}]>

    # 单表分组查询的ORM语法：单表模型.objects.values("group by的字段").annotate(聚合函数("统计字段"))

    # 示例2：
    # 查询每一个省份的名称以及对应的员工数

    # sql:SELECT province,Count(id) FROM app01_emp GROUP BY province

    # ret = Emp.objects.values("province").annotate(c=Count("id"))
    # print(ret)  # <QuerySet [{'c': 2, 'province': '山东省'}, {'c': 1, 'province': '河北省'}]>

    # 补充知识点：

    # ret = Emp.objects.all()
    # print(ret) # sql:select * from emp

    # ret = Emp.objects.all().values("name")
    # print(ret)  # sql:select name from emp

    # 在单表分组下，按着主键进行group by是没有任何意义的

    # ---------------------->跨表分组查询：

    # 示例1：查询每一个出版社的名称以及出版的书籍个数

    # 分组查询sql:
    # SELECT  app01_publish.name, Count("title") FROM app01_book
    # INNER JOIN app01_publish
    # ON app01_book.publish_id = app01_publish.nid
    # GROUP BY app01_publish.nid;

    # 思考：如何用ORM语法实现跨表分组查询
    # ret = Publish.objects.values("nid").annotate(c=Count("book__title"))
    # print(ret)  # <QuerySet [{'c': 3, 'nid': 1}, {'c': 1, 'nid': 2}]>

    # ret = Publish.objects.values("name").annotate(c=Count("book__title"))
    # print(ret)  # <QuerySet [{'c': 3, 'name': '人民出版社'}, {'c': 1, 'name': '南京出版社'}]>

    # ret = Publish.objects.values("nid").annotate(c=Count("book__title")).values("name","c")
    # print(ret)  # <QuerySet [{'name': '人民出版社', 'c': 3}, {'name': '南京出版社', 'c': 1}]>

    # 示例2：查询每一个作者的名字以及出版过的书籍的的最高价格

    # sql:
    # SELECT app01_author.name, MAX(app01_book.price) FROM app01_author
    # INNER JOIN app01_book_authors
    # ON app01_author.nid = app01_book_authors.author_id
    # INNER JOIN app01_book
    # ON app01_book_authors.book_id = app01_book.nid
    # GROUP BY app01_author.nid;

    # ret = Author.objects.values("nid").annotate(m=Max("book__price")).values("name","m")
    # print(ret)  # <QuerySet [{'name': 'mm', 'm': Decimal('80.00')}, {'name': 'tt', 'm': Decimal('80.00')}]>

    # 总结跨表的分组查询的模型；
    # 每一个后的表模型.objects.values("pk").annotate(聚合函数(关联表__统计字段))

    # 示例3：查询每一个书籍的名称以及对应的作者个数

    # ret = Book.objects.values("pk").annotate(c=Count("authors__nid")).values('title',"c")
    # print(ret)  # <QuerySet [{'title': '红楼梦', 'c': 0}, {'title': '西游记', 'c': 0}, {'title': '三国演义', 'c': 0}, {'title': '水浒传', 'c': 2}]>

    ############################ 跨表分组查询的另一种玩法 ############################

    # 示例1：查询每一个出版社的名称以及出版的书籍个数

    # ret = Publish.objects.all().annotate(c=Count("book__title")).values("name","c")
    # print(ret)  # <QuerySet [{'name': '人民出版社', 'c': 3}, {'name': '南京出版社', 'c': 1}]>


    # 练习：

    # 统计每一本以py开头的书籍的作者个数：

    # ret = Book.objects.filter(title__startswith="py").values("pk").annotate(c=Count("authors__name")).values("title","c")

    # 统计不止一个作者的书籍：

    # ret = Book.objects.values("pk").annotate(c=Count("authors__name")).filter(c__gt=1).values("title","c")
    # print(ret)  # <QuerySet [{'c': 2, 'title': '水浒传'}]>

七、F查询 - Q查询

models.py(Book表添加read_num和comment_num字段)

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)

    read_num = models.IntegerField()
    comment_num = models.IntegerField()

    publish = models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,null=True)
   
    authors = models.ManyToManyField(to="Author")

给一个已经存在的有数据的表添加新的 字段带来的问题：

解决方法：添加default=0

　　

def query(request):

    ############################ F查询和Q查询 ############################

    from django.db.models import F,Q

    # 示例1：查询评论数大于阅读数的书籍
    # ret = Book.objects.filter(comment_num__gt=F("read_num"))
    # print(ret)  # <QuerySet [<Book: 西游记>, <Book: 水浒传>]>

    # 示例2：所有书籍价格提高10元
    # Book.objects.all().update(price=F("price")+10)


    # 示例3：查询书籍名称为红楼梦，价格为90的书籍
    # ret = Book.objects.filter(title="红楼梦",price=90) # 只可以表示且

    # Q的字段不仅可以表示且，也可以表示或
    # ret = Book.objects.filter(Q(title="红楼梦")|Q(price=90))
    # print(ret)  # <QuerySet [<Book: 红楼梦>, <Book: 西游记>, <Book: 三国演义>, <Book: 水浒传>]>

    # 示例4：过滤书名不等于红楼梦的书籍
    ret = Book.objects.filter(~Q(title="红楼梦"))
    print(ret)  # <QuerySet [<Book: 西游记>, <Book: 三国演义>, <Book: 水浒传>]>

    return HttpResponse("OK")

八、关联管理器

http://www.cnblogs.com/liwenzhou/p/8660826.html

http://www.cnblogs.com /yuanchenqi/articles/8978167.html

https://docs.djangoproject.com/en/1.11/ref/models/querysets/

九、补充知识

1. 内容回顾
    1. 常用字段和字段参数
        1. 常用字段
            1. AutoField
                primary_key=True  # 设置为主键
            2. CharField
                max_length=32     # 设置最大长度
            3. IntegerField
            4. BigInterField
            5. TextField
            6. DateField
                auto_now_add      # 创建这条数据时自动添加当前时间
                auto_now          # 每次更新的时候都自动更新时间

            7. DateTimeField
                同上
            ...

            常用参数：
                default=""        # 设置默认值
                null=True         # 可以为空
                unique=True       # 该字段在数据库中不能重复

        2. 关系字段
            1. 外键  ForeignKey
                1. 外键通常放在多（一对多的多）的那一边

                2. 参数
                    1. to=“表名”
                    2. related_name="xx"  用来替换反向查询时的 表名_set
                    3. on_delete=models.CASCADE

            2. 一对一  OneToOneField
                1. 什么时候用  作者和作者详情

            3. 多对多  ManyToManyField
                1. 三种方式
                    1.  不用ManyToMany
                    2.  自带的ManyToMany， 自动帮我创建第三张表
                    3.  自定义第三张表


                        # 相亲网站
                        # 男孩
                        class Boy(models.Model):
                            name = models.CharField(max_length=32)
                            girls = models.ManyToManyField(to='Girl', through="Info", through_fields=("boy1", "girl1"))  # 能满足多对多的关系，但是少点东西


                        # 女孩
                        class Girl(models.Model):
                            name = models.CharField(max_length=32)
                            # through_fields=('field1', 'field2'),
                            # 你把多对多建在那个表，field1就是这个表的名字
                            # field2是你目标表的表名
                            # boys = models.ManyToManyField(to=Boy, through="Info", through_fields=("girl1", "boy1"))  # 能满足多对多的关系，但是少点东西


                        # 约会记录
                        # 男孩1      女孩1
                        # 男孩2      女孩1
                        # 男孩1      女孩2


                        # 自己创建第三张表， 记录约会的记录
                        class Info(models.Model):
                            girl1 = models.ForeignKey(to=Girl)
                            boy1 = models.ForeignKey(to=Boy)

                            # 其他补充字段
                            date = models.DateTimeField(auto_now_add=True)


        3. 元信息
            # 定义元信息
            class Meta:
                ordering = ("price", )  # 默认按照价格排序
                db_table = "book"  # 指定在数据库中创建表的表名
                unique_together = ("title", "price")  # 多字段联合唯一

    2. ORM操作
        1. 单表13个    --> 永远不要怀疑自己！要自信！！！  混乱即阶梯！

            返回QuerySet的有：
                1. all()
                3. filter()
                4. exclude()

                7. values_list()  --> 元祖
                8. values()       --> 字典
                9. order_by()
                10. reverse()
                13. distinct()
            返回对象：
                2. get()
                5. first()
                6. last()
            返回数字：
                11. count()
            返回布尔值：
                12. exist()

            双下划线：
                id__lt=10
                ...

            跨表的双下划线：
                models.Book.objects.filter(author__name=“小仙女")
                models.Book.objects.filter(author__detail__age=18)
                ...

        2. 关系表的操作
            1. 外键
                1. 正向查找         --> 具体的对象
                    直接找
                2. 反向查找         --> 对象的列表
                    .表名(小写)_set.all()
            2. 多对多
                1. 正向查找
                    直接找          --> 对象的列表

                2. 反向查找
                    表名_set.all()  --> 对象的列表

                多对多才有的：
                    .create()    --> author_obj.books.create(title="番茄物语")
                    .add(1,2,3)
                    .clear()     -->清空
                    .remove(1)
                    .set([1,2,3]/QuerySet对象)
        3.聚合和分组
            1. aggregate()
            2. annotate()     ---> GROUP BY
        4. F和Q
            1. 同一张表的不同列作比较
            2. 多个条件做查询

        5. 事务
                try:
                    from django.db import transaction
                    with transaction.atomic():
                        new_publisher = models.Publisher.objects.create(name="新华出版社CCC")
                        # 再去创建新书
                        # new_book = models.Book.objects.create(title="新华字典", price=3.5, publisher_id=new_publisher.id)
                        new_book = models.Book.objects.create(titl="新华字典CCC", price=3.5, publisher=new_publisher)
                except Exception as e:
                    print(str(e))

        6. 如何在Python脚本加载Django环境
            import os
            os.environ.setdefault("DJANGO_SETTINGS_MODULE", "项目名.settings")
            import django
            django.setup()

            # 引用Django内部的变量

事务

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():
            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))

在Python脚本中调用Django环境

import os

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

    from app01 import models

    books = models.Book.objects.all()
    print(books)

orm参数

https://www.cnblogs.com/liwenzhou/p/8688919.html