JinLinC个人在线文档库

数据库交互

在`Ubuntu`中安装`MySQL`数据库

sudo apt-get install mysql-server
安装mysql的服务，安装完成后会提示设置数据库密码
sudo apt install mysql-client
安装mysql的客户端
sudo apt install libmysqlclient-dev
安装一些依赖

如果需要进行远程连接的话，需要更改一下mysqld.cnf文件，这个文件一般在/etc/mysql/mysql.conf.d/mysqld.cnf路径下，我们需要将bind-address = 127.0.0.1这一行进行注释掉

创建数据库

可以在Navicat中直接连接数据库，右键连接的数据库，点击新建数据库，输入数据库名（dj_data），字符集（utf8mb4），排序规则（utf8mb4_bin）

`ORM`

ORM可以使我们直接使用python的方法去使用数据库（使用python的代码去控制mysql）
ORM可以把表映射成类，把行作为实例，把字段作为属性，orm在执行对象操作时会把对应的操作转换成数据库原生语句的方式来完成数据库的开发工作

`Django`中的`ORM`

Django中的虚拟对象数据库也叫模型，通过模型实现对目标数据库的读写操作：

在settings.py中设置数据库的信息（需要提前在数据库中创建库）
在应用app的models.py中使用类的形式定义数据类型
通过模型在目标数据库中创建对应的表
在视图函数中通过对模型的操作实现目标数据库的读写操作

`settings.py`中的数据库配置

DATABASES是一个数据库相关的配置项

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # 数据库引擎
        'NAME': 'dj_data',  # 自己数据库的名称，数据库需要提前建立
        'USER': 'root',  # 数据库的用户名
       	'PASSWORD': '',  # 数据库的密码
        'HOST': '',      # 数据库的主机ip，留空默认是127.0.0.1
        'PORT': '3306',  # 数据库软件端口
    }
}

`models.py`的配置

在应用文件夹中的models.py文件，我们需要进行相关的配置，去生成一些相应的表，我们只需要在该文件下编写这些表的数据模型：

from django.db import models  # models是django内置的ORM

class Test(models.Model):  # 继承models中的Model模块
    # 编写相关的字段， models.CharFild表示声明的是一个字符串类型，max_length设置最大长度，是必须要进行设置的
    name = models.CharFild(max_length=20)
    # models.IntegerField表示整形类型，设置默认值默认为0
    age = models.IntegerField(default=0)

同步到数据库时，我们需要下载一个包：pip install pymysql
在项目文件下的__init__.py文件中将pymysql进行导入后再进行调用：
py
import pymysql
pymysql.install_as_MySQLdb

在Tools中点击Run manage.py Task...，我们在里面输入命令：

makemigrations 生成一个python的脚本，脚本文件存在应用文件中的migrations文件夹下面
migrate 同步脚本文件到数据库中

后续我们需要进行对表的修改只需要修改models.py文件，并执行上述数据库命令即可

数据模型中的字段

字段方法所在的位置：在models.py中会导入一个包，之后去创建一个模型类去继承models就可以去使用了，models中存在许多的字段类型，我们可以通过dir(models)进行查看，具体的类型如下所示：

字符串与数字类型

字段名	描述	列举
`charField`	字符串类型	`'abc'`
`TextField`	文本类型	`'abcdef...'`
`EmailField`	邮箱类型	`'adimn@admin.com'`
`UrlField`	网址类型	`'http://www.baidu.com'`
`BooleanField`	布尔类型	`True False`
`NullBooleanField`	可为空的布尔类型	`None True False`
`IntegerField`	整形	`(-2147483648,2147483647)`
`SmallIntegerField`	短整型	`(-32768,32767)`
`BigIntegerField`	长整型
`PositiveIntegerField`	正整形	`(0,2147483647)`
`PositiveSmallIntegerField`	短正整形	`(0,32767)`
`FloatField`	浮点类型	`3.14`
`DecimalField`	十进制小数	`12345.123123`

时间类型

