day19

 

上节回顾：

一旦确定表关系为一对多：在多的一张表中加关联字段
一对一：在任何一张表中加入有个关联字段，另外关联字段必须唯一约束。
多对多：创建第三张表，主键，两个关联字段

单表操作：

添加记录：

# 方式1：
#obj=Book.objects.create(title="python",publishDate="2012-12-12",price=100)

注意：Book.objects.create()的返回值是当前添加的记录对象
# 方式2：
book_obj=Book(title="python2",publishDate="2012-12-12",price=100)
book_obj.save()

查询记录：（数据类型：QuerySet） [...,...,]

<1> all(): 查询所有结果
<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
如果符合筛选条件的对象超过一个或者没有都会抛出错误。
<5> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象

<4> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
model的实例化对象，而是一个可迭代的字典序列
<9> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

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

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

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

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

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

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

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


双下划线的查询：

book_list=Book.objects.filter(price__gt=60)
book_list=Book.objects.filter(price__lt=60)
book_list=Book.objects.filter(title__contains="py")
book_list=Book.objects.filter(title__startswith="python")
book_list=Book.objects.filter(price__in=[60,70,100])
book_list=Book.objects.filter(price__range=[50,99])



删除：
Book.objects.filter().delete() # 默认级联删除

更新：
Book.objects.filter().update(price=50,.....)


select distinct(nid,title) from Book

nid title
1 python
2 python
3 python

基于对象的跨表操作（子查询）：

什么是正向查询：通过关联字段所在的表查询另外一张关联表
什么是反向查询：通过一张关联表查询关联字段所在的表

#一对多 publish：与当前书籍对象关联的的出版社对象
publish=models.ForeignKey(to="Publish",to_field="id")
#多对多 authors
authors=models.ManyToManyField(to="Author")
author=models.OneToOneField("Author")
一对多：

正向查询，按字段：publish
反向查询，按表名小写_set


添加记录：


# 方式1：
#Book.objects.create(title="python",publishDate="2012-12-12",price=100,publish_id=2)
# 方式2：
publish_obj=Publish.objects.filter(name="人民出版社")[0]
Book.objects.create(title="python",publishDate="2012-12-12",price=100,publish=publish_obj)


查询：

查询java这本书的出版社的邮箱

book_obj=Book.objects.filter(title="java").first()
book_obj.publish.email

多对多：

正向查询，按字段：authors
反向查询，按表名小写_set

添加记录：

book_obj=Book.objects.create(title="python",publishDate="2012-12-12",price=100,publish_id=2)

book_obj.authors.add(obj1,obj2....)
book_obj.authors.add(*[])

book_obj.authors.remove(obj1,obj2....)
book_obj.authors.remove(*[])
book_obj.authors.clear()

查询：
book_obj.authors.all() # 与这本书籍关联的所有作者对象集合

一对一：

添加记录：参考一对多
查询记录：

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



基于QuerySet的跨表查询（join查询）


#一对多 publish：与当前书籍对象关联的的出版社对象
publish=models.ForeignKey(to="Publish",to_field="id")
#多对多 authors
authors=models.ManyToManyField(to="Author")
author=models.OneToOneField("Author")


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

一对多：
例1：
查询java这本书的出版社的邮箱（正向查询）

ret=Book.objects.filter(nid__gt=6).values("publish__name")

sql：
SELECT "app01_publish"."name"
FROM "app01_book" INNER JOIN "app01_publish"
ON ("app01_book"."publish_id" = "app01_publish"."id")
WHERE "app01_book"."nid" > 6 LIMIT 21;

values实现机制：
对调用的QuerySet集合对象里面的每一个对象循环遍历，取出每一个对象的显示字段的值，组成新的字典，放在一个新的QuerySet中，返回

例2：
# 查询人民出版社出版过的所有的书籍名称（反向查询）
ret=Publish.objects.filter(name="人民出版社").values("book__title")
print(ret)
<QuerySet [{'book__title': 'golang'}, {'book__title': 'linux2'}, {'book__title': 'qq'}, {'book__title': 'www'}]>

多对多的查询
# 查询php这本书籍的所有作者的名字以及年龄
# ret=Book.objects.filter(title="php").values("authors__name","authors__age")
# print(ret)
# 查询alex出版社过的所有书籍的名称和价格
# ret=Author.objects.filter(name="alex").values("book__title","book__price")
# print(ret)
一对一查询
# 查询tel=789的作者的名字
ret=AuthorDetail.objects.filter(tel="789").values("author__name")
# 查询alex的手机号是多少
ret=Author.objects.filter(name="alex").values("authordetail__tel")

扩展：
#查询人民出版社出版过的所有的书籍名称(两种查询思路，基表不同)

ret=Publish.objects.filter(name="人民出版社").values("book__title")
ret=Book.objects.filter(publish__name="人民出版社").values("title")

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

ret=Book.objects.filter(authors__authordetail__tel__startswith="7").values("title","publish__name")
print(ret)

SELECT "app01_book"."title", "app01_publish"."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"."id")
INNER JOIN "app01_authordetail" ON ("app01_author"."id" = "app01_authordetail"."author_id")
INNER JOIN "app01_publish" ON ("app01_book"."publish_id" = "app01_publish"."id")
WHERE
"app01_authordetail"."tel" LIKE '7%' ESCAPE '\' LIMIT 21; args=('7%',)

聚合查询与分组查询

聚合函数：Sum Count Avg Min Max

