　　　　多表的一对多创建

　　　多表的多对多创建

　　　多表的一对多修改

　　　多表的多对多修改

前情提要:

　　最近认识了不少大佬,大佬开着保时捷. .一顿狂奔..我连车尾灯都看不到..

　　本次内容 ORM 的多表链接查询 , html的模板继承

　　　2、添加表记录

　　　　　　方式一：

　　　　　　　　通过类实例化对象的方式。注意：一定要对象.save()

1 2	`book` `=` `models.Book(title="吸星大法", price=200, publisher="明教出版社", pub_date="2018-12-12")` `book.save()`

　　　　　　方式二：

　　　　　　　　通过ORM提供的objects提供的方法 create来实现。

1	`book` `=` `models.Book.objects.create(title="独孤九剑", price=150, publisher="华山出版社", pub_date="2019-1-12")`

　　　　3、查询表记录

　　　　　　1、查询API

<1> all():                  查询所有结果

<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象

<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，

                            如果符合筛选条件的对象超过一个或者没有都会抛出错误。

<4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象

<5> order_by(*field):       对查询结果排序

<6> reverse():              对查询结果反向排序

<7> count():                返回数据库中匹配查询(QuerySet)的对象数量。

<8> first():                返回第一条记录

<9> last():                返回最后一条记录

<10> exists():              如果QuerySet包含数据，就返回True，否则返回False

<11> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列

                            model的实例化对象，而是一个可迭代的字典序列

<12> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

<13> distinct():            从返回结果中剔除重复纪录

　　　　　　2、基于双下划线的模糊查询

Book.objects.filter(price__in=[100,200,300])

Book.objects.filter(price__gt=100)

Book.objects.filter(price__lt=100)

Book.objects.filter(price__range=[100,200])

Book.objects.filter(title__contains="法")

Book.objects.filter(title__icontains="python") # 不区分大小写

Book.objects.filter(title__startswith="九")

Book.objects.filter(pub_date__year=2018)

　　　　4、删除表记录

　　　　　　删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：

1	`model_obj.delete()`

　　　　　　你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中所有的对象。

　　　　　　例如，下面的代码将删除 pub_date 是2018年的 Book 对象：

1	`Book.objects.filter(pub_date__year=2018).delete()`

　　　　　　在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：

b = Book.objects.get(pk=1)

# This will delete the Blog and all of its Entry objects.

b.delete()

要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致所有的记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：

1	`Book.objects.all().delete()`

　　　　5、修改表记录

　　　　　　方式一：

　　　　　　　　通过修改实例对象的属性方式。注意：一定要对象.save()

book = models.Book.objects.get(title="吸星大法")

book.price = 180

book.save()

　　　　　　方式二：

　　　　　　　　通过ORM提供的objects提供的方法 update来实现。

1	`models.Book.objects.filter(title="吸星大法").update(price=190)`

　　　　　　　　此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。

一: html 模板继承

　　　　　　　 模板继承主要使用在几个界面大体类似只是地方做修改的时候的操作

　　　　　　　　1:首先先建立一个公共模板

 <!DOCTYPE html>

 <html lang="en">

 <head>

     <meta charset="UTF-8">

     <title>Title</title>

     <link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7-dist/bootstrap/css/bootstrap.css">

     <link rel="stylesheet" href="/static/css/dsb.css">

     {% block css %}

     {% endblock css %}

 </head>

 <body>

     <nav class="navbar navbar-inverse navbar-fixed-top">

       <div class="container-fluid">

         <div class="navbar-header">

           <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">

             <span class="sr-only">Toggle navigation</span>

             <span class="icon-bar"></span>

             <span class="icon-bar"></span>

             <span class="icon-bar"></span>

           </button>

           <a class="navbar-brand" href="#">图书管理系统</a>

         </div>

         <div id="navbar" class="navbar-collapse collapse">

           <ul class="nav navbar-nav navbar-right">

             <li><a href="#">Dashboard</a></li>

             <li><a href="#">Settings</a></li>

             <li><a href="#">Profile</a></li>

             <li><a href="#">Help</a></li>

           </ul>

           <form class="navbar-form navbar-right">

             <input type="text" class="form-control" placeholder="Search...">

           </form>

         </div>

       </div>

     </nav>

     <div class="container-fluid">

       <div class="row">

         <div class="col-sm-3 col-md-2 sidebar">

           <ul class="nav nav-sidebar">

             <li class="active"><a href="{% url 'book_list' %}">书籍列表 <span class="sr-only">(current)</span></a></li>

             <li><a href="#">Reports</a></li>

             <li><a href="#">Analytics</a></li>

             <li><a href="#">Export</a></li>

           </ul>

         </div>

         <div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2 main">

           <div class="panel panel-primary">

       <div class="panel-heading">

         {% block title %}

         {% endblock title %}

       </div>

       <div class="panel-body">

           {% block content %}

                 <a class="btn btn-primary" href="{% url 'add_book' %}">新增书籍</a>

           {% endblock content %}

       </div>

     </div>

         </div>

       </div>

     </div>

 </body>

 {% block js %}

 {% endblock js %}

 </html>

