今日内容回顾（django之表查询操作）

表查询数据准备及环境搭建

django自带小型数据库sqlite3

该数据库功能少，针对日期类型的数据兼容性查，可以选择切换到Mysql数据库

django切换MySQL数据库

1. 在settings.py配置文件中找打DATABASES
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
2. 将其配置修改到mysql数据库
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': 'd5',
         'HOST': '127.0.0.1',
         'PORT': 3306,
         'USER': 'root',
         'PASSWORD': '123',
         'CHARSET': 'utf8',      
         
"""
其中版本不同需要做出不同的修改

django1.x版本中需要在 __init__.py文件中添加
			import pymysql
			pymysql.install_as_MySQLdb()
			
			
django2.x以上只需要下载模块
	pip install mysqlclient

"""

定义模型类

class User(models.model):
    uid = models.AutoField(primary_key=True,verbose_name="编号（类似于注释）")
	name = models.CharField(max_length=32,verbose_name="姓名")
    age = models.ItegerField(verbose_name="年龄")
    join_time = models.DataField(auto_now_add=True)
    
    
    """
    日期字段重要参数
    	auto_now: 每次操作数据并保存都会自动更新当前时间
    	auto_now_add:在创建数据的那一刻自动获取当前时间，之后不是如果不人为变动则不更改
    """

执行数据库迁移命令
```
makemigrations
	migrate
```

模型层测试环境准备

django里面的文件是不支持直接测试的需要自己搭建一个小的测试环境

方式1：在任意空的py文件中准备环境

#在manage.py文件拷贝前四行代码
import os
def main():
    os.environ.setdefault('DJANGO_SETTINGS_MODULE','day')
   # 加上下面两行代码
	import django
    django.setup()
    # 在下方写入需要测试的代码
    from appo1 import models
    print(models.User.objects.filter())
    
# 加上main启动脚本    
if __name__=='__main__':
    main()

方式2：pycharm提供测试环境

python console命令行测试环境

ORM常见查询关键字

当需要查询主键值字段值的时候，可以使用pk替代主键字段的真正名字。

在模型类中可以定义一个__ str __ 方法，便于后续数据对象被打印展示

Queryset中如果是列表套对象那么可以直接for循环和索引取值。（索引取值不支持负数）

虽然Queryset支持索引但是当Queryset没有数据的时候索引取值会报错，推荐使用first

一、创建数据，返回值就是当前创建的数据对象  create()
    
    user_obj = models.User.objects.create(username='jason',age=18)
        print(user_obj.username)  # jason
        print(user_obj.join_time)  # 2022-09-0508:37:17.073245+00:00
# 利用类实例化对象然后调用save方法创建数据
     user_obj = models.User()
        user_obj.username='tony'
        user_obj.age=22
        user_obj.save()
二、更新数据  update ()

    models.User.objects.filter(id=1).update(username='tank',age=36)

三、删除数据  detele()
	
	models.User.objects.filter(pk=1).delete()
    
四 查询操作

1. filter()
筛选数据，返回值是一个Queryset(可以看成是列表套数据对象)
user_obj = models.User.objects.filter()
print(user_obj)  # <QuerySet [<User: 对象:jason>, <User: 对象:tony>]>

user_obj1 = models.User.objects.filter(username='jason',age=18)
print(user_obj1)  # <QuerySet [<User: 对象:jason>]>

2. all()
查询所有数据，返回值是一个Queryset(可以看成是列表套数据对象)
user_obj = models.User.objects.all()
    print(user_obj)  # <QuerySet [<User: 对象:jason>, <User: 对象:tony>]>

3.first()
获取Queryset中第一个数据对象，如果为空则返回None
user_obj = models.User.objects.all().first()
    print(user_obj)  # 对象:jason

 user_obj = models.User.objects.filter(username='不存在').first()
    print(user_obj)  # None
4.last()
获取Queryset中最后一个数据对象，如果为空则返回None
user_obj = models.User.objects.all().last()
    print(user_obj)  # 对象:tony

user_obj = models.User.objects.filter(pk=6).last()
    print(user_obj)  # None
 
5.get()
直接根据条件查询具体的数据对象，但是条件不存在则直接报错，不推荐使用
user_obj = models.User.objects.get(username='jason')
    print(user_obj)  #  对象:jason
    
user_obj = models.User.objects.get(username='不存在')
    print(user_obj)  # 报错！！！
    
