ORM操作mysql数据库

Posted 2022-12-22 luckinlee

orm介绍

#ORM是“对象-关系-映射”的简称。（Object Relational Mapping，简称ORM）
#类对象--->sql--->pymysql--->mysql服务端--->磁盘，orm其实就是将类对象的语法翻译成sql语句的一个引擎
orm语句 -- sql -- 调用pymysql客户端发送sql -- mysql服务端接收到指令并执行

连接数据库

1#在django项目的配置文件中,修改链接数据库的配置,django默认链接自带数据库sqllite3,改成链接mysql数据库
    DATABASES = 
        'default': 
            'ENGINE': 'django.db.backends.mysql',#申明链接mysql
            'NAME':'orm01',     # 要连接的数据库，连接前需要创建好
            'USER':'root',      # 连接数据库的用户名
            'PASSWORD':'123456',# 连接数据库的密码
            'HOST':'127.0.0.1',  #IP地址
            'POST':3306,    #端口号
        
        'app01':  #可以为每个app都配置自己的数据，并且数据库还可以指定别的，也就是不一定就是mysql，也可以指定sqlite等其他的数据库
            'ENGINE': 'django.db.backends.mysql',
            'NAME':'bms',     　　 　  # 要连接的数据库，连接前需要创建好
            'USER':'root',　　　　　　  # 连接数据库的用户名
            'PASSWORD':'',　　　　　　  # 连接数据库的密码
            'HOST':'127.0.0.1',       # 连接主机，默认本级
            'PORT'：3306    　　　     #  端口 默认3306
        
 
2:#在项目的文件夹中的init文件中,申明使用pymysql模块链接mysql服务端,django默认使用mysqldb链接数据库服务端,mysqldb并不支持python3.4以上版本,用pymysql替换mysqldb;
    import pymysql
    pymysql.install_as_MySQLdb()
3:#在应用的models文件中新建一个类:
    from django.db import models
    #类名就是新建的表的表名,orm要求每一个表中都必须有一个主键,没有设置就自动生成一个自增主键,叫ID字段
    class UserInfo(models.Model):
        #添加ID字段,AutoField为自增属性字段,参数是设置为主键,
        id=models.AutoField(primary_key=True)
        #添加一个name字段CharField代表varchar类型,参数max_length执行长度
        name=models.CharField(max_length=10)
        #Date类型,只有年月日,传入数据的时候必须是"2018-12-12"这种格式
        bday=models.DateField()
        #布尔值类型,数据库中bool值存储的是tinyInt类型,存的是0或者1数字
        checked=models.BooleanField()
4:#执行数据库同步指令,
    #生成记录，每次修改了models里面的内容或者添加了新的app，新的app里面写了models里面的内容，都要执行这两条
    #执行makemigrations命令会在当前应用中的migrations模块中生成一个记录,
    python mange.py makemigrations
    #执行上面这个语句的记录来创建表，生成的表名字前面会自带应用的名字，
    #例如：你的book表在mysql里面叫做app01_book表
    python manage.py migrate
5:#往表中添加数据:
    #导入应用中的midels模块
    from app01 import models
    new_obj=models.UserInfo(
        id=1,name='张达',bday='2019-09-10',chenked=1,)
    #save方法把上面的语句翻译成sql语句,然后调用pymysql,发送给mysql服务端,
    new_obj.save()

增加数据

'''方式一'''
#导入应用中的midels模块
    from app01 import models
    #实例化对象,会把对象的参数,当作数据插入到数据库中
    new_obj=models.UserInfo(
        id=1,name='张达',bday='2019-09-10',chenked=1,)
    #save方法把上面的语句翻译成sql语句,然后调用pymysql,发送给mysql服务端,
    new_obj.save()
'''方式二'''
    #new_obj是当前创建新的数据的model对象
    imnport datetime
    #传入的时间可以是获取的当前时间
    data_time=datetime.datetime.now()
    new_obj=models.UserInfo.objects.create(
            id=1,name='张达',bday=data_time,checked=0
    )
    print(new_obj)#打印对象:UserInfo object
    print(new_obj.name)

批量增加数据

#导入应用中的midels模块
    from app01 import models
    #定义一个空的列表用来盛放所有的数据
    obj_list=[]
    #实例化对象,会把对象的参数,当作数据插入到数据库中
    for i in range(20):
        new_obj=models.UserInfo(
            id=i,name='张达'+i,bday=f'2019-09-i+1',chenked=1,)
        obj_list.append(new_obj)
    #bulk_create方法可以批量添加数据
    models.UserInfo.objects.bulk_create(obj_list)