字段名	描述	列举
`DateField`	日期类型	`xxxx-xx-xx`
`DateTimeField`	日期类型	`xxxx-xx-xx xx:xx:xx`
`TimeField`	时间类型	`xx:xx:xx`

文件类型

字段名	描述	列举
`ImageField`	图片类型	`xxx.jpg`
`FileField`	文件类型	任意文件类型

特殊类型属性

字段名	描述	列举	作用于
`max_digits`	数字中允许的最大位数	12	`DecimalField`
`decimal_places`	存储的十进制位数	2	`DecimalField`
`width_field`	图片宽（可不传）	1024	`ImageField`
`height_field`	图片高（可不传）	576	`ImageField`
`upload_to`	保存上传文件的本地文件路径	`'xx/xx.xx'`	`ImageField`、`FileField`

公共属性

公共属性一般作用于整形，时间类型，字符串类型等等

字段名	描述	列举
`null`	值是否设为空	`True False`
`blank`	值是否可为空	`True False`
`primary_key`	设置主键	`True`
`auto_now`	时间自动添加	`True`
`auto_now_add`	自动添加时间，但仅在创建的时候	`True`
`max_length`	字段长度
`default`	默认值	`xxx`
`verbose_name`	`admin`中显示名字	`name`
`db_column`	数据库字段名
`unique`	唯一索引	`True`
`db_index`	普通索引	`True`

编写数据模型

在models.py中进行数据模型的编写：

from django.db import models

class User(models.Model):
    # id可以不用专门创建，数据库会自动进行创建
    id = models.IntegerField(primary_key=True)  # 设置为主键
    # unique 唯一索引，该值不允许重复; blank=Flase表示该值不允许为空
    username = models.CharField(unique=True, max_length=20, blank=Flase)
    age = models.SmallIntegerField(default=0)
    # db_index=True 设置普通索引，允许重复
    phone = models.SmallIntegerField(db_index=True, blank=True)
    email = models.EmailField(blank=True, default='')
    info = models.TextField()
    # auto_now_add=True创建时添加时间
    create_time = models.DateTimeField(auto_now_add=True)
    # 更新时变更时间auto_now=True
    update_time = models.DateTimeField(auto_now=True)

数据库的表关系和联合索引的创建

表关联的方法

字段名	描述
`ForeignKey`	一对多
`OneToOneField`	一对一
`ManyToManyField`	多对多

一对一表关系：仅在两张表中，表1的a这一行数据和表2的a这一行数据有关系，且表2的a行数据也只会和表1的a行有关系，如用户信息表和用户信息详情表，详情表中的某条数据都要与用户信息表中的某条数据对应
一对多表关系：表1的第a行数据和多个表的多行数据都会有所关系，而多个表中的多行数据与表1的a行数据有关系，且只和表1的第a行数据有所关联，如一个用户可以发送多篇日志，这些日志只是对应了一个用户
多对多表关系：表1中的第a行数据可以与表2中的一行或多行相互联系，表2中的a行也可以和表1中的一行或多行相互关联

属性名	描述	列举
`related_name`	关联表的名字	`related_name='profile'`
`on_delete`	外键删除的对策	`on_delete=models.SET_NULL(CASCADE, PROTECT)`

主键和外键，当我们想要删除一张主表的时候，可能我们的副表会关联到我们主表的ID，我们删除主表后，副表可能会抛出错误，使用on_delete=models.SET_NULL(CASCADE, PROTECT)后，当我们删除有副表关联的主表后，将副表中的主键设置为空，就不会抛出异常了

在`Django`中创建联合索引

索引是为了让我们的数据库查询速度变快的，索引是将两个字段合并使用一个索引，并且通过这一个索引进行查询

联合索引的创建方法（在models.py中进行创建一个内部类）：

from django.db import models