css 模板继承

html 继承

　js 继承:

前面是在模板层定义大体框架,之后设计具体的内容

{% extends 'layout.html' %}

{% block title %}

<h3 class="panel-title">书籍列表</h3>

{% endblock title %}

{% block content %}

    {{ block.super }}

<table class="table table-hover">

            <thead>

        <tr>

            <th>序号</th>

            <th>id</th>

            <th>书名</th>

            <th>价格</th>

            <th>出版社</th>

            <th>出版日期</th>

            <th>操作</th>

        </tr>

    </thead>

    <tbody>

        {% for book in all_book %}

        <tr>

            <td>{{ forloop.counter }}</td>

            <td>{{ book.pk }}</td>

            <td>{{ book.title }}</td>

            <td>{{ book.price }}</td>

            <td>{{ book.publish }}</td>

            <td>{{ book.pub_date|date:"Y-m-d" }}</td>

            <td>

                <a class="btn btn-info btn-sm" href="{% url 'edit_book' book_id=book.nid %}">编辑</a>

                |

                <a class="btn btn-danger btn-sm" href="{% url 'del_book' book.nid %}">删除</a>

            </td>

        </tr>

        {% endfor %}

    </tbody>

        </table>

{% endblock content %}

　　　　　　二: ORM 多表链接

　　　　1:创建模型

　　　　　　>1: 创建图书管理系统的模型

　　　　1.1分析:

由上可知 :　　

　　模型创建以后有5个表

　　　　其中 book 中的 book_id 与 book_author 是一对多的关系 ,即一本书可能会有好几个作者

　　　　publish 表中的id 与book 表中的publish 是一对多的关系 ,即一个出版社可能会有好几个书

　　　　author表与book_author 是一对多的关系 ,即一个作者可能会有好几个书,

　　　　所以book_author 是多对多关系. 是第第三方表.

通过上面分析.: Django 中可以创建4个模型. 即可实现5个表的关系

　　book 模型

from django.db import models

# Create your models here.

class Book(models.Model):

    title = models.CharField(max_length=32)

    price = models.DecimalField(max_digits=5, decimal_places=2)

    pub_date = models.DateField

    publish = models.ForeignKey("Publish", on_delete=models.CASCADE)  # 一对多

    authors = models.ManyToManyField("Author")  # 多对多

　　　　publish 模型

class Publish(models.Model):

    name = models.CharField(max_length=32)

    city = models.CharField(max_length=64)

    email = models.EmailField()

　　author 模型

class Author(models.Model):

    name = models.CharField(max_length=32)

    age = models.IntegerField()

    au_detail = models.OneToOneField("AuthorDeail", on_delete=models.CASCADE)  # 一对一

　　AuthorDeail 模型

class AuthorDeail(models.Model):

    tel = models.CharField(max_length=32)

    addr = models.CharField(max_length=255)

    birthday =models.DateField()

创建一对多关系时对应的id Django 会自动帮填写id

整理 : 首先是普通方法

　　　　正向:调用字段名 ,反向: 调用小写的表明

　　　　1:一对多

　　　　正向: (在model 内写关系的为正向)

代码:

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

    # print(book_obj.publish.city)

