django ORM

目录

• 表创建
• 多对多三种创建方式
• 单表操作
• 必知必会13条
• 神奇的双下划线查询
• 一对多外键增删改查
• 多对多外键增删改
• 正反向的概念
• 多表查询
  • 子查询(基于对象的跨表查询)
  • 联表查询(基于双下划线的跨表查询)
• 聚合查询(aggregate)
• 分组查询(annotate)
• F与Q查询
• django中开启事务(transaction)
• 数据库查询优化
• choices参数(数据库字段设计)
• django单文件测试
• Django打印SQL语句

表创建

"""
用户表  图书表  出版社表  作者表  作者详情表 

图书和出版社是一对多的关系 外键字段建在多的那一方 book

图书和作者是多对多的关系 需要创建第三张表来专门存储

作者与作者详情表是一对一
"""
class User(models.Model):
    # int自增列，必须填入参数 primary_key=True。当model中如果没有自增列,则自动会创建一个列名为id的列。
    id = models.AutoField(primary_key=True, verbose_name='主键')
    # 字符类型，必须提供max_length参数,max_length表示字符长度,对应的MySQL数据库中的varchar类型。
    name = models.CharField(max_length=24, verbose_name='用户名')
    password = models.CharField(max_length=24)
    email = models.EmailField(max_length=24, default='xxx@163.com') # default 为该字段设置默认值
    # 日期字段，日期格式  YYYY-MM-DD，相当于Python中的datetime.date()实例
    reg_data = models.DateField(auto_now_add=True) # auto_now_add 创建数据记录的时候会把当前时间添加到数据库,之后不人为修改将一直不变
    # DateTimeField:日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime()实例。

class Book(models.Model):
    title = models.CharField(max_length=24)
    price = models.DecimalField(max_digits=8, decimal_places=1)
    # 一对多
    publish = models.ForeignKey(to='Publish')
    # 多对多
    authors = models.ManyToManyField(to='Author')

class Publish(models.Model):
    name = models.CharField(max_length=24)
    addr = models.CharField(max_length=24)
    email = models.EmailField(default='xxx@163.com')

class Author(models.Model):
    name = models.CharField(max_length=24)
    age = models.IntegerField()
    # 一对一
    author_detail = models.OneToOneField('AuthorDetail')

class AuthorDetail(models.Model):
    phone = models.CharField(max_length=11)
    addr = models.CharField(max_length=48)
    email = models.EmailField(default='xxx@163.com')

多对多三种创建方式

# 全自动:利用orm自动帮我们创建第三张关系表
class Book(models.Model):
    name = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author')

class Author(models.Model):
    name = models.CharField(max_length=32)
"""
优点:代码不需要你写 非常的方便 还支持orm提供操作第三张关系表的方法
不足之处:第三张关系表的扩展性极差(没有办法额外添加字段)
"""
# 纯手动
class Book(models.Model):
    name = models.CharField(max_length=32)

class Author(models.Model):
    name = models.CharField(max_length=32)

class Book2Author(models.Model):
    book_id = models.ForeignKey(to='Book')
    author_id = models.ForeignKey(to='Author')
'''
优点:第三张表完全取决于你,可以进行额外的扩展
不足之处:需要写的代码较多,不能够再使用orm提供操作第三张关系表的方法
'''

# 半自动
class Book(models.Model):
    name = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author',
                                     through='Book2Author',
                                     through_fields=('book','author')
                                     )
class Author(models.Model):
    name = models.CharField(max_length=32)
    # books = models.ManyToManyField(to='Book',
    #                                  through='Book2Author',
    #                                  through_fields=('author','book')
    #                                  )
class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')

"""
through_fields字段先后顺序:
通过第三张表查询对应的表,需要用到哪个字段就把哪个字段放前面。简单的来说当前表是谁,就把对应的关联字段放前面

半自动:可以使用orm的正反向查询,但是没法使用add,set,remove,clear这四个方法
"""

# 总结:你需要掌握的是全自动和半自动 为了扩展性更高 一般我们都会采用半自动

单表操作

"""
操作User表
"""
1.增
## 第一种方式
models.User.objects.create(name='xxx',password='123', age=18)

## 第二种方式
user_obj = models.User(name='xxx',password='123', age=18)
user_obj.save()


2.删
models.User.objects.filter(pk=1).delete() # pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段

