表查询数据准备及测试环境搭建、orm常见查询关键字、orm外键字段、双下划线、查看ORM底层SQL语句

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

1.Django自带一个sqlite3小型数据库

该数据库功能非常有限 并且针对日期类型的数据兼容性很差；

sqlite3 数据库是 Python 自带的数据库，甚至不需要额外安装模块，而且操作简单。

Python + Mysql = SQLite

2.Django切换MySQL数据

django1.X
    import pymysql
    pymysql.install_as_MYSQLdb()
django2.X 3.X 4.X
    pip install mysqlclient

"""DATABASES配置："""
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # 指定数据库软件名称
        'NAME': 'django01',  # 指定库名
        'USER': 'root',
        'PASSWORD': '123456',
        'HOST': '127.0.0.1',
        'PORT': 3306,
        'CHARSET': 'utf8'
    }
}

3.定义模型类

class User(models.Model):
    uid = models.AutoField(primary_key=True, verbose_name='编号')
    name = models.CharField(max_length=32, verbose_name='姓名')
    age = models.IntegerField(verbose_name='年龄')
    join_time = models.DateField(auto_now_add=True)
   """
   日期字段
       DateTimeField:年月日时分秒
       DateField:年月日

   日期字段重要参数
       auto_now:每次操作数据并保存都会自动更新当前时间
       auto_now_add:只在创建数据的那一刻自动获取当前时间 之后如果不人为更改则不变
   """

4.执行数据库迁移命令（模型类>>>表）

python mange.py makemigrations

python mange.py migrate

5.模型层测试环境准备

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

'''复制mange.py文件的前四行代码 放入一个空白的py文件中 但是不要放入已有的文件中'''
import os

def main():
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djang04.settings')
    import django  # 这个导入文件只能放在这里，放在外面会报错
    django.setup()

    from app01 import models  # 这个导入文件也只能放在这里，放在外面会报错
    print(models.User.objects.filter())


if __name__ == '__main__':
    main()

方式2:pycharm提供测试环境

python console命令行测试环境

终端的形式 代码没法保存下来 电话关掉以后 代码就会没有了 只是临时的

所有操作就可以直接在test.py文件中执行了

orm常见查询关键字

create（）

创建数据 返回值就是当前创建的数据对象，可以通过点的方式去获取数据对象里面具体的某个字段的值

1.当需要查询数据主键字段值的时候 可以使用pk忽略掉数据字段真正的名字
2.在模型类中可以定义一个__str__方法 便于后续数据对象被打印展示的是查看方便
3.Queryset中如果是列表套对象那么直接for循环和索引取值但是索引不支持负数
4.虽然queryset支持索引但是当queryset没有数据的时候索引会报错 推荐使用first
	1.create()
        创建数据 返回值就是当前创建的数据对象
        ps:还可以利用类实例化对象然后调用save方法创建
  	2.update()
  	 	 更新数据
	3.delete()
		 删除数据

import os


def main():
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djang04.settings')
    import django
    django.setup()

    from app01 import models
    print(models.User.objects.filter())

    res = models.User.objects.create(name='kevin', age=38)
    print(res)
    user_obj = models.User(name='oscar', age=20)
    user_obj.save()
    # 对象可以通过点的方式取值
    print(res.name)
    print(res.age)
    print(res.join_time)
    # 获取主键
    print(res.uid)
    print(res.pk)

if __name__ == '__main__':
    main()

查找主键的时候有俩中方式:
    1.我们可以通过主键名去使用点的方式去获取
    2.也可以通过点pk得方式去获取
        查找数据对象的主键以后我们创建表的时候可能会创建好多表，那么每个表中的主键名可能不一样，我们在要获取表对象的主键得时候，需要知道表的主键名，使用pk的话它会自动帮我们去找

1.filter()

筛选数据 返回值是一个QuerySet(可以看成是列表套数据对象)
    1.括号内不写查询条件 默认就是查询所有
    2.括号内可以填写条件 并且支持多个 逗号隔开 默认是and关系

    res = models.User.objects.filter(name='kevin', age=38)
    print(res)  # <QuerySet [<User: 对象：kevin>]>

2.all()

查询所有数据 返回值是一个QuerySet(可以看成是列表套数据对象)

    res = models.User.objects.all()
    print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：kevin>, <User: 对象：tony>]>

3.first()

获取Queryset中第一个数据对象 如果为空则返回None

    res = models.User.objects.all().first()
    print(res)  # 对象：jason

4.last()

获取Queryset中最后一个数据对象 如果为空则返回None

    res = models.User.objects.all().last()
    print(res)  # 对象：tony

5.get()

直接根据条件查询具体的数据对象 但是条件不存在直接报错 不推荐使用

    res = models.User.objects.get(pk=2)
    print(res)  # 对象：kevin