　　反向:

# pub_obj =models.Publish.objects.filter(id=2).first()

    # print(pub_obj.book_set.all(),type(pub_obj.book_set.all()))

    # for i in pub_obj.book_set.all():

    #     print(i.title)

　　2:多对多

　　正向:

    # book_obj =models.Book.objects.filter(id=2).first()

    # for i in book_obj.authors.all():

    #     print(i.name,i.au_detail.tel)

　　反向:

  # au_obj =models.Author.objects.filter(id=3).first()

    # for j in au_obj.book_set.all():

    #     print(j.title)

3:一对一

一对一没有正反向, 两端一样

   # 一对一查询

    # au_obj = models.Author.objects.filter(id=3).first()

    # print(au_obj.au_detail.tel)

    # au_addr = models.AuthorDetail.objects.filter(id=2).first()

    # print(au_addr.author.name)

双下方法的使用

　　正向: 直接调用他对应的内容的字段

　　反向: 反向找到其父级,调用其对应内容的字段

关联管理器(RelatedManager)

一、class RelatedManager

　　"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。它存在于下面两种情况：

　　1、一对多

　　　　ForeignKey关系的“另一边”。像这样：

from django.db import models

class Publish(models.Model):

pass

class Book(models.Model):

publish = models.ForeignKey("Publish", on_delete=models.CASCADE)

　　　　在上面的例子中，管理器publish_obj.book_set 会拥有下面介绍的方法。

　　2、多对多

　　　　ManyToManyField关系的两边：

class Author(models.Model):

pass

class Book(models.Model):

authors = models.ManyToManyField("Author")

　　　　在这个例子中，book_obj.authors 和author_obj.book_set 都拥有下面的方法。

　　3、方法合集

　　　　1、add(obj1[, obj2, ...])

把指定的模型对象添加到关联对象集中。

例如：

>>> author_obj = Author.objects.get(id=1)

>>> book_obj = Book.objects.get(id=2)

>>> author_obj .book_set.add(e)

在上面的例子中，对于ForeignKey关系，book_obj.save()由关联管理器调用，执行更新操作。然而，在多对多关系中使用add()并不会调用任何 save()方法，而是由QuerySet.bulk_create()创建关系。

延伸：

# 1 *[]的使用

>>> book_obj = Book.objects.get(id=1)

>>> author_list = Author.objects.filter(id__gt=2)

>>> book_obj.authors.add(*author_list)

# 2 直接绑定主键

book_obj.authors.add(*[1,3])  # 将id=1和id=3的作者对象添加到这本书的作者集合中

                              # 应用: 添加或者编辑时,提交作者信息时可以用到.

　　　　2、create(**kwargs)

创建一个新的对象，保存对象，并将它添加到关联对象集之中。返回新创建的对象：

>>> author_obj = Author.objects.get(id=1)

>>> book = author_obj.book_set.create(

    ...

    title='挤奶龙爪手',

    ...

)

# No need to call e.save() at this point -- it's already been saved.

这完全等价于（不过更加简洁于）：

>>> author_obj = Author.objects.get(id=1)

>>> book = Book(

    ...

    title='挤奶龙爪手',

    ...

)

>>> author_obj.save(force_insert=True)

要注意我们并不需要指定模型中用于定义关系的关键词参数。在上面的例子中，我们并没有传入author_obj参数给create()。Django会明白新的 Book对象author_obj 应该添加到author_obj中。

　　　　3、remove(obj1[, obj2, ...])

从关联对象集中移除执行的模型对象：

>>> author_obj = Author.objects.get(id=1)

>>> book_obj = Book.objects.get(id=2)

>>> author_obj .book_set.remove(book_obj)

对于ForeignKey对象，这个方法仅在null=True时存在。

　　　　4、clear()

从关联对象集中移除一切对象。

>>> author_obj = Author.objects.get(id=1)

>>> author_obj.book_set.clear()

注意这样不会删除对象 —— 只会删除他们之间的关联。

就像 remove() 方法一样，clear()只能在 null=True的ForeignKey上被调用。

　　　　5、set()方法

　　　　先清空，在设置，编辑书籍时即可用到。

