13.Django之数据库models&orm初探（一）

1、使用django orm的准备操做。
django 默认支持sqlite，mysql, oracle,postgresql数据库。
在默认状况下django的项目中会默认使用sqlite数据库，在打开settings里有以下设置：

当咱们想改成mysql数据库时，须要在settings.py中作如下修改。
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'test_db', #数据库名称
'USER': 'root', #链接mysql时使用的用户名
'PASSWORD': '123456', #链接mysql使用的密码
'HOST': '127.0.0.1', #mysql的ip
'PORT': '3306', #链接mysql的端口。
}
}

当咱们把链接数据的配置设置完成后，从新启动django项目，这时会报错！
no module named MySQLdb
这是由于django默认你导入的操做mysql的模块是MySQLdb，但是MySQLdb对于py3有很大问题，因此咱们须要的模块是PyMySQL。

那么如何解决呢？
首先，要找到项目目录下的init.py文件。
而后在这个文件里面写两行代码：
import pymysql
pymysql.install_as_MySQLdb()
而后，这个报错就会解决。
（若是依旧报错。。。请检查你的pymsql是否有安装。。。）

2、在表（模型）建立以前，须要了解的概念。
首先咱们先来假定下面这些概念，字段和关系。

（1）一对一关系：
假如说，一个数据库有两张表，其中一个表是做者的名字，另一张表则是做者的详细信息。
第一张表中保存有做者的姓名，第二张表则保存了，做者的详细信息，性别，年龄，email等。
在这里，做者的名字和做者的详细信息就是一种一对一的关系，因此说，这种一对一的关系也不必拆分红两张表。

（2）多对多关系：
拿出版商进行举例，假如说出版商的数据在一张表中，这里面包含出名称，地址，所在城市，省，国家和网站。
书籍信息中包含的书名和出版日期，可是一本书，可能会有多个做者，可是一个做者又能够写多本书。
因此说，多对多的关系就好像做者与书籍之间的关系。

（3）一对多关系：
好比一本书只能被一个出版商出版，可是一个出版商能够出版不少本书，因此说，书籍对出版商来讲，就是一对多关系。
这种一对多的关系，也被称为外键。

3、关于表的建立。
models.py
class UserGroup(models.Model):
uid = models.AutoField(primary_key=True)
caption = models.CharField(max_length=32,unique=True)
ctime = models.DateTimeField(auto_now_add=True, null=True)
uptime = models.DateTimeField(auto_now=True, null=True)

class UserInfo(models.Model):

id列，自增，主键

# 用户名列，字符串类型，指定长度
# 字符串、数字、时间、二进制
username = models.CharField(max_length=32,blank=True,verbose_name='用户名')
password = models.CharField(max_length=60, help_text='pwd')
email = models.CharField(max_length=60)
test = models.EmailField(max_length=19,null=True,error_messages={'invalid': '请输入密码'})
#user_group_id 数字
user_group = models.ForeignKey("UserGroup",to_field='uid') # (uid,catption,ctime,uptimew)
user_type_choices = (
    (1, '超级用户'),
    (2, '普通用户'),
    (3, '访客'),
)
user_type_id = models.IntegerField(choices=user_type_choices,default=1)

上面这段代码，每一个数据模型都是django.db.models.Model的子类，它的父类Model包含了全部必要的和数据库交互的方法。
其次每一个模型至关于单个数据库表（多对多关系例外，会多生成一张关系表），每一个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）至关于数据库的字段类型（例如varchar）。你们能够留意下其它的类型都和数据库里的什么字段对应。

而后在仔细思考下，前面说的到的三种关系：
分别是一对一，一对多，多对多。
一对一：实现一对一的本质，就是在外键，（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；

一对多：就是主外键关系；（foreign key）