这个方法与filter方法对比：
    res = models.User.objects.get(pk=2)
    print(res)  # 对象：kevin
    res = models.User.objects.filter(pk=2).first()
    print(res)  # 对象：kevin
    虽然看起来get方法可能更简单一点，但是不推荐使用get方法
        当查询查询条件不存在的时候：
            res = models.User.objects.get(pk=21)
            print(res)  # 直接报错
            res = models.User.objects.filter(pk=21).first()
            print(res)  # None

6.values()

指定查询字段 结果是Queryset(可以看成是列表套字典数据)

    res = models.User.objects.values()
    print(res)   # <QuerySet [{'uid': 1, 'name': 'jason', 'age': 18, 'join_time': datetime.date(2022, 9, 5)}, {'uid': 2, 'name': 'kevin', 'age': 38, 'join_time': datetime.date(2022, 9, 5)}, {'uid': 3, 'name': 'tony', 'age': 19, 'join_time': datetime.date(2022, 9, 5)}]>

7.value_list()

指定查询字段 结果是Queryset(可以看成是列表套元组数据)

8.order_by()

指定字段排序 默认是升序 在字段前加负号则为降序 并且支持多个字段排序

    res = models.User.objects.order_by('age')
    print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：tony>, <User: 对象：kevin>]>
    res = models.User.objects.order_by('-age')
    print(res)  # <QuerySet [<User: 对象：kevin>, <User: 对象：tony>, <User: 对象：jason>]>

9.count()

统计orm查询之后结果集中得数据格式

    res = models.User.objects.all().count()
    print(res)  # 3

10.distinct()

针对重复的数据进行去重 一定要注意数据对象中的主键

11.exclude（）

针对括号内的条件取反进行数据查询QuerySet(可以看成是列表套数据对象)

    res = models.User.objects.exclude(pk=2)
    print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：tony>]>

12.reverse()

针对已经排了序的结果做颠倒

13.exists()

判断查询结果集是否有数据 返回布尔值 但是几乎不用因为所有数据自带布尔值

14.raw()

执行SQL语句
还可以借助于模块
    from django.db import connection
    cursor = connection.cursor()
    cursor.execute("insert into user(name) VALUES ('lisa')")
    cursor.execute("update user set name='lisa' WHERE name='jennie'")
    cursor.execute("delete from user where name='lisa'")
    cursor.execute("select * from user")
    cursor.fetchone()
    cursor.fetchall()

神奇的双下划线

1.比较运算符

"""
字段__gt					大于
字段__lt					小于
字段__gte					大于等于
字段__lte					小于等于
"""

res = models.User.objects.filter(age__lte=18)
print(res)  # <QuerySet [<User: 对象：jason>]>

2.成员运算符

字段__in

res = models.User.objects.filter(name__in=['jason', 'tony', 'oscar'])
print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：tony>]>

3.范围查询（数字）

字段__range

res = models.User.objects.filter(age__range=(15, 30))
print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：tony>]>

4.模糊查询

字段__contains          不忽略大小写
字段__icontains			 忽略大小写

res = models.User.objects.filter(name__contains='j')
print(res)  # <QuerySet [<User: 对象：jason>]>
res = models.User.objects.filter(name__icontains='j')
print(res)  # <QuerySet [<User: 对象：jason>, <User: 对象：Jerry>]>

5.日期处理

字段__year
字段__month
字段__day

查看ORM底层SQL语句

1.方式1
    如果是Queryset对象 那么可以直接点query查看SQL语句，但是这种方法通用性不强

2.方式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外键字段创建

1.一对多

ORM中外键字段建在多的一方 models.ForeignKey()
    会自动添加_id后缀

2.多对多

ORM中有三种创建多对多字段的方式 models.ManyToManyField()
        方式1:直接在查询频率较高的表中填写字段即可 自动创建第三张关系表
        方式2:自己创建第三张关系表
        方式3:自己创建第三张关系表 但是还是要orm多对多字段做关联

3.一对一

ORM中外键字段建在查询频率较高的表中 models.OneToOneField()
    会自动添加_id后缀

django1.X 针对 models.ForeignKey() models.OneToOneField()不需要on_delete
django2.X 3.X 则需要添加on_delete参数

外键字段数据操作

1.外键

models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    方式1直接给实际字段添加关联数据值	publish_id = 1
    方式2间接使用外键虚拟字段添加数据对象	publish=publish_obj

2.一对一

models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
    方式1直接给实际字段添加关联数据值	author_detail_id = 1
    方式2间接使用外键虚拟字段添加数据对象 	author_detail=authorDetail_obj

3.多对多