book = models.Book.objects.filter(title="独孤九剑").first()

book.authors.set([1, 3])

注意：

对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。

二、操作表记录

　　1、添加一些简单的数据

　　　　1、publish表：

　　　　2、author表：

　　　　3、authordatail表：

　　2、一对多

# 方式一 传对象的形式

pub_obj = models.Publish.objects.get(pk=1)

book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish=pub_obj)

# 方式二 传对象id的形式

book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish_id=1)

　　　　核心：明白book.publish 和 book.publish_id 的区别？

　　3、多对多

# 方式一 传对象的形式

book = models.Book.objects.filter(title="独孤九剑").first()

ling = models.Author.objects.filter(name="令狐冲").first()

ying = models.Author.objects.filter(name="任盈盈").first()

book.authors.add(ling, ying)

# 方式二 传对象id的形式

book = models.Book.objects.filter(title="独孤九剑").first()

ling = models.Author.objects.filter(name='令狐冲').first()

ying = models.Author.objects.filter(name='任盈盈').first()

book.authors.add(ling.pk, ying.pk)

　　　　核心：book.authors.all()是什么？

　　　　多对多其他常用API：

book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])

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

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

　　　　1、一对多查询（Publish 与 Book）

　　　　正向查询（按字段 publish）

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

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

# book_obj.publish 是主键为1的书籍对象关联的出版社对象

print(book_obj.publish.city)

　　　　反向查询（按book表）

# 查询明教出版社出版的书籍名

publish=Publish.objects.get(name="明教出版社")

#publish.book_set.all() : 与明教出版社关联的所有书籍对象集合

book_list=publish.book_set.all()

for book_obj in book_list:

print(book_obj.title)

　　　　2、一对一查询（Author 和 AuthorDetail）

　　　　正向查询（按字段：au_detail）：

1 2	`# 查询令狐冲的电话<br>ling=Author.objects.filter(name="令狐冲").first()` `print(ling.au_detail.tel)`

　　　　反向查询（按表名：author）：

# 查询所有住址在黑木崖的作者的姓名

authorDetail_list=AuthorDetail.objects.filter(addr="黑木崖")

for obj in authorDetail_list:

print(obj.author.name)

　　　　3、多对多查询 (Author 与 Book)

　　　　正向查询(按字段：authors)：

# 独孤九剑所有作者的名字以及手机号

book_obj = Book.objects.filter(title="独孤九剑").first()

authors = book_obj.authors.all()

for author_obj in authors:

print(author_obj.name, author_obj.au_detail.tel)

　　　　反向查询(按表名：book_set)：

# 查询令狐冲出过的所有书籍的名字

author_obj=Author.objects.get(name="令狐冲")

book_list=author_obj.book_set.all() #与令狐冲作者相关的所有书籍

for book_obj in book_list:

print(book_obj.title)

　　　　注意：

　　　　　　你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Book model 中做一下更改：

1	`publish` `=` `models.ForeignKey("Publish", on_delete=models.CASCADE, related_name="book_list")`

　　　　那么接下来就会如我们看到这般：

# 查询明教出版社出版过的所有书籍

publish=Publish.objects.get(name="明教出版社")

book_list=publish.book_list.all() # 与明教出版社关联的所有书籍对象集合

　　3、基于双下划线的跨表查询

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

'''

    正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表

'''

　　　　1、一对多查询

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

    # 正向查询 按字段:publish

    queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__price")

　　　　2、多对多查询　

# 练习: 查询令狐冲出过的所有书籍的名字(多对多)

    # 正向查询 按字段:authors:

    queryResult=Book.objects.filter(authors__name="令狐冲").values_list("title")

    # 反向查询 按表名:book

    queryResult=Author.objects.filter(name="令狐冲").values_list("book__title","book__price")

　　　　3、一对一查询

# 查询令狐冲的手机号

    # 正向查询

    ret=Author.objects.filter(name="令狐冲").values("au_detail__tel") 

　　# 反向查询 
　　ret=AuthorDetail.objects.filter(author__name="令狐冲").values("tel")

