Django之数据库对象关系映射

Django ORM基本配置

到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：

创建数据库，设计表结构和字段
使用 MySQLdb 来连接数据库，并编写数据访问层代码
业务逻辑层去调用数据访问层执行数据库操作

django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM），django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表；

1、修改project数据库配置（程序主目录下的settings.py文件）

默认连接数据库为本地文件sqlite3：

DATABASES = {
    \'default\': {
        \'ENGINE\': \'django.db.backends.sqlite3\',
        \'NAME\': os.path.join(BASE_DIR, \'db.sqlite3\'),
    }
}

更换为指定的mysql数据库：

DATABASES = {
    \'default\': {
        \'ENGINE\': \'django.db.backends.mysql\',
        \'NAME\': \'mysite\',   #一定要存在的数据库名
        \'USER\': \'xxxx\',
        \'PASSWORD\': \'xxx\',
        \'HOST\': \'192.168.xx.xx\',
        \'PORT\': \'3306\'
    }
}

2、创建定义数据库表结构文件（对应app目录下的models.py文件）

生成一个简单的数据库表：

from django.db import models

# Create your models here.

class UserInfo(models.Model):

    username = models.CharField(max_length=32)
    passwd = models.CharField(max_length=64)

把对应的app名称加入到settings.py文件配置里：

INSTALLED_APPS = [
    \'django.contrib.admin\',
    \'django.contrib.auth\',
    \'django.contrib.contenttypes\',
    \'django.contrib.sessions\',
    \'django.contrib.messages\',
    \'django.contrib.staticfiles\',
    \'cmdb02\',
]

3、生成数据库表

执行下面命令：

python manage.py  makemigrations
python manage.py  migrate         # 生成数据表

注意：Django默认用的MysqlDB模块连接数据库，但在python3.x里面还没有这个模块，所有需要把连接数据库的模块改成pymsyql，修改project目录下的init.py文件

import  pymysql
pymysql.install_as_MySQLdb()

执行生成数据库表命令，遇到的问题：

a. django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.13 or newer is required; you have 0.9.3.

解决：找到 python_path\Lib\site-packages\django\db\backends\mysql路径下的base.py，注释以下代码：

b. AttributeError: \'str\' object has no attribute \'decode\'

解决：找到 python_path\Lib\site-packages\django\db\backends\mysql路径下的operations.py，修改以下代码：