models.ManyToManyField(to='Author')
    add()
        添加数据  括号内即可以填写数字值也可以填写数据对象 支持多个
        方法一：
            book_obj = models.Book.objects.filter(pk=3).first()
            book_obj.author.add(1)
            book_obj.author.add(2, 3)
        方法二：
            book_obj = models.Book.objects.filter(pk=3).first()
            author_obj1 = models.Author.objects.filter(pk=3).first()
            author_obj2 = models.Author.objects.filter(pk=4).first()
            book_obj.author.add(author_obj1, author_obj2)
    remove()
        删除数据  括号内即可以填写数字值也可以填写数据对象 支持多个
            book_obj = models.Book.objects.filter(pk=3).first()
            author_obj1 = models.Author.objects.filter(pk=3).first()
            author_obj2 = models.Author.objects.filter(pk=4).first()
            book_obj.author.remove(1)
            book_obj.author.remove(2, 3)
            book_obj.author.remove(author_obj1)
            book_obj.author.remove(author_obj1, author_obj2)
    set()
        修改数据  括号内必须是可迭代对象
            book_obj.author.set([2, ])
            book_obj.author.set([2, 3])
            book_obj.author.set([author_obj1, ])
            book_obj.author.set([author_obj1, author_obj2])
    clear()
        清空指定数据  括号内不需要任何参数
            book_obj.author.clear()

正反向概念

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

正向查询

通过书查询出版社 外键字段在书表中

反向查询

通过出版社查询书 外键字段不在出版社表中

ORM跨表查询口诀

正向查询按外键字段 反向查询按表名小写

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

'''基于对象的正向跨表查询'''
    # 1.查询主键为1的书籍对应的出版社（书--出版社）
    # 1.1 先根据条件查询数据对象（先查书籍对象）
    book_obj = models.Book.objects.filter(pk=1).first()
    # 1.2 以对象为基准 思考正反向概念（书查出版社 外键字段在书表中 所以是正向查询）
    print(book_obj.publish)  # 出版社：清华大学出版社

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

    # 3.查询zxr的作者详情
    # 3.1.先根据条件查询数据对象
    author_obj = models.Author.objects.filter(name='zxr').first()
    # # 3.2.以对象为基准 思考正反向概念
    print(author_obj.author_detail)  # 作者电话及地址：110 山西
'''基于对象的反向跨表查询'''
    # 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: 对象：女人你成功引起了我的注意>, <Book: 对象：国民大侦探>, <Book: 对象：一生一世>]>

    # 2.查询jfw写过的书
    # 2.1先拿出作者
    author_obj1 = models.Author.objects.filter(name='jfw').first()
    # 2.2 思考正反方向
    print(author_obj1.book_set)  # app01.Book.None
    print(author_obj1.book_set.all())  # <QuerySet [<Book: 对象：凉生，我们可不可以不忧伤>]>

    # 3.查询电话是110的作者
    # 3.1.先拿作者详情对象
    author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    # 3.2.思考正反向
    print(author_detail_obj.author)  # 作者：zxr

基于双下划线的跨表查询(连表操作)

'''基于双下划线的正向跨表查询'''
    # 1.查询主键为1的书籍对应的出版社名称及书名
    res = models.Book.objects.filter(pk=1).values('publish__name', 'title')
    print(res)  # <QuerySet [{'publish__name': '清华大学出版社', 'title': '女人你成功引起了我的注意'}]>
    # 2.查询主键为3的书籍对应的作者姓名及书名
    res1 = models.Book.objects.filter(pk=3).values('author__name', 'title')
    print(res1)  # <QuerySet [{'author__name': 'jfw', 'title': '凉生，我们可不可以不忧伤'}]>
    # 3.查询zxr的作者的电话号码和地址
    res2 = models.Author.objects.filter(name='zxr').values('author_detail__phone', 'author_detail__addr')
    print(res2)  # <QuerySet [{'author_detail__phone': 110, 'author_detail__addr': '山西'}]>

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

    # 1.查询南方出版社出版的书籍名称和价格
    res3 = models.Publish.objects.filter(name='清华大学出版社').values('book__title', 'book__price')
    print(res3)  # <QuerySet [{'book__title': '女人你成功引起了我的注意', 'book__price': Decimal('1314.98')}, {'book__title': '国民大侦探', 'book__price': Decimal('67.98')}, {'book__title': '一生一世', 'book__price': Decimal('28.98')}]>
    # 2.查询wyn写过的书的名称和日期
    res4 = models.Author.objects.filter(name='wyn').values('book__title', 'book__publish_time')
    print(res4)  # <QuerySet [{'book__title': '女人你成功引起了我的注意', 'book__publish_time': datetime.datetime(2022, 9, 5, 13, 16, 43, 303992, tzinfo=<UTC>)}]>
    # 3.查询电话是110的作者姓名和年龄
    res5 = models.AuthorDetail.objects.filter(phone=110).values('author__name', 'author__age')
    print(res5)  # <QuerySet [{'author__name': 'zxr', 'author__age': 18}]>

"""
研究ORM跨表本质
# 7.查询主键为1的书籍对应的作者电话号码
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    print(res)
"""

当表与表之间的关系是一对多或者多对多时，那么需要使用.all()查询，否则查询结果为None

当表与表之间的关系是一对多或者多对赌且子查询是反向概念时，需要使用: 对象.表名小写_set.all()
    
当表与表之间的关系是一对一，正向概念是外键字段，反向概念就是表名小写