一 创建模型

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

class AuthorDetail(models.Model):#不常用的放到这个表里面

    nid = models.AutoField(primary_key=True)

    birthday=models.DateField()

    telephone=models.BigIntegerField()

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

#多对多的表关系，我们学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这个参数的时候，最后后面的值是个字符串，不然你就需要将你要关联的那个表放到这个表的上面

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")

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")

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")

二 添加表记录

方式1:

   publish_obj=Publish.objects.get(nid=1) #拿到nid为1的出版社对象

   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish=publish_obj) #出版社对象作为值给publish，其实就是自动将publish字段变成publish_id,然后将publish_obj的id给取出来赋值给publish_id字段，注意你如果不是publish类的对象肯定会报错的，别乱昂

方式2:

   book_obj=Book.objects.create(title="金瓶眉",publishDate="2012-12-12",price=100,publish_id=1)　　#直接可以写id值，注意字段属性的写法和上面不同，这个是publish_id=xxx，上面是publish=xxx。

   方式一： 多对多一般在前端页面上使用的时候是多选下拉框的样子来给用户选择多个数据，这里可以让用户选择多个书籍，多个作者
　　# 当前生成的书籍对象

    book_obj=Book.objects.create(title="追风筝的人",price=200,publishDate="2012-11-12",publish_id=1)

    # 为书籍绑定的做作者对象

    yuan=Author.objects.filter(name="yuan").first() # 在Author表中主键为2的纪录，注意取的是author的model对象

    egon=Author.objects.filter(name="alex").first() # 在Author表中主键为1的纪录

　　#有人可能会说，我们可以直接给第三张表添加数据啊，这个自动生成的第三张表你能通过models获取到吗，是获取不到的，用不了的，当然如果你知道了这个表的名字，那么你通过原生sql语句可以进行书的添加，所以要通过orm间接的给第三张表添加数据，如果是你手动添加的第三张表你是可以直接给第三张表添加数据

    # 绑定多对多关系,即向关系表book_authors中添加纪录，给书添加两个作者，下面的语法就是告诉orm给第三张表添加两条数据

    book_obj.authors.add(yuan,egon)    #  将某些特定的 model 对象添加到被关联对象集合中。   =======    book_obj.authors.add(*[])
    #book_obj是书籍对象，authors是book表里面那个多对多的关系字段名称。
    #其实orm就是先通过book_obj的authors属性找到第三张表，然后将book_obj的id值和两个作者对象的id值组合成两条记录添加到第三张表里面去
　　方式二

　　　　book_obj.authors.add(1，2)

　　　　book_obj.authors.add(*[1，2]) #这种方式用的最多，因为一般是给用户来选择，用户选择是多选的，选完给你发送过来的就是一堆的id值

book_obj.authors.remove()      # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[1，2])，将多对多的关系数据删除

book_obj.authors.clear()       #清空被关联对象集合

book_obj.authors.set()         #先清空再设置　　 ===== 

   book_obj = models.Book.objects.filter(nid=4)[0]

    # book_obj.authors.remove(2) #将第三张表中的这个book_obj对象对应的那个作者id为2的那条记录删除

    # book_obj.authors.clear()

    # book_obj.authors.set('2') #先清除掉所有的关系数据，然后只给这个书对象绑定这个id为2的作者，所以只剩下一条记录  3---2，比如用户编辑数据的时候，选择作者发生了变化，那么需要重新选择，所以我们就可以先清空，然后再重新绑定关系数据,注意这里写的是字符串，数字类型不可以

    book_obj.authors.set(['1',]) #这么写也可以，但是注意列表中的元素是字符串，列表前面没有*，之前我测试有*，感觉是版本的问题，没事，能够用哪个用哪个

更新：

book_obj = models.Book.objects.get(id=1) #获取一个书籍对象

data = {'title':'xxx','price':100} #这个书籍对象更新后的数据

models.Book.objects.filter(id=n).update(**data) #将新数据更新到原来的记录中

book_obj.authors.set(author_list) #将数据和作者的多对多关系加上

删除：

models.Book.objects.filter(id=1).delete()

三 基于对象的跨表查询

# 查询主键为1的书籍的出版社所在的城市

book_obj=Book.objects.filter(pk=1).first()

# book_obj.publish 是主键为1的书籍对象关联的出版社对象，book对象.外键字段名称

print(book_obj.publish.city) 　

publish=Publish.objects.get(name="苹果出版社")

#publish.book_set.all() : 与苹果出版社关联的所有书籍对象集合，写法：小写的表名_set.all()，得到queryset类型数据

book_list=publish.book_set.all()

for book_obj in book_list:

       print(book_obj.title)

egon=Author.objects.filter(name="egon").first()