class User(models.Model):
    # id可以不用专门创建，数据库会自动进行创建
    id = models.IntegerField(primary_key=True)  # 设置为主键
    # unique 唯一索引，该值不允许重复; blank=Flase表示该值不允许为空
    username = models.CharField(unique=True, max_length=20, blank=Flase)
    age = models.SmallIntegerField(default=0)
    # db_index=True 设置普通索引，允许重复
    phone = models.SmallIntegerField(db_index=True, blank=True)
    email = models.EmailField(blank=True, default='')
    info = models.TextField()
    # auto_now_add=True创建时添加时间
    create_time = models.DateTimeField(auto_now_add=True)
    # 更新时变更时间auto_now=True
    update_time = models.DateTimeField(auto_now=True)
    
    
    # 创建联合索引
    class Meta:
        # # 唯一联合索引，值不能被重复
        # unique_together = ['day', 'hour']
        # 普通联合索引
        index_together = ['username', 'phone']
    
# 一对一表关系
class Userprofile(models.Model):
    id = models.IntegerField(primary_key=True)
    # on_delete=models.SET_NULL设置主表删除后副表不会报错，默认设置NULL，可以设置为NULL的前提是blank=True, null=True
    user = models.OneToOneField(User, blank=True, null=True, on_delete=models.SET_NULL)
    birthday = models.CharField(max_length=50, blank=True, default='')
    
# 一对多的表关系
class Userlog(models.Model):
    id = models.IntegerField(primary_key=True)
    # related_name='user_log' 表示设置别名
    user = models.ForeignKey(User, related_name='user_log', blank=True, null=True, on_delete=models.SET_NULL)
    content = models.TextField()
    create_time = models.DateTimeField()
    
# 多对多的表关系
# 多对多的表关系是不需要设置on_delete属性的
class Group(models.Model):
    id = models.IntegerField(primary_key=True)
    user = models.ManyToManyField(User, related_name='group')
    name = models.CharField(max_length=20)
    create_time = models.IntegerField(default=0)

声明多对多的关系表时，实际上在数据库中会创建三张表，两张联系的数据表之间还会有一个中间表，中间表中会存放userId和GroupId，通过用户的Id会去查询组里面相对的Id，中间表的作用就是为了方便查询

数据库的增删改查

首先需要创建一个简单的数据模型，在models.py中进行创建：

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=20)
    age = models.SmallIntegerField(default=0)
    
    def __str__(self):  # 时打印返回的对象为特定的键对应的值
        return self.username

在数据库表中插入数据，我们先在应用文件夹下的views.py中将编写的数据模型导入：

from djange.shortcuts import render
from .models import User
from django.views.generic import View

class UserInfo(View):
    def get(self, request):
        # 创建数据
        # 第一种创建数据插入方式
        User.objects.create(username='jlc', age=24)
        # 第二种创建数据的插入方式
        user = User(username='jlc', age=24)
        user.save()
        # 第三种创建数据的插入方式
        user = User()
        user.username = 'jlc'
        user.age = 24
        user.save()
        
        return render(request, 'UserInfo.html')
        # return render(request, 'UserInfo.html')可以不写，我们可以写return HttpResponse('successful')              注意需要先进行导入：from django.http import HttpResponse
        
        
        # 查询数据
        # 查询单个
        user = User.objects.get(id=1)
        return render(request, 'UserInfo.html', {'name': user.username})
        # 查询所有
        Users = User.objects.all()
        print(Users)  # 将查询的列表打印到控制台
        return render(request, 'UserInfo.html')
    
    	# 更新数据
        user = User.objects.filter(id=1).update(age=22)
        return render(request, 'UserInfo.html')
    
    	# 删除数据
        user = User.objects.get(id=3)
        user.delete()
        return render(request, 'UserInfo.html')

objects集成了数据库增删改查的所有方法

我们需要在根目录下创建一个templates文件夹，在文件中创建一个UserInfo.html页面文件

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
	{{ name }}
</body>
</html>

最后配置网站的子路由和总路由

启动后端，进入网页，刷新一下，就可以看到创建的数据已经填写到数据库中了

数据库查询的进阶