　　　　4、进阶练习(连续跨表)

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

    # 正向查询

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

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

    # 方式1:

    queryResult=Book.objects.filter(authors__au_detail__tel__startswith="132").values_list("title","publish__name") 

　　 # 方式2:  
　　 ret=Author.objects.filter(au_detail__tel__startswith="132").values("book__title","book__publish__name")

二、操作表记录

　　1、添加一些简单的数据

　　　　1、publish表：

　　　　2、author表：

　　　　3、authordatail表：

　　2、一对多

# 方式一 传对象的形式

pub_obj = models.Publish.objects.get(pk=1)

book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish=pub_obj)

# 方式二 传对象id的形式

book = models.Book.objects.create(title="独孤九剑", price=180, pub_date="2018-10-23", publish_id=1)

　　　　核心：明白book.publish 和 book.publish_id 的区别？

　　3、多对多

# 方式一 传对象的形式

book = models.Book.objects.filter(title="独孤九剑").first()

ling = models.Author.objects.filter(name="令狐冲").first()

ying = models.Author.objects.filter(name="任盈盈").first()

book.authors.add(ling, ying)

# 方式二 传对象id的形式

book = models.Book.objects.filter(title="独孤九剑").first()

ling = models.Author.objects.filter(name='令狐冲').first()

ying = models.Author.objects.filter(name='任盈盈').first()

book.authors.add(ling.pk, ying.pk)

　　　　核心：book.authors.all()是什么？

　　　　多对多其他常用API：

book_obj.authors.remove() # 将某个特定的对象从被关联对象集合中去除。 ====== book_obj.authors.remove(*[])

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

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

　　　　1、一对多查询（Publish 与 Book）

　　　　正向查询（按字段 publish）

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

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

# book_obj.publish 是主键为1的书籍对象关联的出版社对象

print(book_obj.publish.city)

　　　　反向查询（按book表）

# 查询明教出版社出版的书籍名

publish=Publish.objects.get(name="明教出版社")

#publish.book_set.all() : 与明教出版社关联的所有书籍对象集合

book_list=publish.book_set.all()

for book_obj in book_list:

print(book_obj.title)

　　　　2、一对一查询（Author 和 AuthorDetail）

　　　　正向查询（按字段：au_detail）：

1 2	`# 查询令狐冲的电话<br>ling=Author.objects.filter(name="令狐冲").first()` `print(ling.au_detail.tel)`

　　　　反向查询（按表名：author）：

# 查询所有住址在黑木崖的作者的姓名

authorDetail_list=AuthorDetail.objects.filter(addr="黑木崖")

for obj in authorDetail_list:

print(obj.author.name)

　　　　3、多对多查询 (Author 与 Book)

　　　　正向查询(按字段：authors)：

# 独孤九剑所有作者的名字以及手机号

book_obj = Book.objects.filter(title="独孤九剑").first()

authors = book_obj.authors.all()

for author_obj in authors:

print(author_obj.name, author_obj.au_detail.tel)

　　　　反向查询(按表名：book_set)：

# 查询令狐冲出过的所有书籍的名字

author_obj=Author.objects.get(name="令狐冲")

book_list=author_obj.book_set.all() #与令狐冲作者相关的所有书籍

for book_obj in book_list:

print(book_obj.title)

　　　　注意：

　　　　　　你可以通过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，如果 Book model 中做一下更改：

1	`publish` `=` `models.ForeignKey("Publish", on_delete=models.CASCADE, related_name="book_list")`

　　　　那么接下来就会如我们看到这般：

# 查询明教出版社出版过的所有书籍

publish=Publish.objects.get(name="明教出版社")

book_list=publish.book_list.all() # 与明教出版社关联的所有书籍对象集合

　　3、基于双下划线的跨表查询

'''

    正向查询按字段,反向查询按表名小写用来告诉ORM引擎join哪张表

'''

　　　　1、一对多查询

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

    # 正向查询 按字段:publish

    queryResult=Book.objects.filter(publish__name="明教出版社").values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects.filter(name="明教出版社").values_list("book__title","book__price")

　　　　2、多对多查询　