添加字段

from django.db import models
1:#在models文件中添加一个字段
    class UserInfo(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=10)
    bday=models.DateField()
    checked=models.BooleanField()
    #新增一个字段,orm添加字段,该字段不能为空,所以要么给默认值,要么设置它允许为空 null=True
    now=models.DateTimeField(null=True)
2:#当models中的数据发生改变执行python mange.py makemigrations和python manage.py migrate指令
    python mange.py makemigrations  执行指令会产生一个新的记录,然后在执行migrate指令,发送数据到服务端
    
'''DateTimeField时间问题'''
    #DateTimeField设置参数auto_now_add=True,在添加数据的时候自动帮你添加当前时间
    #添加的事件存在时区问题,使用的时区是格林尼治(UTC)时区,
    now=models.DateTimeField(auto_now_add=True,null=True)
    #auto_now属性更新数据时,自动添加更新当前时间,创建新数据时,也会自动添加时间
    now=models.DateTimeField(auto_now=True,null=True)
    #解决方法:
        settings配置文件中将USE_TZ的值改为False:告诉mysql存储时间是按照当地时间来存储
        使用pycharm的数据库客户端的时候,时区也是utc时间,要注意修改

删除数据

1:#filter()简单查询
    返回的是queryset类型的数据,里面是一个个的model对象,类似于列表,因为查到的可能是多个数据
    #queryset对象删除数据,如果查询到的是多条数据,就会删除这些查到的所有数据
    models.UserInfo.objects.filter(id=7).delete()  
    #model对象调用删除,使用索引具体到某一条数据,删除只会删除这一条数据
    models.UserInfo.objects.filter(id=7)[0].delete()  
    #删除所有的数据
    models.UserInfo.objects.all().delete()

修改数据

#方式一:update
    #update方法只能用queryset对象可以调用,model对象不能使用update方法
    models.UserInfo.objects.filter(id=2).update(
         name='篮子文',
         checked = 0,)
#方式二:
    #使用model对象修改,直接设置值的方式直接修改
    ret = models.UserInfo.objects.filter(id=2)[0]
    ret.name='lijie'
    ret.checked=1
    ret.save()#save提交数据
    
#修改数据时时间auto_now参数:
    # 更新记录时,自动更新时间,创建新纪录时也会帮你自动添加创建时的时间,但是在更新数据时只有使用save方法的方式2的形式更新才能自动更新时间,update方式不会生效,
    now2 = models.DateTimeField(auto_now=True,null=True)

查询API

#all() 查询所有
    查询数据库中的所有结果，结果是queryset类型
    models.UserInfo.objects.all() 返回的数据库中所有的数据
#filter() 条件查询
    查询条件不能匹配到数据时,不会报错,返回一个空的queryset,<QuerySet []>,如果没有写查询条件会获取所有数据,获取的是queryset对象,queryset类型的数据还能够继续调用fitler方法
    ret = models.Book.objects.filter(title='金瓶7',publish='24期出版社')可以指定多个条件查询,相当于原生sql的and语句,
#get() model对象查询
    get获取的是一个model对象,有且只能有一个,查询不到,或者查询到多个都会报错
    1. 查不到数据会报错 :Book matching query does not exist
    2. 超过一个就报错 :returned more than one Book -- it returned 13!
#exclude() 排除
    指定排除与条件匹配的数据,返回值是queryset类型 
    1.object能够调用,models.Book.objects.exclude(id=6)
    2.queryset类型数据能够调用, models.Book.objects.all().exclude(id=6)
#order_by()排序
    queryset类型的数据来调用，对查询结果排序,默认是按照id来升序排列的，返回值还是queryset类型
    指定条件排序,可以指定多个排序字段,在条件中加上减号就是倒序排列
    models.Book.objects.all().order_by('-price','id')先根据price倒序排列,然后数据相同的再根据id排序
#reverse() 反转
    queryset类型的数据来调用，对查询结果反向排序，返回值还是queryset类型,数据哟啊先排序再反转
    models.Book.objects.all().order_by('id').reverse()
#count() 计数
    queryset类型的数据来调用，返回数据库中匹配查询(QuerySet)的对象数量
    models.Book.objects.all().count() 查询一共有多少条数据
#first()    
    返回第一条数据,结果是model对象类型
    Book.objects.all()[0] = Book.objects.all().first()这两种写法的意思相同