在增删改查中，数据库的查询往往是最为重要的

`ORM`的两种查询方式

原生sql的查询方法：users = User.objects.raw('select * from app_user')
该方法针对于比较复杂的查询方式，同时查询性能比较快，from后面跟的是表，查询到数据后，我们需要将接收的数据放到列表中进行打印展示print(list(users))
基于ORM方法查询：User.objects.filter(id=xx)
比较简单的查询方式，在开发中常用，其他基于ORM的常用查询方法：
- User.objects.all()：返回user表中的所有数据
- User.objects.get(**filter)：返回满足条件的数据（单条，没有数据则抛出异常）
- User.objects.filter(**filter)：返回满足条件的数据（多条，没有数据则抛出异常）
- User.objects.all()/filter().exists()：返回是否有对象，True False
- User.objects.all()/filter().count()：返回获取到对象的数量
- User.objects.all()/filter().exclude(**filter)：返回的数据中排除满足**filter的
- User.objects.filter().distinct('age')：返回的对象中通过某个列去重，如果有两个age为18的数据，会去掉一个重复的
- User.objects.filter().order_by('age')：返回的对象中通过age排序
- dir(User.objects)：查询其他方法

深入查询

属性名	描述	列举
`__exact`	类似于`sql`中的`like`精准查找方法	`name__exact='jlc'`
`__iexact`	精准查找且忽略大小写	`name__iexact='jlc'`
`__contains`	模糊查找(包括一个字的都列举出来)，类似`'like %jlc%'`	`name__contains='jlc'`
`__icontains`	模糊查找且忽略大小写	`name__icontains='jlc'`
`__gt`	大于条件的全部列出来	`age__gt=18`
`__gte`	大于等于条件的全部列出来	`age__gte=18`
`__lt`	小于条件的全部列出来	`age__lt=18`
`__lte`	小于等于条件的全部列出来	`age__lte=18`
`__isnull`	是否为空	`email__isnull=True`
`__startswith`	以什么开头	`name__startswith='make'`
`__istartswith`	以什么开头，且忽略大小写	`name__istartswith='make'`
`__endswitch`	以什么结尾	`name__endswith='make'`
`__iendswitch`	以什么结尾，且忽略大小写	`name__iendswith='make'`
`__in`	查询在表中的哪个数据	`name__in = ['jlc', 'make']`

或查询

或查询在网站开发时使用较多，搜索框的查找

from django.db import Q
# 满足两个条件的其中一种，全部列出来
user = User.objects.filter(Q(username='make') | Q(username='jlc'))

聚合查询

使用聚合查询时，我们需要导入几个包：

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

方法名	描述	列举
`Avg`	平均值	`User.objects.all().aggregate(Avg='age')`
`Sum`	求和	`User.objects.all().aggregate(Sum='age')`
`Max`	最大值	`User.objects.all().aggregate(Max='age')`
`Min`	最小值	`User.objects.all().aggregate(Min='age')`
`Count`	统计数量	`User.objects.all().aggregate(Count='age')`

多表查询值查询关联信息

通过对主对象选择需要查找的表对应的related_name，通过value查询具体信息：

user = User.objects.get(id=1)
user.diary.value('content') # 返回id为1的用户的diary的content信息
user.diary.count() # 返回id为1的用户的diary关联数量

反向查询

反向查询：当在user表中和diary表之间有所关联的时候，通过user模型借助diary关联的条件进行查找user

查找在diary表中id为2的这个对应的user：

user = User.objects.filter(diary__id=2)

user主表关联了diary从表，反向查找就是可以通过diary来查找user表相关的数据

`SQLAlchemy`

SQLAlchemy是Python中知名的ORM工具，有高效和高性能的数据库访问能力，实现了完成的企业级持久化模型，可以搭配任何一个Python的Web框架，其中比较出名的是Flask（多用于移动端的开发）

下载安装：pip install sqlalchemy

在根文件中创建一个sqlalchemy_test.py文件夹，导入相关的包，并创建数据表：