print(egon.authorDetail.telephone) egon.authorDeail就拿到了这个对象，因为一对一找到的就是一条记录，注意写法：作者对象.字段名,就拿到了那个关联对象

# 查询所有住址在北京的作者的姓名

authorDet=AuthorDetail.objects.filter(addr="beijing")[0]

authorDet.author.name

四 基于双下划线的跨表查询（基于join实现的）

'''

    基于双下划线的查询就一句话：正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表,一对一、一对多、多对多都是一个写法，注意，我们写orm查询的时候，哪个表在前哪个表在后都没问题，因为走的是join连表操作。

'''

# 练习:  查询苹果出版社出版过的所有书籍的名字与价格(一对多) 

    # 正向查询 按字段: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")

    # 查询yuan的手机号

    # 正向查询

    ret=Author.objects.filter(name="yuan").values("authordetail__telephone")

    # 反向查询

    ret=AuthorDetail.objects.filter(author__name="yuan").values("telephone")

# 练习: 查询人民出版社出版过的所有书籍的名字以及作者的姓名

    # 正向查询

    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")

# 练习: 查询人民出版社出版过的所有书籍的名字与价格(一对多)

# 反向查询 不再按表名:book,而是related_name:bookList

    queryResult=Publish.objects

　　　　　　　　　　　　　　.filter(name="人民出版社")

　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price") 

五 聚合查询、分组查询、F查询和Q查询

###################################－－单表分组查询－－#######################################################

查询每一个部门名称以及对应的员工数

emp:

id  name age   salary    dep

1   alex  12   2000     销售部

2   egon  22   3000     人事部

3   wen   22   5000     人事部

sql语句:

select dep,Count(*) from emp group by dep;

ORM:

emp.objects.values("dep").annotate(c=Count("id") #注意：annotate里面必须写个聚合函数，不然没有意义，并且必须有个别名=，别名随便写，但是必须有，用哪个字段分组，values里面就写哪个字段,annotate其实就是对分组结果的统计，统计你需要什么。
'''
　　select dep,count('id') as c from emp grouby dep;  #原生sql语句中的as c，不是必须有的
'''

###################################－－多表分组查询－－###########################

多表分组查询：

查询每一个部门名称以及对应的员工数

emp:

id  name age   salary   dep_id

1   alex  12   2000       1

2   egon  22   3000       2

3   wen   22   5000       2

dep

id   name

1    销售部

2    人事部

emp－dep:

id  name age   salary   dep_id   id   name

1   alex  12   2000       1      1    销售部

2   egon  22   3000       2      2    人事部

3   wen   22   5000       2      2    人事部

sql语句:

select dep.name,Count(*) from emp left join dep on emp.dep_id=dep.id group by dep.id

ORM:

dep.objetcs.values("id").annotate(c=Count("emp")).values("name","c")

ret = models.Emp.objects.values('dep_id','name').annotate(a=Count(1)) 
'''
  SELECT `app01_emp`.`dep_id`, `app01_emp`.`name`, COUNT(1) AS `a` FROM `app01_emp` GROUP BY `app01_emp`.`dep_id`, `app01_emp`.`name`
'''
#<QuerySet [{'dep_id': 1, 'name': 'alex', 'a': 1}, {'dep_id': 2, 'name': 'egon', 'a': 1}, {'dep_id': 2, 'name': 'wen', 'a': 1}]>,注意，这里如果你写了其他字段，那么只有这两个字段重复，才算一组，合并到一起来统计个数

#单表：

    #查询每一个部门的id以及对应员工的平均薪水

    ret = models.Emp.objects.values('dep_id').annotate(s=Avg('salary'))

    #查询每个部门的id以及对对应的员工的最大年龄

    ret = models.Emp.objects.values('dep_id').annotate(a=Max('age'))

    #Emp表示表，values中的字段表示按照哪个字段group by，annotate里面是显示分组统计的是什么

#连表：

    # 查询每个部门的名称以及对应的员工个数和员工最大年龄

    ret = models.Emp.objects.values('dep__name').annotate(a=Count('id'),b=Max('age')) #注意，正向与反向的结果可能不同，如果反向查的时候，有的部门还没有员工，那么他的数据也会被统计出来，只不过值为0，但是正向查的话只能统计出来有员工的部门的相关数据，因为通过你是员工找部门，而不是通过部门找员工，结果集里面的数据个数不同，但是你想要的统计结果是一样的

    #<QuerySet [{'a': 1, 'dep__name': '销售部', 'b': 12}, {'a': 3, 'dep__name': '人事部', 'b': 22}]>

    #使用双下划线进行连表，然后按照部门名称进行分组，然后统计员工个数和最大年龄，最后结果里面显示的是部门名称、个数、最大年龄。

#注意：如果values里面有多个字段的情况：
ret = models.Emp.objects.values('dep__name','age').annotate(a=Count('id'),b=Max('age')) #是按照values里面的两个字段进行分组，两个字段同时相同才算是一组，看下面的sql语句
''' 
    SELECT `app01_dep`.`name`, `app01_emp`.`age`, COUNT(`app01_emp`.`id`) AS `a`, MAX(`app01_emp`.`age`) AS `b` FROM `app01_emp` INNER JOIN `app01_dep` ON (`app01_emp`.`dep_id` = `app01_dep`.`id`) GROUP BY `app01_dep`.`name`, `app01_emp`.`age`;
'''

queryResult= Publish.objects

　　　　　　　　　　　　.annotate(MinPrice=Min("book__price"))

　　　　　　　　　　　　.values_list("name","MinPrice")

print(queryResult)

ret=Book.objects.annotate(authorsNum=Count('authors__name'))

ret=models.Book.objects.annotate(authorsNum=Count('authors__name')).values('title','authorsNum') #注意写法，values里面写的个数的别名
ret=models.Book.objects.annotate(a=Count('author__name')).filter(a__gt=2).values('title','a') #还有这种写法，看看你能不能明白这是在做什么

 queryResult=Book.objects

　　　　　　　　　　 .filter(title__startswith="Py")

　　　　　　　　　 　.annotate(num_authors=Count('authors')) #连接第三张表再连接author表，where title regexp '^Py' 然后按照连表后的大表中的book表的title字段进行分组，并且统计对应作者的个数

queryResult=Book.objects

　　　　　　　　　　.annotate(num_authors=Count('authors'))

　　　　　　　　　　.filter(num_authors__gt=1) #filter也是也可以是querset来调用

#   按author表的所有字段 group by

    queryResult=Author.objects
　　　　　　　　　　　　　　.annotate(SumPrice=Sum("book__price"))
　　　　　　　　　　　　　　.values_list("name","SumPrice")

    print(queryResult)

#1 查询每个作者的姓名以及出版的书的最高价格

    ret = models.Author.objects.values('name').annotate(max_price=Max('book__price'))

    print(ret) #注意：values写在annotate前面是作为分组依据用的，并且返回给你的值就是这个values里面的字段（name）和分组统计的结果字段数据(max_price)

    # ret = models.Author.objects.annotate(max_price=Max('book__price')).values('name','max_price')#这种写法是按照Author表的id字段进行分组，返回给你的是这个表的所有model对象，这个对象里面包含着max_price这个属性，后面写values方法是获取的这些对象的属性的值，当然，可以加双下划线来连表获取其他关联表的数据，但是获取的其他关联表数据是你的这些model对象对应的数据，而关联获取的数据可能不是你想要的最大值对应的那些数据

# 2 查询作者id大于2作者的姓名以及出版的书的最高价格

    ret = models.Author.objects.filter(id__gt=2).annotate(max_price=Max('book__price')).values('name','max_price')#记着，这个values取得是前面调用这个方法的表的所有字段值以及max_pirce的值，这也是为什么我们取关联数据的时候要加双划线的原因

    print(ret)

#3 查询作者id大于2或者作者年龄大于等于20岁的女作者的姓名以及出版的书的最高价格

    # ret = models.Author.objects.filter(Q(id__gt=2)|Q(age__gte=20),sex='female').annotate(max_price=Max('book__price')).values('name','max_price')

#4 查询每个作者出版的书的最高价格 的平均值

    # ret = models.Author.objects.values('id').annotate(max_price=Max('book__price')).aggregate(Avg('max_price')) #{'max_price__avg': 555.0} 注意，aggregate是queryset的终止句，得到的是字典

    # ret = models.Author.objects.annotate(max_price=Max('book__price')).aggregate(Avg('max_price')) #{'max_price__avg': 555.0} 注意，aggregate是queryset的终止句，得到的是字典

#5 每个作者出版的所有书的价格以及最高价格的那本书的名称（通过orm玩起来就是个死题，需要用原生sql）

    '''

    select title,price from (select app01_author.id,app01_book.title,app01_book.price from app01_author INNER JOIN app01_book_authors on app01_author.id=

app01_book_authors.author_id INNER JOIN app01_book on app01_book.id=

app01_book_authors.book_id ORDER BY app01_book.price desc) as b  GROUP BY id

'''

    print(ret)

六 ORM执行原生sql语句(了解)

class Person(models.Model):

    first_name = models.CharField(...)

    last_name = models.CharField(...)

    birth_date = models.DateField(...)

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

...     print(p)

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')

    for i in ret:

        print(i.id, i.hehe)

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)

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)

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

七 Python脚本中调用Django环境(django外部脚本使用models)

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)

八 xxx