# user_obj = models.User.objects.filter(pk=1).first()
# user_obj.delete()


3.修改
models.User.objects.filter(pk=1).update(name='egonDSB')

# user_obj = models.User.objects.get(pk=2)
"""
get方法返回的直接就是当前数据对象
但是该方法不推荐使用,一旦数据不存在该方法会直接报错
而filter则会返回None
"""
# user_obj.name = 'egonPPP'
# user_obj.save()


4.查
## 查询user表所有数据
user_queryset = models.User.objects.all()
"""
<QuerySet [<User: User object>, <User: User object>, <User: User object>]>
返回QuerySet对象,里面是列表套对象
"""

## 按条件查询
user_queryset = models.User.objects.filter(name='xxx') # filter括号内可以携带多个参数 参数与参数之间默认是and关系

## 查询出指定字段
res = models.User.objects.values('name', 'password')
"""
<QuerySet [{'name': 'xxx', 'password': 'd8828e857400'}, {'name': 'root', 'password': '9e6abb87d62f'}]>
返回QuerySet对象,里面是列表套字典
"""

必知必会13条

1. all() 查询所有数据
res = models.User.objects.all()
# <QuerySet [<User: User object>, <User: User object>, <User: User object>]>

2. filter() 带有过滤条件的查询(可以携带多个参数 参数与参数之间默认是and关系)
res = models.User.objects.filter(name='xxx')
# <QuerySet [<User: User object>]>

3. get() 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
res = models.User.objects.filter(pk=1)
# <QuerySet [<User: User object>]>

4. first() 返回queryset里面第一条记录
res = models.User.objects.all().first()
# User object

5. last() 返回queryset里面最后一条记录
res = models.User.objects.all().last()
# User object

6. values() 指定获取数据字段
res = models.User.objects.values('name', 'password')
# <QuerySet [{'name': 'xxx', 'password': 'd8828e857400'}, {'name': 'root', 'password': '9e6abb87d62f'}]>

7. values_list() 与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列
res = models.User.objects.values_list('name', 'password')
# <QuerySet [('xxx', 'd8828e857400'), ('root', '9e6abb87d62f')]>

8. distinct() 从返回结果中剔除重复纪录
res = models.User.objects.values('name', 'password').distinct()
#  去重一定要是一模一样的数据,如果带有主键那么肯定不一样,一定要注意

9. order_by() 对查询结果排序
res = models.User.objects.values('id', 'name').order_by('id') # 默认升序
# <QuerySet [{'id': 1, 'name': 'xxx'}, {'id': 3, 'name': 'root'}, {'id': 4, 'name': 'jason'}]>
res = models.User.objects.values('id', 'name').order_by('-id') # 降序
# <QuerySet [{'id': 4, 'name': 'jason'}, {'id': 3, 'name': 'root'}, {'id': 1, 'name': 'xxx'}]>

10. reverse() 对查询结果反向排序,请注意reverse()通常只能对已经排过序的数据使用
res = models.User.objects.values('id', 'name').reverse()
# <QuerySet [{'id': 1, 'name': 'xxx'}, {'id': 3, 'name': 'root'}, {'id': 4, 'name': 'jason'}]>
res = models.User.objects.values('id', 'name').order_by('id').reverse()
# <QuerySet [{'id': 4, 'name': 'jason'}, {'id': 3, 'name': 'root'}, {'id': 1, 'name': 'xxx'}]>

11. count() 统计查询到的数据的个数
res = models.User.objects.count()
# 3

12. exclude() 排除与所给筛选条件不匹配的对象
res = models.User.objects.exclude(name='jason')
# <QuerySet [<User: User object>, <User: User object>]>

13. exists() 如果QuerySet包含数据，就返回True，否则返回False
res = models.User.objects.filter(pk=10).exists()
# False

神奇的双下划线查询

1. models.Class.objects.filter(id__gt=1)   # 获取id大于1的值
# res = models.User.objects.filter(id__gt=1)

2. models.Class.objects.filter(id__gte=4)   # 获取id大于等于4的值
# res = models.User.objects.filter(id__gte=4)

3. models.Class.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
# res = models.User.objects.filter(id__lt=10, id__gt=1)
类似的还有：__lt, __lte

4. models.Class.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
# res = models.User.objects.filter(id__in=[11, 22, 33])

