orm查询

request对象的几种方法

# GET POST FILES method
path path_info get_full_path() body
def index(request):
    print(request.path)  # /index/
    print(request.path_info)  # /index/
    print(request.get_full_path()) # 接收路径的全部内容，连参数也能拿到 /index/?username=kevin
    print(request.body)  # 浏览器发过的二进制数据
    return HttpResponse('ok')

1.什么是FBV与CBV，能不能试着解释一下CBV的运作原理

FBV是在视图里面写函数的   路由里面写views.函数名
CBV是在视图里面写类的  路由里面写views.类名.as_view()
本质上：路由里面的都是函数的内存的地址
CBV  vies.类名.as_view()   View中有as_view函数，返回值是view函数的内存地址，路由就可以变形为
view，浏览器请求路由，加括号调用view函数，view函数最后返回调用dispath函数，dispath函数调用getatter
判断是否拥有这个方法，拥有这个方法，返回这个方法的内存地址，加括号调用

2.模版语法的传值需要注意什么，常见过滤器及标签有哪些

模板语法中只用点语法
过滤器;safe,lenth,data('Y-m-d')

3.什么是模版的继承与导入，如何正确使用

{{}}   跟变量有关
{%%}   跟逻辑有关
{%extends 'html'%}
{% blovk css%}
style
{% endblock %}

1.常见的十几种查询方法都有哪些，每个都是干啥使的

get,filter, all(),first(),last()
values()   结果是列表套字典
values_list  结果是列表套元组
res = models.user.objects.filter(条件)
res.query   #查看原生sql语句
update()   修改数据
delete()	删除数据
user_obj.save()  对象，保存数据
distinct()       去重
order by      排序
reverse      反转 有序才能反转
count	查看表中数据的数量

2.简述双下划线查询都有哪些方法，作用是什么

大于，小于，大于等于，小于等于
filter(__gt)	大于
filter(__lt)	小于
filter(__gte)	大于等于
filter(__lte)	小于等于
#in
字段__in=[12,13,14]
#模糊查询
filter(__contains='s')   模糊查询，查看字段中包含s的
filter(__startswith='s')     以s开头
filter(__endswith='s')      以什么结尾
#时间
filter(__minth=5)   #查看是时间是五月的
filter(__year=5)	#查看是时间是五号的

查看原生sql语句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level': 'DEBUG',
        },
    }
}

3.针对多对多外键字段的增删改查方法有哪些，各有什么特点？

# 1. 子查询
###########################多表查询
    # 1.查询书籍主键为1的出版社
    # 先把书籍查询出来
    # book_obj = models.Book.objects.filter(pk=1).first()
    # book----->publish----->正向查询------>正向查询按外键字段
    # print(book_obj.publish) # 它就相当于是出版社对象了
    # publish_obj = book_obj.publish
    # print(publish_obj.name)
    # print(publish_obj.addr)

    # 2.查询书籍主键为2的作者
    # book----->author------->正向查询----->按字段
    # book_obj = models.Book.objects.filter(pk=2).first()
    # print(book_obj.authors)  # app01.Author.None
    # print(book_obj.authors.all())  # app01.Author.None

    # 3.查询作者jack的电话号码
    # 作者---------->详情-------->正向------->字段
    # author_obj = models.Author.objects.filter(name='jack').first()
    # print(author_obj.author_detail)
    # author_detail_obj = author_obj.author_detail
    # print(author_detail_obj.phone)


    # # 4.查询出版社是北京出版社出版的书
    # 先查出出版社的对象
    # publish_obj = models.Publish.objects.filter(name='北京出版社').first()
    # # 出版社  查 书  --------------> 反向-------->反向查询按表名小写或者_set
    # print(publish_obj.book_set)  # app01.Book.None
    # print(publish_obj.book_set.all())  # app01.Book.None

    # 5.查询作者是jack写过的书
    # author_obj = models.Author.objects.filter(name='jack').first()
    # # 作者 查 书 -------------->反向查询----->
    # print(author_obj.book_set)  # app01.Book.None
    # print(author_obj.book_set.all())  # app01.Book.None

    # 6.查询手机号是110的作者姓名
    # 详情表中
    # author_detail_obj = models.AuthorDetail.objects.filter(phone='110').first()
    # # 详情  -----》 作者 -------》反向-------》表名小写
    # print(author_detail_obj.author)  # Author object (1)
    # print(author_detail_obj.author.name)  # Author object (1)

# 2. 连表查询

联表查询(基于双下划线的跨表查询)

####################################基于双下划线的查询
    ## 1.查询jack的手机号和作者姓名
    # 作者 查 作者详情-------》正向查询-------》按字段
    # author_obj = models.Author.objects.filter(name='jack').values('name','author_detail__phone')
    # print(author_obj)

    # 反向查询
    # author_detail_obj = models.AuthorDetail.objects.filter(author__name='jack').values('phone','author__name')
    # print(author_detail_obj)






    # 2.查询书籍主键为1的出版社名称和书的名称
    # 书 ---》 出版社----》正向-----》按字段
    # book_obj = models.Book.objects.filter(pk=1).values('title', 'publish__name')
    # print(book_obj)

    # 反向查询
    # publish_obj = models.Publish.objects.filter(book__pk=1).values('name', 'book__title')
    # print(publish_obj)
    #  # 3.查询书籍主键为1的作者姓名
    # 书---》作者----》正向----》字段
    # book_obj = models.Book.objects.filter(pk=1).values('authors__name')
    # print(book_obj)

    # 反向查询
    # author_obj = models.Author.objects.filter(book__pk=1).values('name')
    # print(author_obj)


    # # 查询书籍主键是1的作者的手机号
    # book ---->  author ---->     author_detail
    author_detail = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    print(author_detail)
    '''当表特别多的时候，ORM语句其实并不好写，如果你真遇到这种不好写的语句的时候，就是要原生sql语句'''

