ORM增删改查

转载 strawberry* 2019/10/8 21:28:13

或者框架中包括一个重要的部分,就是,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库,这极大的减轻了开发人员的工作量是“对象关系映射”的简称。执行流程​类对象y

orm

1.MVC或者MVC框架中包括一个重要的部分,就是ORM,它实现了数据模型与数据库的解耦,即数据模型的设计不需要依赖于特定的数据库,通过简单的配置就可以轻松更换数据库,这极大的减轻了开发人员的工作量

2.ORM是“对象-关系-映射”的简称。

3.执行流程

​ 类对象--->sql--->pymysql--->mysql服务端--->磁盘

​ orm其实就是将类对象的语法翻译成sql语句的一个引擎

​ orm语句 -- sql -- 调用pymysql客户端发送sql -- mysql服务端接收到指令并执行

img

django 连接mysql顺序

1 settings配置文件中

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',   # 引擎
        'NAME': 'day53',            # 数据库名称
        'HOST': '127.0.0.1',        # IP
        'PORT': 3306,               # 端口号
        'USER': 'root',         # 用户名
        'PASSWORD': '123'           # 密码
    }
}

2 项目文件夹下的init文件中写上下面内容,

​ 作用:用pymysql替换mysqldb(djnago自带的)

mysqldb 不能python3.4以上的版本

需要使用第三方模块pymysql进行替换

app01中的--init--文件

补充

MySQLdb的是一个接口连接到MySQL数据库服务器从Python
MySQLdb并不支持Python3.4之后版本
原因:
#python默认连接的MySQLdb并不支持Python3.4之后版本
解决办法:
#12使用第三方模块pymysql进行替换
import pymysql
pymysql.install_as_MySQLdb()

3 models文件中创建一个类(类名就是表名)

#引用一个模块 from django.db import models
class UserInfo(models.Model):
     id = models.AutoField(primary_key=True)
     name = models.CharField(max_length=10)
     bday = models.DateField()
     checked = models.BooleanField()
# 1  翻译成sql语句
# 2  django内置的一个sqlite客户端将sql语句发给sqlite服务端
# 3  服务端拿到sql,到磁盘里面进行了数据操作(create table app01_userinfo(id name...))

4.执行数据库同步指令,

添加字段的时候别忘了,该字段不能为空,所有要么给默认值,要么设置它允许为空 null=True

 #注意在每次增加字段时候都需要执行一遍这个方法
 python manage.py makemigrations#创建一个表记录
python版本号
 python manage.py migrate 执行记录

数据库问题mysql 更改时区和改变版本号mysql for 5.1

5 创建记录

(实例一个对象,调用save方法)

models.py

#创建一条记录,增
def query(request): 
    new_obj = models.UserInfo(
        id=2,
        name='子文',
        bday='2019-09-27',
        checked=1,

    )
    new_obj.save()  
    #翻译成sql语句,
    #然后调用pymysql,发送给服务端 
    相当于执行insert into app01_userinfo values(2,'子文','2019-09-27',1)

    return HttpResponse('xxx')

6.字段约束

通过选项实现对字段的约束,选项如下:

null:如果为True,表示允许为空,默认值是False。
blank:如果为True,则该字段允许为空白,默认值是False。
对比:null是数据库范畴的概念,blank是表单验证证范畴的。
db_column:字段的名称,如果未指定,则使用属性的名称。
db_index:若值为True, 则在表中会为此字段创建索引,默认值是False。
default:默认值。
primary_key:若为True,则该字段会成为模型的主键字段,默认值是False,一般作为AutoField的选项使用。
unique:如果为True, 这个字段在表中必须有唯一值,默认值是False。

配置数据库

python3 manage.py makemigrations   创建脚本
python3 manage.py migrate   迁移

创建app01中的--init--文件

