ORM增删改查

目录

  • orm

    • django 连接mysql顺序

      • 1 settings配置文件中
      • 2 项目文件夹下的init文件中写上下面内容，
      • 补充
      • 3 models文件中创建一个类（类名就是表名）
      • 4.执行数据库同步指令,
      • 5 创建记录
      • 6.字段约束
    • 数据库的操作（django）
      • 增:
      • 时间问题
      • 删
      • 改
      • 批量插入(bulk_create)
      • form表单提交之字典
      • 查询api
      • filter双下划线查询
    • 多表查询
      • 表结构
      • 注意事项
      • 多对多关系
      • 一对一关系
      • 多对一
      • 外键
    • admin使用超级管理员
      • 1.连接数据库
      • 2.创建超级管理员
      • 增删改查
      • 增加
      • 删除
      • 改
      • 基于对象的跨表查询
      • 一对一
      • 一对多
      • 多对多

orm

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

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

3.执行流程

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

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

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

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的一个控制台
#[email protected] > 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')

原文地址：https://www.cnblogs.com/strawberry-1/p/11632693.html

时间： 2024-10-24 11:17:19

ORM增删改查的相关文章

3.django模板，单表ORM增删改查

1.Django模板语法 模板语法: 变量: {{}} 1 深度查询 句点符 2 过滤器 {{val|filter_name:参数}} 标签: {% %} 1.1Django模板使用 from django.shortcuts import render import datetime def index(request): now = datetime.datetime.now() return render(request,"index.html",{"current_t

Django 自带的ORM增删改查

通过Django来对数据库进行增删改查 1 首先创建类,在app应用程序里面的model模块里面创建类,写好数据库信息,方便我们待会初始化: 2 创建在django项目里面的settings里面添加app程序()在settings里面的INSTALLED_APPS里面) 3  python manage.py makemigrations     python manage.py migrate 拿models里面的一个类举例: class WebGroup(models.Model): nam

Django框架（三）-- orm增删改查、Django生命周期

一.orm介绍 1.什么是orm ORM即Object Relational Mapping,全称对象关系映射. 2.使用orm的优缺点 优点: 不用写SQL语句 开发效率高 缺点: SQL的效率低 3.使用orm 如果连接的是pycharm默认的Sqlite,不用改动,使用默认配置即可 如果连接mysql,需要在配置文件中的setting中进行配置: 将DATABASES={} 更新为 DATABASES = { 'default': { 'ENGINE': 'django.db.backen

Django ORM增删改查

ORM操作是通过类来操作的, 类通常是定义的表格 增加有三种方式: 方式一: models.User.objects.create( #表示对表User操作 username= "root", #属性列都写进去 password= "123", ) 方式二: obj = models.User( username= "WSX", password= "123") obj.save() 方式三: 将一个字典传进去,需要在其前面加

ORM增删改查(django)

单表操作: 一.添加 (1)方式一 from  mysite.models  import * def  add(request): book= Book(name="python",price=99,author="python作者") book.sava() return  HttpResponse("书籍信息添加成功") (2)方式2 def  add(request): book= Book.objects.create(name=&qu

SQLAlchemyの增删改查

用a*my写原味sql from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy import create_engine Base = declarative_base() # 创建单表 class Users(Base): __tablename__ = 'users' id = Column(Integer, p

ORM 实现数据库表的增删改查

这次通过反射技术来实现一下数据库表的增删改查对象关系映射(英语:Object Relational Mapping,简称ORM,或O/RM,或O/R mapping) 注:引用时约束了以下几点: 数据库表的表名与类的类名一致 数据库字段名和类字段名一致 自增字段的访问权限为private其余字段都为public 注:如果用的是MySql数据库,有提供好的MySqlhelper非MySql数据库可以参考我写好的SqlHelper SqlHelper参考位置:http://www.cnblogs.c

使用轻量级ORM Dapper进行增删改查

  项目背景 前一段时间,开始做一个项目,在考虑数据访问层是考虑技术选型,考虑过原始的ADO.NET.微软的EF.NH等.再跟经理讨论后,经理强调不要用Ef,NH做ORM,后期的sql优化不好做,公司也没有人对EF,Nh 等orm优化比较熟悉的.强调说的,我们的项目要做的得简单,可以使用ADO.NET 写原始的sql.但我自己还是喜欢ORM的,它可以提高数据访问层的开发.有一天,在订阅张善友 doNet跨平台微信公众号里,看到Dapper的推荐.了解之后,我自己喜欢喜欢Dapper,可以满足我这

django 利用ORM对单表进行增删改查

牛小妹上周末,一直在尝试如何把数据库的数据弄到界面上.毕竟是新手,搞不出来,文档也看不懂.不过没关系,才刚上大学.今晚我们就来解释下,要把数据搞到界面的第一步.先把数据放到库里,然后再把数据从库里拿出来. 以下内容,参考django官方文档 . 1.创建MODEL 这里和官方文档一致.直接拷出来,放到一个叫models的py文件里面.若是你的项目中没有,一定不要觉得无处写代码.你自己建一个即可 同步数据库: 执行以下命令.不懂的可以参考:django连接mysql python manage.p