5. models.Class.objects.exclude(id__in=[11, 22, 33])  # not in
# res = models.User.objects.exclude(id__in=[11, 22, 33])

6. models.Class.objects.filter(id__range=[10,20])  # 获取id在10到20之间的数据 首尾都要
# res = models.User.objects.filter(id__range=[10,20])

7. models.Class.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的值 区分大小写
# res = models.User.objects.filter(name__contains="ven")

8. models.Class.objects.filter(name__icontains="ven") # 忽略大小写
# res = models.User.objects.filter(name__icontains="ven")

9. models.Class.objects.filter(name__startswith="j") # 获取name字段以j开头的值
# res = models.User.objects.filter(name__startswith='j')

10. models.Class.objects.filter(name__istartswith="j") # 忽略大小写
# res = models.User.objects.filter(name__istartswith='j')
类似的还有：__endswith, __iendswith

11. models.Class.objects.filter(reg_data__year=2017) # 获取日期等于2017年的值
date字段可以通过在其后加__year,__month,__day等来获取date的特点部分数据
# models.User.objects.filter(reg_data__date=datetime.date(2005, 1, 1))
# models.User.objects.filter(reg_data__date__gt=datetime.date(2005, 1, 1))

# models.User.objects.filter(reg_data__year=2018)
# models.User.objects.filter(reg_data__year__gte=2017)

# models.User.objects.filter(reg_data__month=12)
# models.User.objects.filter(reg_data__month__gte=6)

# models.User.objects.filter(reg_data__day=3)
# models.User.objects.filter(reg_data__day__gte=3)

# models.User.objects.filter(pub_date__week_day=2)
# models.User.objects.filter(pub_date__week_day__gte=2)

# models.User.objects.filter(reg_data__year=2020, reg_data__month__gte=4)
需要注意的是在表示一年的时间的时候，我们通常用52周来表示

一对多外键增删改查

1.增
# 1  直接写实际字段 id
models.Book.objects.create(title='论语',price=899.23,publish_id=1)
models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)

# 2  虚拟字段 对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)

2.删
models.Publish.objects.filter(pk=1).delete() # 级联删除

3.修改
models.Book.objects.filter(pk=1).update(publish_id=2)

publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj)

4.查
models.Book.objects.filter(pk=1).values('title', 'price', 'author__name')

多对多外键增删改

1.增
book_obj = models.Book.objects.filter(pk=1).first()
# print(book_obj.authors)  # 就类似于你已经到了第三张关系表了
book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1 的作者
# book_obj.authors.add(2,3) # 可以写多个值

# author_obj = models.Author.objects.filter(pk=1).first()
# author_obj1 = models.Author.objects.filter(pk=2).first()
# author_obj2 = models.Author.objects.filter(pk=3).first()
# book_obj.authors.add(author_obj)
# book_obj.authors.add(author_obj1,author_obj2)
"""
add给第三张关系表添加数据括号内既可以传数字也可以传对象 并且都支持多个
"""

2.删
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.remove(2)
book_obj.authors.remove(1,3)

# author_obj1 = models.Author.objects.filter(pk=1).first()
# author_obj2 = models.Author.objects.filter(pk=2).first()
# book_obj.authors.remove(author_obj1,author_obj2)
"""
remove括号内既可以传数字也可以传对象 并且都支持多个
"""


3.修改
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
book_obj.authors.set([3])  # 括号内必须给一个可迭代对象

# author_obj = models.Author.objects.filter(pk=1).first()
# author_obj1 = models.Author.objects.filter(pk=2).first()
# book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
"""
set括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
"""


4.清空
# 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()
"""
clear括号内不要加任何参数
"""

正反向的概念

1.正向
外键字段在我手上我查你就是正向

2.反向
外键字段如果不在我手上我查你就是反向

eg: 查询书籍的出版社,书籍表和出版社表的外键是在book表中的,所有通过book表去查出版社就是正向。反之通过出版社去查询就是反向

多表查询

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

1.查询书籍主键为1的出版社
book_obj = models.Book.objects.filter(pk=1).first()
## 书查出版社 正向
res = book_obj.publish # Publish object
# print(res)
# print(res.name)

2.查询书籍主键为2的作者
book_obj = models.Book.objects.filter(pk=2).first()
## 书查作者 正向
# res = book_obj.authors  # app01.Author.None
res = book_obj.authors.all()  # <QuerySet [<Author: Author object>, <Author: Author object>]>