6. values()
指定查询字段，结果是Queryset(可以看成是列表套字典数据)
user_obj= models.User.objects.values('username')
    print(user_obj)  # <QuerySet [{'username': 'jason'}, {'username': 'tony'}]>

7. values_list()
指定查询字段，结果是Queryset(可以看成是列表套元组)
user_obj = models.User.objects.values_list('username', 'age')
    print(user_obj)  # <QuerySet [('jason', 18), ('tony', 22)]>
    
 8.oeder_by()
只当字段排序，结果是Queryset默认是升序，在字段前加符号则为降序，并且支持多个字段排序
user_obj = models.User.objects.order_by('age')  # 升序
	print(user_obj)  # <QuerySet [<User: 对象:jason>, <User: 对象:tony>]>
    
user_obj = models.User.objects.order_by('-age')  # 降序
	print(user_obj)  # <QuerySet [ <User: 对象:tony>,<User: 对象:jason>,]>
    
 9. count()
统计orm查询之后结果集中的数据格式
user_obj = models.User.objects.all().count()
    print(user_obj)  # 2

10. disatinct()
针对重复的数据进行去重，去重的数据必须所有的数据都一样才符合去重，注意数据对象的主键
user_obj = models.User.objects.all().distinct()
    print(user_obj)
    
11.exclude()
针对括号呢的条件取反进行数据查询结果是Queryset(可以看成是列表套数据对象)
user_obj = models.User.objects.exclude(pk=2)
    print(user_obj)  # <QuerySet [<User: 对象:tony>]>

12.reverse()
反转，只针对已经排过序的结果做反转
user_obj = models.User.objects.order_by().reverse()
    print(user_obj)

13.exists()
判断查询结果是否又数据，返回布尔值，但是几乎不用因为所有数据自带布尔值

14.raw()
执行SQL语句，还可以借助模块
user_obj = models.User.objects.raw('select * from app01_User')
    print(user_obj)
    for i   in user_obj:
        print(i.username)
        print(i.age)
        print(i.join_time)
        
  
    from django.db import connection
    cursor = connection.cursor()
    cursor.execute("select * from app01_user")
    obj_tuple = cursor.fetchall()
    print(obj_tuple)

神奇的双下划线的查询

比较运算符

1. 大于，字段名__gt
    user_obj = models.User.objects.filter(age__gt=20)
        print(user_obj)  # <QuerySet [<User: 对象:tony>]>
2.小于，字段名__lt
	user_obj = models.User.objects.filter(age__lt=20)
    	print(user_obj)  # <QuerySet [<User: 对象:jason>]>
3. 大于等于，字段名__gte
	user_obj = models.User.objects.filter(age__gte=20)
        print(user_obj)  # <QuerySet [<User: 对象:tony>]>
4. 小于等于，字段名__lte
	user_obj = models.User.objects.filter(age__lte=20)
    	print(user_obj)  # <QuerySet [<User: 对象:jason>]>

成员运算

字段名__ in
    user_obj = models.User.objects.filter(username__in=
    ('jason','hha'))
        print(user_obj)  # <QuerySet [<User: 对象:jason>]>

范围查询

字段名__range
    user_obj = models.User.objects.filter(age__range=(20,30))
        print(user_obj)  # <QuerySet [<User: 对象:tony>]>

模糊查询

1. 字段__contains(不忽略大小写)
	user_obj = models.User.objects.filter(username__contains='t')
    print(user_obj)  # <QuerySet [<User: 对象:tony>]>

2. 字段__icontains(忽略大小写)
	 user_obj = models.User.objects.filter(username__icontains='j')
    print(user_obj)  # <QuerySet [<User: 对象:jason>]>

日期处理

1. 字段__year、__mouth、__day
	user_obj = models.User.objects.filter(join_time__year=2022)
   	 	print(user_obj)

查看ORM底层SQL语句

方式1

如果是Queryset对象，那么可以直接点query查看SQL语句

方式2

配置文件配置，打印所有的ORM操作对应的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',
                },
            }
}

ORM外键字段创建

一对多
  ORM中外键字段建在多的一方	models.Foreignkey()
  	_id后缀无需添加  会自动添加上
多对多
  ORM中有三种创建多对多字段的方式， models.ManyToManyField()
  1. 直接在查询频率较高的表中填写字段即可，自动创建第三张表关系
  2. 自己创建第三张关系表
  3. 自己创建第三张关系表，但还是要orm多对多字段做关联
一对一
  ORM中外键字段建在查询频率较高的表中  models.OneToOneField()
  	_id后缀无需添加  会自动添加上

