django ORM

• 表创建
• 单表操作
• 必知必会13条
• 神奇的双下划线查询
• 一对多外键增删改查
• 多对多外键增删改
• 正反向的概念
• 多表查询
• 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(‘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‘)

单表操作

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

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里通过表名小写__去查询
"""

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‘,
        },
    }
}

django ORM

原文：https://www.cnblogs.com/chenwenyin/p/12987986.html