# 练习: 查询令狐冲出过的所有书籍的名字(多对多)

    # 正向查询 按字段:authors:

    queryResult=Book.objects.filter(authors__name="令狐冲").values_list("title")

    # 反向查询 按表名:book

    queryResult=Author.objects.filter(name="令狐冲").values_list("book__title","book__price")

　　　　3、一对一查询

# 查询令狐冲的手机号

    # 正向查询

    ret=Author.objects.filter(name="令狐冲").values("au_detail__tel") 

　　# 反向查询 
　　ret=AuthorDetail.objects.filter(author__name="令狐冲").values("tel")

　　　　4、进阶练习(连续跨表)

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

    # 正向查询

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

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

    # 方式1:

    queryResult=Book.objects.filter(authors__au_detail__tel__startswith="132").values_list("title","publish__name") 

　　 # 方式2:  
　　 ret=Author.objects.filter(au_detail__tel__startswith="132").values("book__title","book__publish__name")

# book_obj =models.Book.objects.filter(id=2).first()
# for i in book_obj.authors.all():
#     print(i.name,i.au_detail.tel)

  '''1、查询丐帮出版社出版的所有书名和作者名称；

    2、查询独孤九剑的作者名称和出版社名称；

    3、查询吸星大法的作者的姓名、电话和地址；

    4、查询令狐冲写的书籍，在哪些出版社出版过，获取其出版社名称和地址；

    5、查询出版社地址为黑木崖，在该出版社出版过书籍的作者姓名和邮箱；

   '''

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

    # 1方式1 正向 双下

    # books1 =models.Book.objects.filter(publish__id=2).values("title","authors__name")

    # print(books1)

    # print(">>>>>>>>>>>>>>>>>")

    # # 1方式2 反向 双下

    # books2 =models.Publish.objects.filter(id=2).values("book__title","book__authors__name")

    # print(books2)

    # # 1 方式3 反向

    # pub1 =models.Publish.objects.filter(id=2).first()

    # for i in pub1.book_set.all():

    #     for j in i.authors.all():

    #

    #         print(i.title,j.name)

    # 2 方法1

    # books1 =models.Book.objects.filter(id=2).values("authors__name","publish__name")

    # print(books1)

    # #2 方法2

    # books2 =models.Author.objects.filter(book__id=2).values("name","book__publish__name")

    # print(books2)

    # #2 方法3

    # books3 =models.Book.objects.filter(id=2)

    # for i in books3:

    #     name,pub=i.authors.all(),i.publish.name

    #     for j in name:

    #         print(j.name,i.publish)

    # 3、查询吸星大法的作者的姓名、电话和地址；

    # 3 方法1:

    # books1=models.Book.objects.filter(id=3).values("authors__name","authors__au_detail__tel","authors__au_detail__addr")

    #

    # print(books1)

    # #3 方法2:

    # books2 =models.Author.objects.filter(book__id=3).values("name","au_detail__tel","au_detail__addr")

    # print(books2)

    # # 3 方法3:

    # books3 =models.Book.objects.filter(id=3).first().authors.all()

    # for i in books3:

    #     print(i.name,i.au_detail.tel,i.au_detail.addr)

    # 4、查询令狐冲写的书籍，在哪些出版社出版过，获取其出版社名称和地址；

    # 4 方法1:

    # books1 =models.Author.objects.filter(id=3).values("book__title","book__publish__name","book__publish__city")

    # print(books1)

    # # 4 方法2:

    # books2 =models.Book.objects.filter(authors__id=3).values("title","publish__name","publish__city")

    # print(books2)

    # #4 方法3 :

    # books3 =models.Author.objects.filter(id=3).first()

    # for i in books3.book_set.all():

    #     print(i.title,i.publish.name,i.publish.city)

    #

    # 5     5、查询出版社地址为黑木崖，在该出版社出版过书籍的作者姓名和邮箱；

    # 5 方法1 :

    books1 =models.Publish.objects.filter(id=2).values("book__title","book__authors__name","book__authors__au_detail__addr")

    print(books1)

    # 5 方法2:

    books2 =models.Book.objects.filter(publish_id=2).values("title","authors__name","authors__au_detail__addr")

    print(books2)

    # 5 方法3:

    books3 =models.Publish.objects.filter(id=2).first()

    for i in books3.book_set.all():

        for j in i.authors.all():

            print(i.title,j.name)