query = query.encode(errors=\'replace\') 将decode修改为encode

c. pymysql.err.InternalError: (1049, "Unknown database \'mysite\'")

解决：数据库创建数据库 mysite

django数据库增删改查，可以直接运行python文件，具体配置如下：

新建python文件，设置django的配置：

import django, os
os.environ.setdefault(\'DJANGO_SETTINGS_MODULE\', \'dj_test.settings\')  #设置django的配置文件
django.setup()

from user import models
from django.db.models import Q

#新增
# models.Nav.objects.create(name=\'哈哈哈\')

# 对象实例化
# nav = models.Nav(name=\'我的心情\')
# nav.save()

4. Django数据库单表操作

1. 增加：

第一种写法：

def ormadd(request):
    UserInfo.objects.create(username=\'root\',passwd=\'123456\')
    return HttpResponse(\'orm add\')

第二种写法：

def ormadd(request):
    dicts = {\'username\': "xiaoxiao", \'passwd\': \'666666\'}
    UserInfo.objects.create(**dicts)
    return HttpResponse(\'orm add\')

第三种写法：

def ormadd(request):
    userinfo = UserInfo(username=\'sb2\',passwd=\'123456\')
    userinfo.save()
    return HttpResponse(\'orm add\')

2.删除数据

def ormdel(request):
    UserInfo.objects.filter(id=19).delete()
    return HttpResponse(\'orm dele\')

3.更新数据

第一种写法：

def ormadd(request):
    UserInfo.objects.filter(id__gt=10).update(username=\'white\')  
  #id大于10的数据，更新name为101
    return HttpResponse(\'orm update\')

第二种写法：

def ormadd(request):
    dicts ={\'username\': \'black\'}
    UserInfo.objects.filter(id__gt=10).update(**dicts)
    return HttpResponse(\'orm update\')

4.查询数据

查询所有的数据

def ormadd(request):
    res = UserInfo.objects.all() #QuerySet类型，列表里每个元素都是obj对象
    print(res) # <QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>
    for row in res:
        # 1 root 123456
        # 2 admin 123123
        print(row.id, row.username, row.passwd)
    return HttpResponse(\'orm select\')

　　2.查询指定字段

def ormadd(request):
    res = UserInfo.objects.filter(username=\'root\')  #过滤后，结果为list
    #res = UserInfo.objects.filter(id=3)  #根据id查询
    new_res = {}
    if res:
        for row in res:
            new_res[\'id\'] = row.id
            new_res[\'username\'] = row.username
            new_res[\'passwd\'] = row.passwd
        return render(request, \'login.html\', {\'new_res\':new_res})

tmplate页面数据显示：

　　3. 获取查询第一条数据和统计匹配个数

def ormadd(request):
    #获取匹配的第一条数据
    obj = UserInfo.objects.filter(username=\'root\').first()
    #获取匹配的字段个数
    c = UserInfo.objects.filter(username=\'root\').count()
    return render(request, \'login.html\', {\'obj\': obj, \'c\': c})

template页面数据显示:

4. 比较值查询及多条件查询

def ormadd(request):
    UserInfo.objects.filter(id=3, username=\'root\')  #id=1 且 name=root
    UserInfo.objects.filter(id__gt=1, username=\'root\') #id>1 且 name=root
    UserInfo.objects.filter(id__lt=1) #id<1
    UserInfo.objects.filter(id__gte=1)  #id>=1
    UserInfo.objects.filter(id__lte=1)  #id<=1
    UserInfo.objects.filter(username__contains=\'root\') #模糊查询
    UserInfo.objects.filter(id__range=(1,3)) #在什么范围
    UserInfo.objects.filter(id__in=[1,2,3,4,5,6]) #在什么范围
    UserInfo.objects.exclude(id=1)  #排除id=1的数据
from django.db.models import Q 
    UserInfo.objects.filter(Q(username__contains=\'root\')|Q(id__gte=1))  #username包含root 或者 id>=1的数据 或者关系

5.外键反向查询

#导航表结构
class Nav(models.Model):
    name = models.CharField(max_length=64, unique=True, verbose_name=\'导航名称\')
    is_delete = models.SmallIntegerField(default=1,verbose_name=\'是否被删除\')  #0已删
    create_time = models.DateTimeField(verbose_name=\'创建时间\',auto_now_add=True) #插入数据自动转换为当前时间
    update_time = models.DateTimeField(verbose_name=\'更新时间\', auto_now=True)   #修改时间自动转换为当前时间

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = \'导航表\'
        verbose_name_plural = verbose_name
        db_table = \'nav\'   #指定表名
        # ordering=[\'create_time\']   #查询数据时，默认按照 某个字段排序

#文章表结构
class Article(models.Model):
    title = models.CharField(max_length=20, verbose_name=\'文章名称\')
    content = models.TextField(verbose_name=\'文章内容\',null=True)
    img = models.ImageField(upload_to=\'article_img\',verbose_name=\'文章图片\',null=True)  #指定上传到哪个目录下
    nav = models.ForeignKey(Nav,verbose_name=\'导航表\',on_delete=models.DO_NOTHING,db_constraint=False)  #外键，对应导航表的数据删除后,该表不需要删除； db_contraint不建立真正的外键关系
    is_delete = models.SmallIntegerField(default=1, verbose_name=\'是否被删除\')
    create_time = models.DateTimeField(verbose_name=\'创建时间\', auto_now_add=True)  # 插入数据自动转换为当前时间
    update_time = models.DateTimeField(verbose_name=\'更新时间\', auto_now=True)  # 修改时间自动转换为当前时间

    def __str__(self):
        return self.title

    class Meta:
        db_table=\'article\'


#外键反向查询
nav = models.Nav.objects.get(name=\'python\')
res_a = nav.article_set.all()  #查导航下所有的文章
print(res_a)

6. 多对多关联表结构

表设计：

from django.db import models
from utils import tools
from earth import settings


class BaseModel(models.Model):
    \'\'\'公共字段\'\'\'
    is_delete_choice = (
        (0, \'删除\'),
        (1, \'正常\')
    )
    is_delete = models.SmallIntegerField(choices=is_delete_choice, default=1, verbose_name=\'是否被删除\')
    create_time = models.DateTimeField(verbose_name=\'创建时间\', auto_now_add=True)  # auto_now_add的意思，插入数据的时候，自动取当前时间
    update_time = models.DateTimeField(verbose_name=\'修改时间\', auto_now=True)  # 修改数据的时候，时间会自动变

    class Meta:
        abstract = True  # 只是用来继承的,不会创建这个表


class Author(BaseModel):
    name = models.CharField(verbose_name=\'名称\', max_length=20)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = \'作家\'
        verbose_name_plural = verbose_name
        ordering = [\'id\']
        db_table = \'eg_author\'


class Book(BaseModel):
    name = models.CharField(verbose_name=\'书名\', max_length=20)
    price = models.FloatField(verbose_name=\'价格\')
    count = models.IntegerField(verbose_name=\'数量\')
    # author = models.ForeignKey(Author, on_delete=models.DO_NOTHING, db_constraint=False, verbose_name=\'作者\')
    author = models.ManyToManyField(Author,  verbose_name=\'作者\')  #多对多关联， 1个作者可以有多本书； 1本书可以有多个作者翻译

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = \'书籍\'
        verbose_name_plural = verbose_name
        ordering = [\'id\']
        db_table = \'eg_book\'

model_test.py，多对多关联查询(正向、反向)

import django,os
os.environ.setdefault(\'DJANGO_SETTINGS_MODULE\', \'earth.settings\')  #设置django的配置文件
django.setup()

from example import models

#新增作者
models.Author.objects.create(name=\'dsx\')
models.Author.objects.create(name=\'niuniu\')

#新增书
models.Book.objects.create(name=\'自动化1\',price=18,count=2)
models.Book.objects.create(name=\'自动化2\',price=18,count=3)
models.Book.objects.create(name=\'自动化3\',price=18,count=4)

#获取2张表的数据
a1 = models.Author.objects.filter(id=4).first()
a2 = models.Author.objects.filter(id=5).first()
b1 = models.Book.objects.filter(id=9).first()
b2 = models.Book.objects.filter(id=10).first()

#创建多对多关系，以Book表为基础
b1.author.add(a1)
b1.author.add(a2)
b2.author.add(a1)
b2.author.add(a2)

#多对多关系查询，正向查询
a = b1.author.all()   #b1这本书对应的作者,正向查询
print(a)

#反向查询
b = a1.book_set.all() # 根据a1作者查询有几本书，反向查询
print(b)

#解除多对多关系
b1.author.remove(a1) #解除书1与作者1的关系

#清除关系
b2.author.clear()  #清除b2这本书对应的所有作者

django 分页：

from django.core.paginator import Paginator
#整体分页功能
m = list(range(100))
page_obj = Paginator(m,20)
print(page_obj.count)   #总共多少数据
print(list(page_obj.get_page(1)))  #获取第几页数据
print(page_obj.num_pages)   #总共分几页 ，100/20 = 5页
print(page_obj.page_range)   #分页范围，默认分页范围

#某页的功能
page1 = page_obj.get_page(1)
page1.has_next()  #判断是否有下一页
page1.has_other_pages()  #是否有其他页
page1.has_previous() #是否有上一页
page1.next_page_number() #下一页的页数
page1.previous_page_number()  #上一页页码
page1.end_index()   #末尾页
page1.start_index()  #首页

page1.number  #当前页码

 page1.paginator #获取分页对象

django查询count、group_by功能

  SQL：select  department,count(*)  from  EmployeeInfo  group  by  department;

 from django.db.models import Count

result = EmployeeInfo.objects.values(\'department\').annotate(Count=Count(\'department\')).order_by()

#例子：

html:

{% block pagination %}
{#    判断是否有其他分页#}
    {% if artciles.has_other_pages %}   
    <div>
        <ul class="pagination">
{#        判断是否有上一页#}
        {% if artciles.has_previous %}
          <li><a href="/index/?limit={{ page_limit }}&page={{ artciles.previous_page_number }}">«</a></li>
        {% endif %}

{#        分页范围#}
            {% for num in artciles.paginator.page_range %}
                {% if num == artciles.number %}
                    <li><a class="active" href="/index/?limit={{ page_limit }}&page={{ num }}">{{ num }}</a></li>
                {% else %}
                    <li><a href="/index/?limit={{ page_limit }}&page={{ num }}">{{ num }}</a></li>
                {% endif %}
            {% endfor %}

{#        判断是否有下一页#}
        {% if artciles.has_next %}
          <li><a href="/index/?limit={{ page_limit }}&page={{ artciles.next_page_number }}">»</a></li>
        {% endif %}
        </ul>
    </div>
    {% endif %}
{% endblock %}

View Code

view 代码：

def index(request):
    limit = request.GET.get(\'limit\', page_limit)
    page = request.GET.get(\'page\', 1)

    artciles = models.Article.objects.all().order_by(\'id\')  #查mysql
    page_obj = Paginator(artciles, limit)   #对文章进行分页， （7,2）
    page_data = page_obj.get_page(page)     #获取某页数据
    return render(request, \'index.html\', {\'artciles\':page_data})