#last()
    返回最后一条数据,结果是model对象类型
    Book.objects.all()[-1] = Book.objects.all().last()这两种写法的意思相同
#exists()
    判断返回结果集是不是有数据
    queryset类型的数据来调用，如果QuerySet包含数据，就返回True，否则返回False
    models.Book.objects.filter(id=9999).exists() #有结果就是True,没有结果就是False
#values()
    返回的queryset对象,里面的数据是字典的形式,每一条数据是一个字典,字段为键,数据为值,
    ret = models.Book.objects.filter(id=9).values('title','price') #条件查询返回一个字典
    ret = models.Book.objects.values() #返回所有的数据
#values_list
    返回的queryset,里面是数组类型数据，它返回的是一个元组序列，把一条数据封装成一个元祖
    ret = models.Book.objects.all().values_list('title','price')#返回的是一个元祖
    ret = models.Book.objects.values_list()#返回所有数据
#distinct() 去重
    values和values_list得到的queryset类型的数据来调用，从返回结果中剔除重复纪录
    models.Book.objects.all().values('name').distinct()#吧name值相同的去除掉

双下划线模糊查询

Book.objects.filter(price__in=[100,200,300]) #price值等于这三个里面的任意一个的对象
Book.objects.filter(price__gt=100)  #大于，大于等于是price__gte=100，别写price>100，这种参数不支持
Book.objects.filter(price__lt=100)  #小于，小于等于是price__gte=100，别写price>100，这种参数不支持
Book.objects.filter(price__range=[100,200])  #sql的between and，大于等于100，小于等于200
Book.objects.filter(title__contains="python")  #title值中包含python的
Book.objects.filter(title__icontains="python") #不区分大小写
Book.objects.filter(title__startswith="py") #以什么开头，istartswith  不区分大小写
Book.objects.filter(title__endswith="py") #以什么结尾，iendswith  不区分大小写
Book.objects.filter(pub_date__year=2012) #查询时间是2012年的所有数据
#某年某月某日:
ret = models.Book.objects.filter(publish_date__year='2018') #查询时间是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')#2019-08-01的所有数据
#找字段数据为空的双下滑线
models.Book.objects.filter(publish_date__isnull=True) #publish_date这个字段值为空的那些数据

多表表结构

from 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)
    #与AuthorDetail建立一对一的关系，一对一的这个关系字段写在两个表的任意一个表里面都可以
    au=models.OneToOneField("AuthorDetail",on_delete=models.CASCADE)
    #就是foreignkey+unique，只不过不需要我们自己来写参数了，并且orm会自动帮你给这个字段名字拼上一个_id，数据库中字段名称为au_id
class AuthorDetail(models.Model):
    """
    作者详细信息表
    """
    birthday=models.DateField()
    telephone=models.CharField(max_length=11)
    addr=models.CharField(max_length=64)
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,)
    ## 通过ORM自带的ManyToManyField自动创建第三张表,与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且注意一点，你查看book表的时候，你看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个book类里面有authors这个字段属性
    authors=models.ManyToManyField('Author',)
    
'''********************************************************************'''
#models.OneToOneField (to="Publish",to_field="nid",on_delete=models.CASCADE)
    建立一对一的关系时候使用,to指向被关联的表，to_field指向你关联的字段，不写这个，默认会自动关联主键字段，on_delete级联删除
#models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE)
    建立一对多的关系的时候使用
#models.ManyToManyField(to='Author',)    
    建立多对多关系的时候使用,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表，并且注意一点，你查看表的时候，你看不到这个字段，因为这个字段就是创建第三张表的意思，不是创建字段的意思，所以只能说这个类里面有这个字段属性,产生的第三张表中有一个默认的id字段,然后是两张被关联表中的id字段,第三张表的表名是以两个被关联数据库的名字来命名,中间加上一个下划线,类名在前,属性在后
'''所有的外键字段都会被自动加上_id字段.所有在建外键的时候,不要写_id,orm会自动帮你追加'''
'''db_constrtaint=False'''消除外键的强制消除关系

创建表时的元信息

元信息
    ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")
    class Meta:
        unique_together = ("author", "book")

#db_table
    ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。db_table = 'book_model'

#index_together
    联合索引。

#unique_together
    创建联合唯一索引。

#ordering
    指定默认按什么字段排序。
    ordering = ['pub_date',]
    ordering = ['-id','pub_date']
    只有设置了该属性，我们查询到的结果才可以被reverse()，否则是能对排序了的结果进行反转(order_by()方法排序过的数据)