单表：
emp：
id name salary dep
1 张三 2000 销售部
2 李四 5000 IT部
3 王五 6000 销售部
4 赵六 5000 人事部
5 主七 2000 人事部

select Count(*),dep from emp group by dep
select * from emp group by id,name,salary,dep

跨表：
emp： dep：
id name salary dep_id id name
1 张三 2000 1 1 销售部
2 李四 5000 2 2 IT部
3 王五 6000 1 3 人事部
4 赵六 5000 3
5 主七 2000 2

dep---emp

id dep.id dep.name emp.id emp.name emp.salary emp.dep_id
1 1 销售部 1 张三 2000 1
2 1 销售部 3 王五 6000 1
3 2 IT部 2 李四 5000 2
4 2 IT部 5 主七 2000 2
5 3 人事部 4 赵六 5000 3

select Count(*) from emp
select * from dep group by id



SELECT "app01_publish"."name", COUNT("app01_book"."title") AS "c"
FROM "app01_publish" LEFT OUTER JOIN "app01_book" ON ("app01_publish"."id" = "app01_book"."publish_id")
GROUP BY "app01_publish"."id", "app01_publish"."name", "app01_publish"."email" LIMIT 21; args=()


ORM:

# 聚合函数 aggregate
from django.db.models import Sum,Count,Max,Min,Avg
# ret=Book.objects.all().aggregate(Sum("price"))
# print(ret)

# 分组函数 annotate

# 查询每一个出版社出版社出版的书籍个数
# ret=Publish.objects.all().annotate(c=Count("book__title")).values("name","c")
# print(ret) # <QuerySet [<Publish: 人民出版社>, <Publish: 机械出版社>, <Publish: 北京出版社>]>

# 查询每一本书的作者个数
#ret=Book.objects.all().annotate(author_num=Count("authors")).values("author_num","title")
# ret=Book.objects.all().annotate(author_num=Count("authors")).filter(author_num__gt=0)
# print(ret)

===============================

F查询与Q查询

=============================== ajax

json字符串：

json标准：number string("") 布尔类型 [] {} null



ajax请求

 

$.ajax({
url:"/handle_Ajax/",
type:"POST",
data:{username:"Yuan",password:123},

success:function(data){
alert(data)
},

今日作业：

 

作业1：

创建单表Book表，要求字段：

1 主键 nid
2 书名 title
3 价格 price
4 出版日期 pubDate
5 出版社 publisher（普通字符串字段）

添加多条记录后，

查询：

(1) 查询所有书籍的名称 Book.objects.all().values("title")
(2) 查询价格大于100的书籍名称以及价格 Book.objects.filter(price__gt=100).values("title","price")
(3) 查询2017年出版的所有以py开头的书籍名称 Book.objects.filter(pubDate__year="2017",title__startswith="py").values("title")
(4) 查询价格为50,100或者150的所有书籍名称及其出版社名称 Book.objects.filter(price__in=[50,100,150]).values("title","pubDate")
(5) 查询所有主键大于2小于5书籍的价格（去重） Book.objects.filter(nid__gt=2,nid__lt=5).values("price").distinct()
(6) 查询所有人民出版社出版的书籍的价格（从高到低排序，去重）Book.objects.filter(publisher="人民出版社").values("price").order_by("-price").distinct()


作业2：

基于图书管理系统的表关系与数据，进行如下查询
要求：1-5查询分别基于对象查询，双下划线查询，以及找到对应翻译的sql语句

1、查询人民出版社出版过的价格大于100的书籍的作者的email
2、查询alex出版过的所有书籍的名称以及书籍的出版社的名称
3、查询2011年出版社过的所有书籍的作者名字以及出版社名称
4、查询住在沙河并且email以123开头的作者写过的所有书籍名称以及书籍的出版社名称
5、查询年龄大于20岁的作者在哪些出版社出版过书籍
6、查询每一个出版社的名称以及出版过的书籍个数
7、查询每一个作者的名字以及出版过的所有书籍的最高价格
8、查询每一本书的名字，对应出版社名称以及作者的个数


作业3：

pass

===============================

form组件

用户认证 auth

 

博客项目（day2）

权限系统
stark组件
crm项目

flask+cmdb

爬虫

路飞

ajax用户登录 验证，基础部分、

js部分

   $("#submit").click(function () {
        var u = $('#user').val();
        var p = $('#pass').val();
        {#        console.log(u,p)#}
        $.ajax({
                url: '/test1/',
                type: 'GET',
                data: {'user': u, 'pass': p},
                dateType: "json",
                success: function (data) {
                    var data = JSON.parse(data)
                    if (data.login == true){
{#                        如果正确则跳转到首页#}
                        location.href="/index/"
                    }
{#                    #如果用户名和密码校验错误，则显示用户名和密码错误，这里也可以后端传值过来#}
                    else {
                       $("#msg").text("用户名和密码错误")
                    };

login ajax 后端部分

#下面为测试代码
def test(request):
    if request.method == "GET":
        return render(request,'test.html')
def test1(request):
    res={"login":False}
    u=request.GET.get('user')
    p=request.GET.get('pass')
    print(u)
    if u == "root" and p == "root":
        #下面两种方式发送json字符串。第一种不需要js那边反解，第二种需要反解json字符串
        # return JsonResponse({'res':1})
        res = {"login": True}
        return HttpResponse(json.dumps(res))

    else:
        # return JsonResponse({'res':0})
        return HttpResponse(json.dumps(res))