django1.x 针对 models.ForeignKey() models.OneToOneField()不需要on_delete
django2.x、3.x、4.x以上 则需要添加on_delete参数



class Book(models.Model):
  bid = models.AutoField(primary_key=True)
  title = models.CharField(max_length=32)
  price = models.DecimalField(max_digits=8, decimal_places=2)
  publish_time = models.DateTimeField(auto_now=True)

  publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
  authors = models.ManyToManyField(to='Author')

  def __str__(self):
      return '对象:%s' % self.title


class Publish(models.Model):
  pid = models.AutoField(primary_key=True)
  name = models.CharField(max_length=32)
  email = models.CharField(max_length=32)

  def __str__(self):
      return '对象:%s' % self.name


class Author(models.Model):
  name = models.CharField(max_length=32)
  age = models.IntegerField()
  Author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

  def __str__(self):
      return '对象:%s' % self.name


class AuthorDetail(models.Model):
  phone = models.BigIntegerField()
  addr = models.CharField(max_length=255)

  def __str__(self):
      return '地址:%s' % self.addr

外键字段数据操作

# 一对多关系表数据操作  书籍与出版社的关系
	models.ForignKey(to='Publish',on_delete=models.CASCADE)
# 先创建没有外键字段的表数据，出版社表
	user_obj = models.Publish.objects.create(
       	name='中原出版社',email='中原')
# 在创建有外键字段的表数据，书籍表
	# 方式1，直接给实际字段添加关联数据值  publish_id = 1
	models.Book.objects.create(title='python', 
       price=28888.88,publish_id=1 )
	# 方式2，间接使用外键虚拟字段添加数据对象  publish=publish_obj
		publish_obj= models.Publish.objects.filter(pk=2).first()
    models.Book.objects.create(title='mysql', price=28666.66, publish=publish_obj)
    
    
# 一对一关系表数据操作
	models.OneToOneField(to="authorDetail",on_delete=models.CASCADE)
# 先创建没有外键字段的表数据，作者详情表
	models.AuthorDetail.objects.create(phone=123456,addr='上海')
# 在创建有外键字段的作者表数据，作者表
	# 方式1直接给实际字段添加关联数据值	 author_detail_id = 1
	models.Author.objects.create(name='jason',age=18,Author_detail_id=1)
	# 方式2 间接使用外键虚拟字段添加数据对象 author_detail=authorDetail_obj
    
    authordetail_obj = models.AuthorDetail.objects.filter(pk=7).first()
    models.Author.objects.create(name='jason1号',age=18,Author_detail=authordetail_obj)
    
 
    
# 多对多关系表数据操作，
models.ManyToManyField(to="Author")
# 1.add添加数据，括号内即可填写数字值也可以填写数据对象，支持多个
    # 方式1，直接添加id值
        book_obj = models.Book.objects.filter(pk=2).first()
        book_obj.authors.add(1)
        book_obj.authors.add(2,3)
    # 方式2，添加作者对象
        book_obj = models.Book.objects.filter(pk=3).first()
        author_obj = models.Author.objects.filter(pk=5).first()
        author_obj1 = models.Author.objects.filter(pk=6).first()
        author_obj2 = models.Author.objects.filter(pk=2).first()
        # 可以添加单个
        book_obj.authors.add(author_obj)
        # 也可以添加多个
        book_obj.authors.add(author_obj1,author_obj2)
# 2.remove删除数据，阔奥内可以填写数字值也可以填写数据对象，支持多个
    book_obj = models.Book.objects.filter(pk=2).first()
    book_obj.authors.remove(5,6)
    # 也可以直接添加对象

# 3.set修改数据，括号内必须是可迭代对象，底层等于先删除后新增，不是在原有的基础上替换
    book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.set((4,5,6))
    # 直接全部替换
# 4.clear清空数据，括号内不需要任何参数
	book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.clear()

正反向概念

正反向概念核心就在于外键字段在谁手上

正向查询：通过书查询出版社，外键字段在书表中

反向查询：通过出版社查询数，外键字段不在出版社表中

ORM跨表查询口诀>>>:正向查询按外键字段，反向查询按表名小写

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

基于对象的正向跨表查询

# 1.查询主键为2的书籍对应的出版社(书>>>出版社)
    # 1.1 先根据条件查询数据对象(先查书籍对象)
    book_obj = models.Book.objects.filter(pk=2).first()
    # 2.2 以对象为基准 思考正反向概念(书查出版社 外键字段在书表中 所以是正向查询 正向按外键字段)
    print(book_obj.publish)  # 对象:南方出版社