3.查询作者jason的电话号码
author_obj = models.Author.objects.filter(name='jason').first()
## 作者查作者信息 正向
res = author_obj.author_detail
# print(res.phone)

"""
正向查询按字段查询
正向什么时候需要加.all()
    当你的结果可能有多个的时候就需要加.all()
    如果是一个则直接拿到数据对象
"""

4.查询出版社是东方出版社出版的书
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
## 出版社查书  反向
# res = publish_obj.book_set  # app01.Book.None
res = publish_obj.book_set.all()
# print(res)

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

6.查询手机号是110的作者姓名
author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
## 作者信息查作者 反向
res = author_detail_obj.author
# print(res.name)
"""
反向查询按表名小写查询
基于对象反向查询的时候
    当你的查询结果有多个的时候 就必须加_set.all()
    当你的结果只有一个的时候 不需要加_set.all()
"""

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

1.查询jason的手机号和作者姓名
## 正向
res = models.Author.objects.filter(name='jason').values('author_detail__phone','name')
# print(res)

## 反向
res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name')
# print(res)

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

## 反向
res = models.Publish.objects.filter(book__id=1).values('name','book__title')
# print(res)

3.查询书籍主键为1的作者姓名
## 正向
res = models.Book.objects.filter(pk=1).values('authors__name')
# print(res)

# 反向
res = models.Author.objects.filter(book__id=1).values('name')
# print(res)


4.查询书籍主键是1的作者的手机号
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
# print(res)
"""
正向查询: 在values里通过外键字段__去查询
反向查询: 在filter里通过表名小写__去查询
"""

聚合查询(aggregate)

from app01 import models
from django.db.models import Max,Min,Sum,Count,Avg

1.所有书的平均价格
res = models.Book.objects.aggregate(Avg('price'))
# print(res)  {'price__avg': 52.025}


res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
# print(res)

分组查询(annotate)

from django.db.models import Max, Min, Sum, Count, Avg

1.统计每一本书的作者个数
# res = models.Book.objects.annotate()  # 如果没values指定分组字段,默认按照表的id分组
res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
"""
author_num是我们自己定义的字段 用来存储统计出来的每本书对应的作者个数
"""

# res = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
# print(res) <QuerySet [{'title': '遮天', 'author_num': 1}, ...]>


2.统计每个出版社卖的最便宜的书的价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
# print(res)

3.统计不止一个作者的图书
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title','author_num')
# print(res)

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

"""
按照指定的字段分组
models.Tb.objects.values('price').annotate() # 按照price分组
"""

F与Q查询

1.F查询

# 1.查询卖出数大于库存数的书籍(在book表中添加库存和卖出字段)
from django.db.models import F
res = models.Book.objects.filter(maichu__gt=F('kucun'))
# print(res)

# 2.将所有书籍的价格提升500块
models.Book.objects.update(price=F('price') + 500)

# 3.将所有书的名称后面加上爆款两个字
"""
在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
"""
from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
# models.Book.objects.update(title=F('title') + '爆款')  # 所有的名称会全部变成空白

2.Q查询

# 1.查询卖出数大于100或者价格小于600的书籍
# res = models.Book.objects.filter(maichu__gt=100,price__lt=600)
"""filter括号内多个参数是and关系"""

from django.db.models import Q

res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600))  # | or关系
# print(res)  # <QuerySet []>

# res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))  # Q包裹逗号分割 还是and关系

# res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))  # ~ not关系


# Q的高阶用法  能够将查询条件的左边也变成字符串的形式
q = Q()
q.connector = 'or' 
q.children.append(('maichu__gt',100))
q.children.append(('price__lt',600))
res = models.Book.objects.filter(q)  
print(res)

django中开启事务(transaction)

"""
事务四大特性 ACID
1.原子性
    事务是一个不可分割的单位
2.一致性
    事务发生前和发生后，数据的完整性必须保持一致
3.隔离性
    事务之间互相不干扰
4.持久性
    事务一旦确认永久生效
"""
from django.db import transaction
try:
    with transaction.atomic():
        # sql1
        # sql2
        ...
        # 在with代码快内书写的所有orm操作都是属于同一个事务
except Exception as e:
    print(e)
print('执行其他操作')

数据库查询优化