4.什么是正反向的概念，及查询口诀，你能否总结一下正反向查询不同情况下点击不同字段的规律

正反向
正向----按外键字段    
反向----按表名小写或者_set

聚合查询（aggregate）

# sum min max avg count
# 在orm中如何使用聚合函数
# 关键字：aggregate，我们需要在django中倒过来才能使用
   from django.db.models import Count, Sum, Max, Min, Avg
    # 求书籍表中得书的平均价格
    # res = models.Book.objects.aggregate(Avg('price'))
    # res = models.Book.objects.aggregate(Max('price'))
    res = models.Book.objects.aggregate(Count('price'),Sum('price'),Max('price'),Min('price'),Avg('price'))
    print(res)

分组查询(annotate)

# group by分组
# 分组之后只能取得分组的依据，其他的字段不能拿到
# 设置一个严格模式：sql_mode='only...' 
# annotate
######################分组查询
    from django.db.models import Count, Sum, Max, Min, Avg
    # 1.统计每一本书的作者个数
    # select *from book group by id
    # res = models.Book.objects.annotate()  # 就是安装书来分组的
    # 正反向：书----》作者-----》正向-----》外键字段
    # annotate就是对models后面的表进行分组
    # 聚合函数一般都是配合分组使用的
    # res = models.Book.objects.annotate(author_num=Count('authors__pk')).values('title', 'author_num')
    # print(res)

    #  # 2.统计每个出版社卖的最便宜的书的价格
    # 1. 按照出版社分组
    # 2. 聚合查询书的价格
    # 3. 出版社查书------------>反向查询------------》表名小写
    # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
    # print(res)

    # 3.统计不止一个作者的图书
    # 1. 统计每一本的作者个数
    # 2. 在过滤出作者个数大于1的就可以了

    # 书----》作者-----》正向-----》外键字段
    # res = models.Book.objects.annotate(author_num=Count('authors__pk')).filter(author_num__gt=1).values('title', 'author_num')
    # res只要返回的结果是queryset，就可以一直往下点 queryset提供的方法
    # res = models.Book.objects.annotate(Count('authors'))
    # print(res)

    # 4.查询每个作者出的书的总价格
    # 1. 按照作者分组
    # 2. 作者查书
    # 总价格
    # res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
    # print(res)

F与Q查询

# 1.查询卖出数大于库存数的书籍
####################F查询
    from django.db.models import F

    # 1.查询卖出数大于库存数的书籍
    # select * from book where sale_num > kucun;
    # kucun

    # res = models.Book.objects.filter(sale_num__gt=F('kucun'))
    # print(res)

    # # 2.将所有书籍的价格提升500块
    # update app01_book set price = price+500;

    # res = models.Book.objects.update(price=F('price')+500)
    # 3.将所有书的名称后面加上爆款两个字
    # update app01_book set title = title + 'haha' ;
    from django.db.models.functions import Concat
    from django.db.models import Value
    # models.Book.objects.update(title=F('title')+'haha') # 不能这样写
    models.Book.objects.update(title=Concat(F('title'), Value('haha'))) 

Q查询

# # 1.查询卖出数大于100或者价格小于600的书籍
    # select * from book where sale_num > 100 or price < 600;
    # res = models.Book.objects.filter(sale_num__gt=100, price__lt=600) # and关系
    # res = models.Book.objects.filter(sale_num__gt=100).filter(price__lt=600) # and关系
    from django.db.models import Q

    # res = models.Book.objects.filter(sale_num__gt=100).filter(price__lt=600) # and关系
    # res = models.Book.objects.filter(Q(sale_num__gt=100), Q(price__lt=600))  # and关系
    # res = models.Book.objects.filter(Q(sale_num__gt=100)|Q(price__lt=600))  # or关系
    # res = models.Book.objects.filter(~Q(sale_num__gt=100)|Q(price__lt=600))  # ~是非的关系
    # print(res)

    # Q补充高级用法
    res = models.Book.objects.filter(Q(sale_num__gt=100) | Q(price__lt=600))
    ''''''
    # 'price'
    # requests.GET.get('sort') # price
    # res = models.Book.objects.filter(price__gt=100)
    # # res = models.Book.objects.filter('price'+'__gt'=100)
    q = Q()
    q.connector = 'or' # 把多个查询条件改为OR关系了
    q.children.append(('maichu__gt', 100))
    q.children.append(('sale_num__lt',100))
    res = models.Book.objects.filter(q)  # and关系 ，，
    print(res)

    # 想学习Q的更高级用法，自行百度

django中如何开启事务

# mysql中的事务
ACID
...

# MySQL的隔离级别：脏读，重复读

开启事务的步骤
1、 开启事务
	start transaction;
2、提交事务
	commit;
3、回滚事务
	rollback;
# django中如何开启事务
  from django.db import transaction
    try:
        with transaction.atomic():
            models.Book.objects.create()
            models.Publish.objects.update()
            # sql1
            # sql2
            ...
    except Exception as e:
        print(e) # 当sql语句出现异常的时候，可以在这里打印错误信息
        transaction.rollback()