# 导入引擎和相关的字段类型(列，整形，字符串)
from sqlalchemy import create_engine, Column, Integer, String
# 导入数据库的增删改查模块
from sqlalchemy.orm import sessionmaker
# 导入初始化的模块
from sqlalchemy.ext.declarative import declarative_base

# 初始化数据库信息
Base = declarative_base()
engine = create_engine('mysql+pymysql://root:root@localhost:3306/user_sqlalchemy')
db_session = sessionmaker(bind=engine)

# 重写初始化方法
# 创建的方法
def init():
    Base.metadata.create_all(engine)

# 删除的方法
def drop():
    Base.metadata.drop_all()
    
# 创建表字段
class User(Base):
    __tablename__ = 'user'  # 创建表名
    # 填入相应的字段
    # 设置id为Integer类型，同时设置为主键和自动增长
    id = Column(Integer, primary_key=True, autoincrement=True) 
    name = Column(String(10))  # 设置为10位的字符串
    
if __name__ == "__main__":
    init()

常用的基础模块

declarative_base：初始化sql与模块化的基础模块（创建数据库对象）
Base = declarative_base()
create_engine：创建数据库引擎，连接数据库
engine = create_engine('mysql+pymysql://root:root@localhost:3306/sqlalchemy_test')
参数的解释：
- mysql：限定数据库的类型
- pymysql：限定数据库的引擎
- root:root@localhost:3306/sqlalchemy_test：用户名：密码@本地连接：端口号/数据库的名字
sessionmaker：数据插入/删除查询模块
db_session = sessionmaker(bind=engine)

常用类型

类型名	`python`类型	描述
`Integer`	`int`	常规整形，通常为32位
`SmallInteger`	`int`	短整形，通常为16位
`BigInteger`	`int`或`long`	精度不受限整形
`Float`	`float`	浮点数
`String`	`str`	可变长度字符串
`Text`	`str`	可变长度字符串，适合大量文本
`Bollean`	`bool`	布尔型
`Date`	`datetime.data`	日期类型
`Time`	`datetime.time`	时间类型

常用属性（列方法参数）

参数名	描述
`primary_key`	如果设置为`True`，则为该列表的主键
`autoincrement`	如果设置为`True`，则主键自增
`unique`	设置唯一索引
`index`	设置普通索引
`nullable`	是否允许为空
`default`	初始化默认值

插入和获取功能

在根目录下新建一个create_user_data.py文件，来实现对数据库表内容的插入和获取数据库内容：

from sqlalchemy_test import User  # 导入sqlalchemy_test.py文件中的类
from sqlalchemy_test import db_session # 导入增删改查模块

# 创建数据(向数据库添加数据)
user = User(name='jlc')
db_session.add(user)
db_session.commit() # 同步到数据库
db_session.close() # 关闭io流

# 数据获取
user = db_session.query(User).filter_by(name='jlc').one # 取一条数据
print(user.id)  # 获取这条数据的id

`Redis`在`Django`中的使用

Redis：是一个基于内存的非关系型数据库，它通过key:value的形式存储，有很多的数据结构（可以存储多种数据结构），如字符串，列表，集合等等

我们可以通过Redis进行数据缓存，防止底层数据库频繁IO，提升性能

通常将mysql数据库中的数据临时缓存到Redis中，用户访问网站的时候是通过Redis去读取值的（去Rsdis读取数据的速度是比去数据库中读取数据的速度快很多的），而不是去读取数据库中的值，去Redis中去读取数据可以提高网站的访问速度

在ubuntu中安装Redis：apt-get install redis-server

在ubuntu中启动Redis：redis-cli

输入后在命令行输入ping，如果返回PONG表示启动成功
查看当前的Redis有没有数据：get '1'，若返回(nil)表示没有缓存数据
退出Redis：exit

下载Redis相关的依赖：

pip install redis：python可以去控制Redis的包
pip install django-redis：django内部使用redis的一个依赖库