class Book(models.Model):  #必须要继承的
    nid = models.AutoField(primary_key=True)  #自增id(可以不写,默认会有自增id AutoField是自增)
    title = models.CharField(max_length=32)
    publishDdata = models.DateField()  #出版日期
    author = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5,decimal_places=2)  #一共5位,保留两位小数

替换数据库的时候需要重新创建表记录

更改字段时候也需要

python36 manage.py makemigrations   创建脚本
python36 manage.py migrate  迁移

数据库的操作(django)

创建字段django特殊说明

1.字段的值默认是不为空的 需要手动设置 不然会报错

2.主键无需手动添加 自动生成id字段(主键)
3.引用模块from django.db import models

获取id字段的两种方式

1.表名.id
例
book.id
2.表名.pk
例
book.pk

增:

方式1:
    new_obj = models.UserInfo(#直接表名创建
        过程
        #1.先实例化产生对象,2.然后调用save方法保存
        id=2,
        name='子文',
        bday='2019-09-27',
        checked=1,

    )
    new_obj.save() 
方式2:
    # ret 是创建的新的记录的model对象(重点)
    ret = models.UserInfo.objects.create(
        name='卫贺',
        bday='2019-08-07',
        checked=0
    )

    print(ret)  #UserInfo object  
    print(ret.name)  #UserInfo object 
    print(ret.bday)  #UserInfo object

时间问题

models.UserInfo.objects.create(
        name='杨泽涛2',
        bday=current_date,
        # now=current_date,  直接插入时间没有时区问题
        checked=0
    )
    但是如果让这个字段自动来插入时间,就会有时区的问题,auto_now_add创建记录时自动添加当前创建记录时的时间,存在时区问题
now = models.DateTimeField(auto_now_add=True,null=True)
解决方法:
    settings配置文件中将USE_TZ的值改为False
    # USE_TZ = True
    USE_TZ = False  # 告诉mysql存储时间时按照当地时间来寸,不要用utc时间
使用pycharm的数据库客户端的时候,时区问题要注意

from django.db import models
简单查询:filter()  -- 结果是queryset类型的数据里面是一个个的model对象,类似于列表
    models.UserInfo.objects.filter(id=7).delete()  #queryset对象调用
    models.UserInfo.objects.filter(id=7)[0].delete()  #model对象调用

方式1:update
    # models.UserInfo.objects.filter(id=2).update(
    #     name='篮子文',
    #     checked = 0,
    #
    # )
    # 错误示例,model对象不能调用update方法
    # models.UserInfo.objects.filter(id=2)[0].update(
    #     name='加篮子+2',
    #     # checked = 0,
    # )
方式2 
    ret = models.UserInfo.objects.filter(id=2)[0]
    ret.name = '加篮子+2'
    ret.checked = 1
    ret.save()
    

更新时的auto_now参数
    # 更新记录时,自动更新时间,创建新纪录时也会帮你自动添加创建时的时间,但是在更新时只有使用save方法的方式2的形式更新才能自动更新时间,有缺陷,放弃
    now2 = models.DateTimeField(auto_now=True,null=True)

批量插入(bulk_create)

步骤
1.把查询的对象放入字典里一次性传入前端进行交互    
    # bulk_create
    obj_list = []
    for i in range(20):
        obj = models.Book(
            title=f'金瓶{i}',
            price=20+i,
            publish_date=f'2019-09-{i+1}',
            publish='24期出版社'
        )
        obj_list.append(obj)

    models.Book.objects.bulk_create(obj_list)  #批量创建

form表单提交之字典

request.POST --  querydict类型 {'title': ['asdf '], 'price': ['212'], 'publish_date': ['2019-09-12'], 'publish': ['asdf ']}
data = request.POST.dict() -- 能够将querydict转换为普通的python字典格式

创建数据
    models.Book.objects.create(
            ## title=title,  #title='asdf '
            ## price=price,  #price='212'
        ## publish_date=publish_date,
        #'publish_date': ['2019-09-12']
            ## publish=publish,
        #publish=['asdf ']
            **data#通过打散把键和值转换成以上数据
        )