多对多：自动建立第三张表(固然咱们也能够本身建立第三张表：两个foreign key。

4、orm之基本的增删改查。
（1）增：
from app01.models import *

#create方式一: Author.objects.create(name='kodakumi')

#create方式二: Author.objects.create(**{"name":"hamasakiayumi"})

！！注意！当使用到mysql innodb的事物特性的时候，就要使用save的方式插入记录了。！！

#save方式一: author=Author(name="amuro")
author.save()

#save方式二: author=Author()
author.name="amuro"
author.save()

（2）删：
models.UserInfo.objects.filter(username="amuro").delete()

（3）改：
models.UserInfo.objects.filter(id=3).update(password="130")

--------------- save方法---------
obj=models.UserInfo.objects.filter(id=3)[0]
obj.password = '130'
obj.save()

(4)查：

#result = models.UserInfo.objects.all() #列出表全部记录，返回一个QuerySet类型。

！！在这里简单介绍一下什么是Queryset类型！
在这里，咱们能够把Queryset理解为一个列表，这个列表中有不少对象，每一个对象就是数据库中的每一条数据！！

#result = models.UserInfo.objects.filter(username='root',password='123') #按条件查询
    查询相关API以下：
    【1】filter(**kwargs):      它包含了与所给筛选条件相匹配的对象。
    filter方法的参数补充：
    #在这以age列作例子：
    age_gt = 1 #age大于1的。
    age_lt = 1 #age小于1的。
    age_lte = 1 #age小于等于1
    age_gte = 1 #age大于等于1
    age_in = [1,2,3] # 找出age为1或2或3的（只要列表中有的就能够）
    age_range = [1,2]#age为这个范围的。
    age_startwith = 'xxx' #age列以xxx开头的
    age_contains = 'xxx' #包含xxx的。
    【2】all():                 查询全部结果。
    【3】get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，若是符合筛选条件的对象超过一个或者没有都会抛出错误。

#===============================#
下面是对查询结果进行处理的API
【1】values(field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列 model的实例化对象，而是一个可迭代的字典序列.
须要特别注意！！values这个方法能够用来分组！！

values 能够取表中全部记录中的某一个或多个列的数据。
例如：
v1 = models.UserInfo.objects.values('name') #select UserInfo.name from UserInfo
print (v1.query) #获取到生成的sql语句。
select app01_UserInfo.name from UserInfo

！！经过values方法而后经过.annotate进行组合！
from django.db.models import Count
v2 = models.UserInfo.objects.values('name').annotate(count_num=Count('id'))
print (v2.query)
#select 'app01_UserInfo'.'id',COUNT('app01_UserInfo'.id) as "count_num" from "app01_UserInfo" group by 'app01_UserInfo'.id'

！！组合后的查询结果，还能够经过filter方法来进行筛选！

from django.db.models import Count
v2=models.UserInfo.objects.values('name').annotate(count_num=Count('id')).filter(count_num = 2)
!#筛选出count_num = > 2 的记录。
print (v2.query)
#select 'app01_UserInfo'.'id',COUNT('app01_UserInfo'.id) as "count_num" from "app01_UserInfo" group by 'app01_UserInfo'.id' having count （'app01_UserInfo'.id'）> 2
#!也就是说把filter放在后面，出现的是sql语句中的having！！

【2】order_by(*field):      对查询结果排序。
例：
user_list = models.UserInfo.objects.all().order_by('id') #以id列为基准从小到大排序。
user_list = models.UserInfo.objects.all().order_by('-id') #以id列为基准从大到小逆向排序。
    user_list = models.UserInfo.objects.all().order_by('-id'，'name') #以id列为基准从大到小逆向排序，当id列有值重复时，按照name从小到大排序。

【3】reverse() ：对查询的结果进行反向排序。
【4】distinct(): 从结果中删除重复的记录。
【5】values_list(*field): 它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列。
【6】count(): 返回数据库中匹配查询(QuerySet)的对象数量。
【7】first(): 返回第一条记录
【8】last(): 返回最后一条记录
【9】exists(): 若是QuerySet包含数据，就返回True，不然返回False。

单表条件查询：
models.Tb1.objects.filter(id=10,name='test') #找出id=10 而且name字段为test的记录 。
！########下面是神奇的双(下划线)！########
models.Tb1.objects.filter(idlt=10, idgt=1) # 获取id大于1 且 小于10的值
models.Tb1.objects.filter(idin=[11, 22, 33]) # 获取id等于十一、2二、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in

是否为空：
Entry.objects.filter(pub_date__isnull=True)

5、经过外键来实现一对多的示例：
models.py
class Business(models.Model):
#id
caption = models.CharField(max_length=32)

class Host(models.Model):
nid = models.AutoField(primary_key=True)
hostname = models.CharField(max_length=32,db_index=True)
ip = models.GenericIPAddressField(protocol='ipv4',db_index=True)
port = models.IntegerField()
busi = models.ForeignKey(to='Business',to_field='id')#建立外键，这个外键以表Business的id字段为准。
不过须要注意的是，这个busi变量的内容不是某个值，而是一个特殊对象，能够经过这个对象去取到Business表中对应id的记录。！！

当建立好外键关系后，在 Business表中插入了三条数据：
+----+-----------+
| id | caption |
+----+-----------+
| 1 | 运维部 |
| 2 | 开发部 |
| 3 | 测试部 |
+----+-----------+

而后在host表中插入四条主机信息：
+-----+----------+---------------+------+---------+
| nid | hostname | ip | port | busi_id |
+-----+----------+---------------+------+---------+
| 1 | host1 | 192.168.100.1 | 80 | 1 |
| 2 | host2 | 192.168.100.5 | 80 | 1 |
| 3 | host3 | 192.168.100.6 | 80 | 2 |
| 4 | host4 | 192.168.100.7 | 80 | 2 |
+-----+----------+---------------+------+---------+

这时，使用django orm进行联表查询：
views.py:

def host(request):
h1 = models.Host.objects.all()
for row in h1:
print(row.nid,row.hostname,row.ip,row.busi.caption)
return HttpResponse('host')
#busi 带只了另一张表的一行数据，这就是外键的特性！
结果以下：
1 host1 192.168.100.1 运维部
2 host2 192.168.100.5 运维部
3 host3 192.168.100.6 开发部
4 host4 192.168.100.7 开发部

6、关于F,Q
F：当要对数据库记录作修改的时候，能快速获取到上一个值，来进行操做。
好比：
models.UserInfo.objects.all().update(age=F('age')+1)

Q:用于复杂的条件查询，Q对象(django.db.models.Q)能够对关键字参数进行封装，从而更好地应用多个查询。能够组合使用 &（and）,|（or），~（not）操做符，当一个操做符是用于两个Q的对象,它产生一个新的Q对象。
例如：
用法1：
models.UserInfo.objects.filter(Q(id=1)|Q(id__gt=2))
##查找出id为1或者2的记录。

用法2：直接建立一个Q对象。
q1 = Q( ) #首先建立一个Q对象。
q1.connector = 'OR' #Q对象中的查询条件的链接方式。
q1.children.append(('id',1))
q1.children.append(('id',2)) #在Q1这个对象里添加两个查询条件。

更复杂的条件嵌套。
q1 = Q( )
q1.connector = 'OR'
q1.children.append(('id',1))
q1.children.append(('id',2))

q2 = Q( )
q2.connector = 'OR'
q2.children.append(('name','ayu'))
q2.children.append(('name','hamasaki'))

con = Q( )con.add(q1,'AND')con.add(q2,'AND')#最后生成的结果是(id=1 or id=2) and (name=ayu or name=hamasaki)