djando中配置redis：在settings.py中添加相关的参数（一般在DATABASES字段的下面）：

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379", # 当前Redis的地址
        "OPTIONS": {
            # 配置客户端
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            # 配置连接池，配置最大可以连接几个
            "CONNECTION_POOL_KWARGS": {"max_connections": 200},
            # 配置密码，默认是没有密码的
            "PASSWORD": "",
        }
    }
}

不依赖django配置redis

import redis
conn = redis.Redis(host='10.0.0.10', port=6379)

`Django`中使用`Redis`

在应用文件夹中的models.py文件中配置缓存装饰器

import json
from functools import wraps  # 关于装饰器的包
from django_redis import get_redis_connection # 连接redis的包
from django.db import models

# 编写缓存装饰器
_cache = get_redis_connection('default')
def cache(func):
    @wraps(func)   # 防止多次调用使函数名被修改
    # 实现方法
    def wrapper(obj, *args):
        key = args[0]
        value = _cache.get(key)
        # 判断缓存中是否有value，如果没有值就进行存储
        if value:
            return json.loads(value)  # 变成字典的格式
        rs = func(obj, *args)
        _cache.set(key, json.dumps(rs))  # 变成json格式 
        return rs
    return wrapper

# 创建数据模板
class User(models.Model):
    # id可以不用专门创建，数据库会自动进行创建
    id = models.IntegerField(primary_key=True)  # 设置为主键
    # unique 唯一索引，该值不允许重复; blank=Flase表示该值不允许为空
    username = models.CharField(unique=True, max_length=20, blank=Flase)
    age = models.SmallIntegerField(default=0)
    # db_index=True 设置普通索引，允许重复
    phone = models.SmallIntegerField(db_index=True, blank=True)
    email = models.EmailField(blank=True, default='')
    info = models.TextField()
    # auto_now_add=True创建时添加时间
    create_time = models.DateTimeField(auto_now_add=True)
    # 更新时变更时间auto_now=True
    update_time = models.DateTimeField(auto_now=True)
    
    # 联合索引
    class Meta:
        index_together = ['username', 'phone']
        
    def __str__(self):
        return self.username
    
    # 在模型类中添加一个类方法，@classmethod表示类方法
    @classmethod
    @cache
    def get(cls, id):
        # 提高上下文对象去获取数据库中对应的id中的值
        rs = cls.objects.get(id=id)
        return {
            'id': rs.id,
            'username': rs.username,
            'age': rs.age,
            'info': rs.info,
            'create_time': str(rs.create_time),
            'update_time': str(rs.update_time)
        }

`MongoDB`在`Django`中的使用

MongoDB：是一个分布式文件存储的数据库，由C++编写，为Web应用程序提供可扩展的高性能数据存储解决方案，MongoDB和Redis都是非关系型数据库

非关系型数据库：非关系型数据库被称之为NoSQL，意思是不仅仅是sql，强调key-value存储和文档数据库的优点，MongoDB是一个介于关系型数据库和非关系型数据库之间的产品

在ubuntu下安装MongoDB：

sudo apt install mongodb
mongod 启动mongodb服务器
mongo 启动客户端

简单使用

在命令行终端中先启动MongoDB客户端，在使用以下的命令

启动服务：mongod
启动客户端：mongo
查看数据库：show dbs
创建用户数据库：use user_message（如果不存在就创建一个，存在就进入
创建完数据库后，必须先插入一条数据，才能通过查看数据库命令显示这个数据库（才是真正的创建数据库）
插入数据：db.user.insert({'name': 'jlc'})
查看单条数据：db.user.findOne({'name': 'jlc'})
查看所有数据：db.user.find()

在`Django`中使用

使用python去控制MongoDB

需要下载一个依赖包：pip install pymongo
初始化和MongoDB建立连接：mongo_client = pymongo.MongoClient("mongodb://localhost:27017/")
使用数据库：mongo_db = mongo_client["dbs"]

在项目文件的settings.py中进行相关的配置：

from pymongo import MongoClient