查询api

筛选基本都是queryset类型

reservse 必须要排序才能反转

1.all()

查询对应表名的所有对象,结果是对象列表

结果为queryset类型

写法
models.表名.object.all()
例如
all_books = models.Book.objects.all()
数量过多会自动截断

2.filter条件查询

过滤出符合条件的数据

filter 条件查询
    ret = models.Book.objects.filter(title='金瓶7',publish='24期出版社') #相当于mysql数据库中and多条件查询
    查询条件不能匹配到数据时,不会报错,返回一个空的queryset,<QuerySet []>,如果没有写查询条件会获取所有数据,queryset类型的数据还能够继续调用fitler方法

3.get()

得到一个满足条件的model对象 有且只有一个

ret = models.Book.objects.get() #得到的是一个model对象,有且只能有一个
    1. 查不到数据会报错 :Book matching query does not exist.
    2. 超过一个就报错 :returned more than one Book -- it returned 13!

4.exclude()#排除

#除了这个之外
models.BOOK.objects.exclude(title__startswith=('金瓶'))
#model类型不能使用这个方法
1.object能够调用,models.Book.objects.exclude(title__startswith='金瓶')    
2.queryset类型数据能够调用,     models.Book.objects.all().exclude(title__startswith='金瓶')

5.order by()排序

models.Book.objects.all().order_by('-price','id')  
#sql语句写法 orderby price desc,id asc;
models类型不能使用
排序order by 加上-字段名 不加是升序

6.reverse() 反转

models.Book.objects.all().order_by('id').reverse()  #数据排序之后才能反转

7.count()

计数,统计返回结果的数量

models.Book.objects.all().count() 
sql语句 聚合函数

8.first()

类似于models.类名(表名).objects.filter(条件判断)[0]
models.类名(表名).objects.filter(条件判断).first()
#返回满足条件的第一条数据

返回第一条数据,结果是model对象类型

9.last()

返回最后一条数据,结果是model对象类型

ret = models.Book.objects.all().first()
ret = models.Book.objects.all().last()

10.exists()

判断返回结果集是不是有数据

models.Book.objects.filter(id=9999).exists() 
#有结果就是True,没有结果就是False

11.values

(返回的queryset类型,里面是字典类型数据)

12.values_list

(返回的queryset类型,里面是数组类型数据)

ret = models.Book.objects.filter(id=9).values('title','price') 
ret = models.Book.objects.all().values_list('title','price')
ret = models.Book.objects.all().values()
ret = models.Book.objects.values()  #调用values或者values_list的是objects控制器,那么返回所有数据 

13.distinct()

去重,配置values和values_list来使用,不能带有id 因为id默认唯一

models.Book.objects.all().values('publish').distinct()

filter双下划线查询

queryset类型 筛选出来的是queryset类型

get筛选出来一个是model对象

queryset 类型的方法可以多次调用使用

13个api能调用的函数和方法(重点)

    # ret = models.Book.objects.all().values('publish').distinct()
    # ret = models.Book.objects.filter(price__gt=35)  #大于
    # ret = models.Book.objects.filter(price__gte=35) # 大于等于
    # ret = models.Book.objects.filter(price__lt=35) # 小于等于
    # ret = models.Book.objects.filter(price__lte=35) # 小于等于
    # ret = models.Book.objects.filter(price__range=[35,38]) # 大于等35,小于等于38   # where price between 35 and 38
    # ret = models.Book.objects.filter(title__contains='金瓶') # 字段数据中包含这个字符串的数据都要
    # ret = models.Book.objects.filter(title__contains='金瓶')
    # ret = models.Book.objects.filter(title__icontains="python")  # 不区分大小写
    # from app01.models import Book
    # ret = models.Book.objects.filter(title__icontains="python")  # 不区分大小写
    # ret = models.Book.objects.filter(title__startswith="py")  # 以什么开头,istartswith  不区分大小写
    # ret = models.Book.objects.filter(publish_date='2019-09-15')