# 2.查询主键为3的书籍对应的作者(书 >> > 作者)
    # 2.1先根据条件查询数据对象(先查书籍对象)
    book_obj= models.Book.objects.filter(pk=3).first()
    # 2.2以对象为基准，思考正反向概念(书查作者，外键字段在书表中 所以是正向查询 正向按外键字段)
    print(book_obj.authors.all())  # <QuerySet [<Author: 对象:tom>, <Author: 对象:egon>, <Author: 对象:jason1号>]>


# 3.查询jason的作者详情
    # 3.1先根据条件查询数据对象(先查询作者)
    authors_obj= models.Author.objects.filter(name='jason').first()
    # 3.2以对象为基准，思考正向反向概念(作者查作者详情，外键字段在作者表中，所以是正向查询 正向查询按外键字段）
    print(authors_obj.Author_detail)  # 地址:上海

基于对象的反向跨表查询

# 1.查询南方出版社出版的书籍
    # 1.1先根据条件查询数据对象(先查出版社)
    publish_obj = models.Publish.objects.filter(name='南方出版社').first()
    # 1.2 以对象为基准，思考正向反向概念（出版社查书籍，外键字段在书籍表中，所以是反向查询 反向查询按表名小写
    print(publish_obj.book_set)  # app01.Book.None
    print(publish_obj.book_set.all())  # <QuerySet [<Book: 对象:python>]>
    
    
    
 # 2.查询jason写过的书
    # 2.1 先根据条件查询数据对象(先查作者)
    authors_obj = models.Author.objects.filter(name='jason').first()
    # 2.2 以对象为基准，思考正向反向概念（作者查书籍，外键字段在书籍表中，所以是反向查询，反向查询按表名小写)
    print(authors_obj.book_set)  # app01.Book.None
    print(authors_obj.book_set.all())  # <QuerySet [<Book: 对象:python>]>

    
 # 3.查询电话是123456的作者
    #3.1 先根据条件查询数据对象（先查作者详情）
    authors_detail_obj = models.AuthorDetail.objects.filter(phone=123456).first()
    # 3.2 以对象为基准，思考正向反向概念（作者详情查作者，外键字段在作者表中，是反向查询，反向查询按表名小写）
    print(authors_detail_obj.author)  # 对象:jason

基于双下划线的跨表查询（连表操作）

基于双下划线的正向跨表查询

 # 1.查询主键为2的书籍对应的出版社名称及书名
    res = models.Book.objects.filter(pk=2).values('publish__name','title')
    print(res)  # <QuerySet [{'publish__name': '南方出版社', 'publish__book__title': 'python'}]>

    
    
 # 2.查询主键为3的书籍对应的作者姓名及书名
    res = models.Book.objects.filter(pk=3).values('authors__name','title')
    print(res)  # <QuerySet [{'authors__name': 'tom', 'title': 'golang'}, {'authors__name': 'egon', 'title': 'golang'}, {'authors__name': 'jason1号', 'title': 'golang'}]>


     # 3.查询jason的作者的电话号码和地址
    res = models.Author.objects.filter(name='jason').values('Author_detail__phone','Author_detail__addr')
    print(res)  # <QuerySet [{'Author_detail__phone': 123456, 'Author_detail__addr': '上海'}]>

基于双下划线的反向跨表查询

# 1.查询南方出版社出版的书籍名称和价格
    res = models.Publish.objects.filter(name='南方出版社').values('book__title','book__price')
    print(res)  # <QuerySet [{'book__title': 'python', 'book__price': Decimal('28888.88')}]>

    
    
  # 2.查询jason写过的书的名称和日期
    res = models.Author.objects.filter(name='jason').values('book__title','book__publish_time')
    print(res)  # <QuerySet [{'book__title': 'python', 'book__publish_time': datetime.datetime(2022, 9, 5, 12, 46, 32, 758263, tzinfo=<UTC>)}]>


# 3.查询电话是123456的作者姓名和年龄
    res = models.AuthorDetail.objects.filter(phone=123456).values('author__age','author__name')
    print(res)  # <QuerySet [{'author__age': 18, 'author__name': 'jason'}]>

"""
研究ORM跨表本质
# 查询主键为2的书籍对应的作者电话号码
    res = models.Book.objects.filter(pk=2).values('authors__Author_detail__phone')
    print(res)  # <QuerySet [{'authors__Author_detail__phone': 123456}, {'authors__Author_detail__phone': 456789}, {'authors__Author_detail__phone'
"""