# 配置Mongo客户端，Mongo的默认端口号是27017
MONGOCLIENT = MongoClient(host='localhost', port=27017)

在应用文件夹下创建一个.py文件mongo_models.py：

from django.conf import settings # 导入django的配置文件

# 连接到我们的MongoDB数据库，user_message是已经存在的数据库
conn = settings.MONGOCLIENT['user_message']

# 创建一个User类，连接数据库中的表
class User(object):
    db = conn['user']
   
	# 编写类方法
    # 插入字典数据类型的方法
    @classmethod
    def insert(cls, **params):
        return cls.db.insert(params)
    
    # 获取单条数据的方法
    @classmethod
    def get(cls, **params):
        return cls.db.find_one(params)
    
    # 获取多条数据的方法
    @classmethod
    def gets(cls, **params):
        return list(cls.db.find(params))  # 把对象转换成列表获取
    
    # 更新数据的方法，根据id找到这个值，再去进行更新
    @classmethod
    def get(cls, _id, **params):
        return cls.db.update({'_id': _id}, {'$set': params})

在根路径文件夹下使用python manage.py shell进入shell交互式环境

导入创建的User类：from app.monge_models import User
创建一个数据字典：data = {'_id': 123, 'name': 'jlc', 'age': 24}
传入数据到数据库：rs = User.insert(**data)
输入rs返回的是其id，及123
使用我们自定义的类方法：
- rs1 = User.get(_id=rs) 查看rs1 将_id=123的这条数据返回

通过`MongoDB`关联表的操作

我们需要先下载Mongo引擎：pip install mongoengine

在应用文件夹下去创建Mongo数据库的引擎，创建mongo_engine.py：

# 导入相关的包（连接，文档，字符串类型，整形类型，表关联）
from mongoengine import connect, Document, StringField, IntField, ReferenceField

# 创建一个数据库连接，原先没有这个数据库则会新建一个数据库，并连接
connect('test_mongo', host='localhost', port=27017)

# 创建类模型
# 创建第一张表的数据
class User(Document):
    name = StringField(required=True, max_length=20)
    age = IntField(required=True)
    
# 创建第二张表的数据
class Paper(Document):
    title = StringField(required=True, max_length=50)
    # 设置绑定关联
    user = ReferenceField(User)

在应用文件中的views.py编写视图模型

from django.shortcuts import render
from mongo_engine import User, Paper # 导入创建的数据模型
from django.http import HttpResponse
from django.views.generic import View

# 编写视图模型
class Mongo_User(View):
    def get(self, request):
        user = User.objects.create(name='jlc', age=24)
        paper = Paper(title='test', user=user) # 与user进行绑定
        paper.save()  # 从表需要进行保存一下
        rs = paper.objects.get(title='test')
        # 在控制台进行打印
        print(paper.user.name)
        # 网页中进行显示
        return HttpResponse('my name is {}, age is {}'.format(user.name, user.age))

配置路由和子路由

数据库交互 ​

在Ubuntu中安装MySQL数据库 ​

创建数据库 ​

ORM ​

Django中的ORM ​

settings.py中的数据库配置 ​

models.py的配置 ​

数据模型中的字段 ​

字符串与数字类型 ​

时间类型 ​

文件类型 ​

特殊类型属性 ​

公共属性 ​

编写数据模型 ​

数据库的表关系和联合索引的创建 ​

表关联的方法 ​

在Django中创建联合索引 ​

数据库的增删改查 ​

数据库查询的进阶 ​

ORM的两种查询方式 ​

深入查询 ​

或查询 ​

聚合查询 ​

多表查询值查询关联信息 ​

反向查询 ​

SQLAlchemy ​

常用的基础模块 ​

常用类型 ​

常用属性（列方法参数） ​

插入和获取功能 ​

Redis在Django中的使用 ​

Django中使用Redis ​

MongoDB在Django中的使用 ​

简单使用 ​

在Django中使用 ​

通过MongoDB关联表的操作 ​