某年某月某日(对于日期的修改):
    ret = models.Book.objects.filter(publish_date__year='2018') 
    ret = models.Book.objects.filter(publish_date__year__gt='2018')#2018写数字也可以
    ret = models.Book.objects.filter(publish_date__year='2019',publish_date__month='8',publish_date__day='1')
    
找字段数据为空的双下滑线
    models.Book.objects.filter(publish_date__isnull=True) #这个字段值为空的那些数据

多表查询

多表是会为减少数据的冗余 加速查询的效率

models.字段类型()

表结构

rom django.db import models

# Create your models here.

class Author(models.Model):
    """
    作者表
    """
    name=models.CharField( max_length=32)
    age=models.IntegerField()
    #一对一 authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)  #
    #一对一
    au=models.OneToOneField("AuthorDetail",on_delete=models.CASCADE)

class AuthorDetail(models.Model):
    """
    作者详细信息表
    """
    birthday=models.DateField()
    telephone=models.CharField(max_length=11)
    addr=models.CharField(max_length=64)
    # class Meta:
        # db_table='authordetail' #指定表名
        # ordering = ['-id',]
class Publish(models.Model):
    """
    出版社表
    """
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)

class Book(models.Model):
    """
    书籍表
    """
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
    #一对多
                                                                                                            publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
    多对多
    authors=models.ManyToManyField('Author',)

注意事项

#重中之重 不要把表名和库名设置成一样的
1.不写字段默认外键默认连接id
2.创表默认创建主键 无需手动创建
3.oneto one 一对一#OneToOneField
4.id可以省略(自动连接另一个表的id字段(主键))
5.djnago1.0版本可以不写外键 默认级联删除
6.djnago2.0版本必须写on_delete=models.CASCADE
7.int类型不能进行模糊搜索 例如 电话去模糊匹配 前三位
字段名__startwith='151'
8.外键字段是赋值变量名=变量名_id
9.class AuthorDetail(models.Model) 创建表结构时 要继承 models.Model方法
完整版写法:
authorDetail=models.ForeignKey(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)  

class meta:

​   指定创建表时的源信息

​   ordering 排序

db contrations 去除强制约束效果

多对多关系

# 多对多没办法使用一个表的外键去设置
#多对多关系用第三张表存储关系
优点
存入字段数据少 数据库小 增加执行效率
1.manytomany #authors=models.ManyToManyField('Author',)

ManyToManyField不会加字段
book——author 一个表-另一个表
1.会生成一个表 字段会自己建立
2。一个字段是表名——id
3.下一个字段是另一个表——id
会自动创建 对应id字段,存入到一个属性中
使用方法
4.类名或者实例化对象(表名)去调用这个属性

一对一关系

#注意事项
1.如果两张表数据不统一 是表数据少的去连接数据多的(数据多的是主表)
2.如果数据统一 建哪个东西
sql语句 把外键变成unique(唯一)格式一样
authorDetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)  

多对一

1。对于外键不需要唯一性, 
2。不建立外键唯一(使用models.OneToOneField)建立外键

外键

1.完整版写法
authorDetail=models.ForeignKey(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)  

2.id可以省略(自动连接另一个表的id字段(主键))
publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
to=,to_field
#publishs是字段名
2.连接表的两种写法
第一种写法
to="加对应表名" 默认连接主键(id)
第二种写法
publishs=models.ForeignKey(to="Publish",on_delete=models.CASCADE,)
可以不写 直接写表名 但是如果加载在之后会报错因为没有预加载出来

admin使用超级管理员

1.连接数据库

注意要先连接数据库才能进入admin页面输入密码进行操作