day 48 ORM 进阶多表连接创建以及 html模板继承的更多相关文章

Django之ORM多表关系创建
ORM模型多表逻辑创建: 以图书和作者关系模型为例: models.py from django.db import models ''' 一本书只能被一个出版社出版; 一个出版社可以出版多本书; 一 ...
Django项目的ORM操作之--数据模型类创建
在django项目中,其自带了ORM(Object Relation Mapping)对象关系映射框架,我们在django项目下app的models模块下对类进行操作,通过ORM会将我们对类的操作转化 ...
4.mysql数据库创建，表中创建模具模板脚本，mysql_SQL99标准连接查询（恩，外部连接，全外连接,交叉连接）
mysql数据库创建,表创建模等模板脚本 -- 用root用户登录系统,运行脚本 -- 创建数据库 create database mydb61 character set utf8 ; -- ...
Python进阶----数据库引擎(InnoDB),表的创建,mysql的数据类型,mysql表的约束
Python进阶----数据库引擎(InnoDB),表的创建,mysql的数据类型,mysql表的约束一丶MySQL的存储引擎什么是存储引擎: MySQL中的数据用各种不同的技术存储在文件( ...
MySQL进阶11--DDL数据库定义语言--库创建/修改/删除--表的创建/修改/删除/复制
/*进阶 11 DDL 数据库定义语言库和表的管理一:库的管理:创建/修改/删除二:表的管理:创建/修改/删除创建: CREATE DATABASE [IF NOT EXISTS] 库名; 修 ...
MySQL 进阶6: 连接查询 (多表连接) : 等值连接/非等值连接 /左右全连接/内连接
#进阶6: 连接查询 (多表连接) : 等值连接/非等值连接 /左右全连接/内连接 /* 含义: 当查询的字段来自于多个表时, 就会用到连接查询一: sql 92标准 :等值连接 ,(#内连接) 1 ...
django ORM model filter 条件过滤，及多表连接查询、反向查询，某字段的distinct
版权归作者所有,任何形式转载请联系作者.作者:petanne(来自豆瓣)来源:https://www.douban.com/note/301166150/ 1.多表连接查询:感觉django太NX了. ...
Django中的ORM进阶操作
Django中的ORM进阶操作 Django中是通过ORM来操作数据库的,通过ORM可以很easy的实现与数据库的交互.但是仍然有几种操作是非常绕也特别容易混淆的.于是,针对这一块,来一个分类总结吧. ...
Django - ORM - 进阶
一.多表操作创建模型实例:我们来假定下面这些概念,字段和关系作者模型:一个作者有姓名和年龄. 作者详细模型:把作者的详情放到详情表,包含生日,手机号,家庭住址等信息.作者详情模型和作者模型之间是 ...

随机推荐

Tomcat连接池配置
今日做了个小网站,数据量不大,但当发布到虚拟主机上之后,接连不断的遇到各种问题. 被折磨了数日后,在网上查了大量的相关资料,现总结如下. 一.项目在上传到远程服务器的过程中,有可能丢失文件,或文件内容 ...
情境领导II
情境领导理论认为,领导者的行为要与被领导者的准备程度相适应,才能取得有效的领导效果,也就是说领导风格不是一成不变的,而要根据环境及员工的变化而改变. 三大技巧分别为诊断.弹性与约定领导型态.诊断是评估 ...
2018.08.21 NOIP模拟 xorand（01trie）
xorand 描述有q次操作,每次操作是以下两种: 1. 加入一个数到集合中 2. 查询,查询当前数字与集合中的数字的最大异或值,最大and值,最大or值输入第一行1个正整数Q表示操作次数接下 ...
1000多块整个插板，arduino + android 蓝牙插板的实现--屌丝版
需求描述儿子有一堆充电玩具,基本上都是锂电池,经常插上去充电忘了到时拔下来,所以需要一块能设置接通时间的插板以保障电池的安全. 硬件设计: 首先需要一块插板,接着需要一个继电器,然后采用a ...
事务不起作用 Closing non transactional SqlSession
In proxy mode (which is the default), only external method calls coming in through the proxy are int ...
4) Maven 安装
# ----------------------------------------------------------------------------# Maven2 Start Up Batc ...
spring + rs + RocketMQ 【精】
cxf-rs-rocketmq 项目地址:见git │ pom.xml │ └─src ├─main │ ├─java │ │ └─cn │ │ └─zno │ │ ├─pojo │ │ │ Rece ...
gorename: easy refactoring tool for Golang[转]
To inaugurate this attempt of blog, I’ll talk about gorename a small but incredibly useful tool I ju ...
python socket.error: [Errno 10061]
用Python写server和client时候如果server中sock.bind(('localhost', 8001)) 则client中sock.connect(('localhost', 8 ...
Perf -- Linux下的系统性能调优工具，第 1 部分
Perf 简介 Perf 是用来进行软件性能分析的工具. 通过它,应用程序可以利用 PMU,tracepoint 和内核中的特殊计数器来进行性能统计.它不但可以分析指定应用程序的性能问题 (per t ...

day 48 ORM 进阶 多表连接 创建 以及 html模板继承

2、添加表记录

3、查询表记录

4、删除表记录

5、修改表记录

关联管理器(RelatedManager)

一、class RelatedManager

1、一对多

2、多对多

3、方法合集

1、add(obj1[, obj2, ...])

2、create(**kwargs)

3、remove(obj1[, obj2, ...])

4、clear()

5、set()方法

二、操作表记录

1、添加一些简单的数据

1、publish表：

2、author表：

3、authordatail表：

2、一对多

3、多对多

2、基于对象的跨表查询

1、一对多查询（Publish 与 Book）

2、一对一查询（Author 和 AuthorDetail）

3、多对多查询 (Author 与 Book)

3、基于双下划线的跨表查询

1、一对多查询

2、多对多查询

3、一对一查询

4、进阶练习(连续跨表)

二、操作表记录

1、添加一些简单的数据

1、publish表：

2、author表：

3、authordatail表：

2、一对多

3、多对多

2、基于对象的跨表查询

1、一对多查询（Publish 与 Book）

2、一对一查询（Author 和 AuthorDetail）

3、多对多查询 (Author 与 Book)

3、基于双下划线的跨表查询

1、一对多查询

2、多对多查询

3、一对一查询

4、进阶练习(连续跨表)

day 48 ORM 进阶 多表连接 创建 以及 html模板继承的更多相关文章

随机推荐

热门专题

day 48 ORM 进阶多表连接创建以及 html模板继承

　　　2、添加表记录

　　　　3、查询表记录

　　　　4、删除表记录

　　　　5、修改表记录

　　1、一对多

　　2、多对多

　　3、方法合集

　　　　1、add(obj1[, obj2, ...])

　　　　2、create(**kwargs)

　　　　3、remove(obj1[, obj2, ...])

　　　　4、clear()

　　　　5、set()方法

　　1、添加一些简单的数据

　　　　1、publish表：

　　　　2、author表：

　　　　3、authordatail表：

　　2、一对多

　　3、多对多

　　2、基于对象的跨表查询

　　　　1、一对多查询（Publish 与 Book）

　　　　2、一对一查询（Author 和 AuthorDetail）

　　　　3、多对多查询 (Author 与 Book)

　　3、基于双下划线的跨表查询

　　　　1、一对多查询

　　　　2、多对多查询　

　　　　3、一对一查询

　　　　4、进阶练习(连续跨表)

　　1、添加一些简单的数据

　　　　1、publish表：

　　　　2、author表：

　　　　3、authordatail表：

　　2、一对多

　　3、多对多

　　2、基于对象的跨表查询

　　　　1、一对多查询（Publish 与 Book）

　　　　2、一对一查询（Author 和 AuthorDetail）

　　　　3、多对多查询 (Author 与 Book)

　　3、基于双下划线的跨表查询

　　　　1、一对多查询

　　　　2、多对多查询　

　　　　3、一对一查询

　　　　4、进阶练习(连续跨表)

day 48 ORM 进阶多表连接创建以及 html模板继承的更多相关文章