"""
orm语句的特点:
惰性查询
    如果你仅仅只是书写了orm语句 在后面根本没有用到该语句所查询出来的参数
    那么orm会自动识别 直接不执行
"""
1.only与defer

res = models.Book.objects.only('title') # 只获取book表中的title字段
# SELECT `app01_book`.`id`, `app01_book`.`title` FROM `app01_book` LIMIT 21;
# print(res)  <QuerySet [<Book: Book object>, <Book: Book object>, ...]>
for i in res:
    print(i.title)  # 点击only括号内包含的字段 不会走数据库
    print(i.price)  # 点击only括号内不包含的字段 会重新走数据库查询


res = models.Book.objects.defer('title')  # 获取除了title字段的所有字段
# SELECT `app01_book`.`id`, `app01_book`.`price`, `app01_book`.`publish_id` FROM `app01_book` LIMIT 21;
# print(res) <QuerySet [<Book: Book object>, <Book: Book object>, ...>

for i in res:
    print(i.price)
    print(i.title)

"""
defer与only刚好相反
    defer括号内放的字段不在查询出来的对象里面 查询该字段需要重新走数据
    而如果查询的是非括号内的字段 则不需要走数据库了
"""

2.select_related与prefetch_related

# res = models.Book.objects.all()
# for i in res:
#     print(i.publish.name)  # 每循环一次就要走一次数据库查询


res = models.Book.objects.select_related('publish') # INNER JOIN
# 可以方多个外键 select_related(外键1__外键2__外键3...)
# print(res) <QuerySet [<Book: Book object>, <Book: Book object>,...]>
for i in res:
    print(i.publish.name)

"""
select_related内部直接先将book与publish连表查询,然后一次性将大表里面的所有数据全部封装给查询出来的对象,这个时候对象无论是点击book表的数据还是publish的数据都无需再走数据库查询。
select_related括号内只能放外键字段  一对多或一对一外键, 多对多不行
"""


res = models.Book.objects.prefetch_related('publish')  # 子查询
# print(res) <QuerySet [<Book: Book object>, <Book: Book object>,...]>
for i in res:
    print(i.publish.name)
"""
prefetch_related该方法内部其实就是子查询,将子查询查询出来的所有结果全部封装给查询出来的对象。
"""

choices参数(数据库字段设计)

"""
针对某个可以列举完全的可能性字段，我们常用的存储方法
"""
# models.py
class User(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    # 性别
    gender_choices = (
        (1,'男'),
        (2,'女'),
    )
    gender = models.IntegerField(choices=gender_choices)

    score_choices = (
        ('A','优秀'),
        ('B','良好'),
        ('C','及格'),
        ('D','不合格'),
    )
    # 保证字段类型跟列举出来的元祖第一个数据类型一致即可
    score = models.CharField(choices=score_choices,null=True)
    """
    该gender字段存的还是数字 但是如果存的数字在上面元祖列举的范围之内
    那么可以非常轻松的获取到数字对应的真正的内容
    """

from app01 import models
models.User.objects.create(username='jason',age=18,gender=1)
models.User.objects.create(username='egon',age=85,gender=2)
# 存的时候 没有列举出来的数字也能存
models.User.objects.create(username='tank',age=40,gender=3)


user_obj = models.User.objects.filter(pk=1).first()
# print(user_obj.gender) # 男

# 只要是choices参数的字段 如果你想要获取对应信息 固定写法 get_字段名_display()
# print(user_obj.get_gender_display())

user_obj = models.User.objects.filter(pk=3).first()
# 如果没有对应关系 那么字段是什么还是展示什么
# print(user_obj.get_gender_display())  # 3

django单文件测试

"""
当你只是想测试django中的某一个py文件内容 那么你可以不用书写前后端交互的形式
而是直接写一个测试脚本即可

脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以
"""
# 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行
import os
import sys

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
import django
django.setup()

if __name__ == "__main__":
    ...
    # 在这个代码块的下面就可以测试django里面的单个py文件了

Django打印SQL语句

## 通过queryset对象点击query查看内部的sql语句
res = models.User.objects.filter(pk=1)
print(res.query)
# SELECT `app01_user`.`id`, `app01_user`.`name`, `app01_user`.`password`, `app01_user`.`email`, `app01_user`.`reg_data` FROM `app01_user` WHERE `app01_user`.`id` = 1


## Django终端打印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',
        },
    }
}