创建与数据库之间的连接
1.在对应的app01 的models文件夹下创建好表,其中表包括(字段类型(约束大小限制)
    1.2外键的创建#需要注意的是1.1默认创建 2.0版本需要手动添加
        1.2.1 一对一创建外键约束 #属性名=OneToOneFlied(on_update=models.CASCADE)
                一对多创建外键约束# 属性名=foreignKey()
    也对就是对应的子程序的models
 2.创建表记录
3.在对应子程序中把python默认支持的mysqldb 替换成pymysql
原因mysqldb不支持3.4以上版本

2.创建超级管理员

写法 createsuperuser
两种写法
1.pycharm的一个控制台 
#1.manage.py@dbcont > createsuperuser#一开始显示这个 
使用createsuperuser创建管理员

2.python控制台
2.1python36 manage.py createsuperuser#创建超级管理员
2.2同理输入账号和密码 邮箱可以不用输入

创建数据(记录)

1.把models的表导入到admin
在对应app01(子程序中)的admin.py文件中
2.from django.contrib import admin
from app01 import models
admin.site.register(models.author)#格式 admin.site.reister(models.类名(表名))

增删改查

在对应子程序的view视图里写增删改查

注意要先引用models模块(对应的models.py文件)

增加

一对一

# 一对一
    # au_obj = models.AuthorDetail.objects.get(id=4)
    查询出对应的models对象 存入表类中


    models.Author.objects.create(
        name='海狗',
        age=59,
        # 两种方式
        au_id=4
        # au=au_obj
        #属性对应的值是对应的models对象
    )

一对多

与一对一的区别

对于连接字段没有唯一的约束

     pub_obj = models.Publish.objects.get(id=3)
    
     models.Book.objects.create(
         title='xx2',
         price=13,
         publishDate='2011-11-12',
         publishs=pub_obj, 
         #类属性作为关键字时,值为model对象
         publishs_id=3  
         # 如果关键字为数据库字段名称,那么值为关联数据的值
     )

多对多

多对多关系表记录的增加

 ziwen = models.Author.objects.get(id=3)
 haigou = models.Author.objects.get(id=5)

new_obj = models.Book.objects.create(
    title='海狗产后护理第二部',
    price=0.5,
    publishDate='2019-09-29',
    publishs_id=2,
)
new_obj是一个对象 
#第一种写法
new_obj.authors.add(对应外键字段的值)#对象.属性.方法名添加add
new_obj.authors.add(3,5) #*args  **kwargs
#添加的多个值用逗号隔开
new_obj.authors.add(*[3,5])  # 用的最多,
用法:
1.select 下拉框 的值是一个列表 使用name属性 查看对应value的值
2.多选的value值 是提交到后端是一个列表
3.使用*[value]打散#*[3,5]

#第二种写法 添加model对象
new_obj.authors.add(ziwen, haigou)
创建完字段之后要把对应的关系字段写到第三张表里

删除

一对一

models.AuthorDetail.objects.filter(id=3).delete()
models.Author.objects.filter(id=3).delete()

一对多

默认级联删除

关联的表是主表 主表删除子表的相对应的整条字段也被删除

models.Publish.objects.filter(id=3).delete()#Publish是主表
models.book.objects.filter(id=3).delete()

多对多

只操作对应第三张表
    book_obj = models.Book.objects.get(id=2)
    book_obj.authors.add()  # 添加
    book_obj.authors.remove(1)  #删除括号里对应的外键关联的id
    book_obj.authors.clear()  # 清除,筛选出的所有的对应外键关系字段
    book_obj.authors.set(['1','5'])  # 先清除对应外键关系字段再添加,相当于修改
    #易错点
    不是在原位置修改是删除这条对应记录,再去添加新纪录

    # 改
    ret = models.Publish.objects.get(id=2)
    models.Book.objects.filter(id=5).update(
         title='华丽丽',
         #publishs=ret,
         publishs_id=1,
     )
    两种方式
    publishs=ret#使用属性 对应的值是model对象
    publishs_id=1#对应的id值

基于对象的跨表查询

obj=models.Author.objects.get(name='王洋')和filter用法一样出来的类型不一样
obj=models.Author.objects.filter(name='王洋').first()

get和filter的区别

    1.filter筛选出来的是queryset对象需要转成model对象
    1.2如果是多个值 需要for循环取值转换
    写法
   a=models.Author.objects.filter()[0]
    a查询出来多个值 这样使用就只能查出一个
    需要for 循环取值
    2.get是对应的model对象 可以直接拿来用

反向查询和正向查询的区别

1.正向查询是创建外键关系的属性 在当前表中
    用法
        obj=models.Author.objects.get(name='王洋')
        obj.对应的外键属性名.字段名

2.反向查询是表中没有对应创建外键关系的属性
    用法·
        obj=models.Author.objects.get(name='王洋')
        obj.小写表名.字段名 #obj,表名找到对应表
    如果 查询东西多 
    1.需要用   注意:正向查和反向查有一些区别,当正相查结果为多个时,直接obj.对应的外键属性名.all()既可以,但是反向查有一些不同obj.小写表名_set.all()属性名(字段)_set.all() 
    取值
    2.使用 for循环列表进行对象取值
    举例
    obj=models.表名.objects.filter(name='子文')
    ret=obj.book_set.all()#查询出来的是个列表s
    for i in ret:
        print(i.title)
#注意:正向查和反向查有一些区别,当正相查结果为多个时,直接obj.对应的外键属性名.all()既可以,但是反向查有一些不同obj.小写表名_set.all()

一对一

# 一对一
     正向查询  对象.属性
     obj = models.Author.objects.filter(name='王洋').first()
     ph = obj.au.telephone
     print(ph)

    # 查一下电话号码为120的作者姓名
    # 反向查询  对象.小写的表名
     obj = models.AuthorDetail.objects.filter(telephone=120).first()
     ret = obj.author.name  #陈硕
     print(ret)

一对多

  
  
    # 查询
    # 一对多
    # 查询一下 海狗的怂逼人生这本书是哪个出版社出版的  正向查询
     obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
     ret = obj.publishs.name
     print(ret)  #24期出版社
    #  查询一下 24期出版社出版过哪些书
     obj = models.Publish.objects.filter(name='24期出版社').first()
    
     ret = obj.book_set.all() #<QuerySet [<Book: 母猪的产后护理>, <Book: 海狗的怂逼人生>]>
     for i in ret:
         print(i.title)

    

多对多

关于多对多正向反向查询的的解释

一句话概括
    是两个的表的关系属性在哪个表里(类) 不是外键字段存在哪个表
解释
    1.多对多需要建立在数据之上 因为没有数据的支持没办法建立外键,建立外键约束
    2.多对多采用把关系存在第三张表里
    3.基于对象的查询是根据属性查询 
    4.两个表的关系属性在哪个表里 哪个表就是正向查询

具体事例

# 多对多
如果post请求多个值使用getlist(字段)
写法
obj=request.POST.getlist("author_id")
#取得的是一个列表
    # 海狗的怂逼人生 是哪些作者写的 -- 正向查询
     obj = models.Book.objects.filter(title='海狗的怂逼人生').first()
     ret = obj.authors.all()#可以直接查询到作者对应的名字 (直接查询到)
    
     print(ret)  #<QuerySet [<Author: 王洋>, <Author: 海狗>]>
     for i in ret:
         print(i.name)

    # 查询一下海狗写了哪些书 -- 反向查询
     obj = models.Author.objects.filter(name='海狗').first()
     ret = obj.book_set.all()
     print(ret)
     for i in ret:
         print(i.publishs.name)
         print(i.title)
     return HttpResponse('ok')

上一篇:Mysql高手系列 - 第21篇:什么是索引?

下一篇:自己动手实现智能家居之温湿度数据采集存储(DHT11,MySql)

赞(0)

共有 条评论 网友评论

验证码: 看不清楚?
    扫一扫关注最新编程教程