model,单表操做

时间 2020-04-29

标签 model 繁體版

原文原文链接

一. modelpython

　　Django提供了一个抽象层（“Model”）来构建和管理Web应用程序的数据。mysql

　　django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。linux

　　关系对象映射（Object Relational Mapping，简称ORM), 它实现了数据模型与数据库的解耦，即数据模型的设计不须要依赖于特定的数据库，经过简单的配置就能够轻松更换数据库，这极大的减轻了开发人员的工做量，不须要面对因数据库变动而致使的无效劳动. git

二. 单表操做sql

　　<一>. 表的建立数据库

　　1. 建立表django

　　建立模型session

　　建立名为book的app，在book下的models.py中建立模型：app

from django.db import models # Create your models here.

class Book(models.Model): id=models.AutoField(primary_key=True) #若是表里面没有写主键，表里面会自动生成一个自增主键字段，叫作id字段，orm要求每一个表里面必需要写一个主键
     title=models.CharField(max_length=32)  #和varchar(32)是同样的，32个字符
     state=models.BooleanField() pub_date=models.DateField() #必须存这种格式"2018-12-12"
     price=models.DecimalField(max_digits=8,decimal_places=2) #max_digits最大位数，decimal_places小数部分占多少位
     publish=models.CharField(max_length=32)

View Code

　　接下来要建立对应的数据，链接上对应的数据库，而后执行建立表的命令，翻译成相应的sql，而后到数据库里面执行，从而建立对应的表。多了一步orm翻译成sql的过程ide

　　2. 更多字段和参数

　　3. setting配置

DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'bms',     　　 　  # 要链接的数据库，链接前须要建立好
        'USER':'root',　　　　　　  # 链接数据库的用户名
        'PASSWORD':'',　　　　　　  # 链接数据库的密码
        'HOST':'127.0.0.1',       # 链接主机，默认本级
        'PORT'：3306    　　　     # 端口 默认3306
 } }

View Code

　　注意1：NAME即数据库的名字，在mysql链接前该数据库必须已经建立，而上面的sqlite数据库下的db.sqlite3则是项目自动建立 USER和PASSWORD分别是数据库的用户名和密码。设置完后，再启动咱们的Django项目前，咱们须要激活咱们的mysql。而后，启动项目，会报错：no module named MySQLdb 。这是由于django默认你导入的驱动是MySQLdb，但是MySQLdb 对于py3有很大问题，因此咱们须要的驱动是PyMySQL 因此，咱们只须要找到项目名文件下的__init__,在里面写入：

import pymysql pymysql.install_as_MySQLdb()

View Code

　　最后经过两条数据库迁移命令便可在指定的数据库中建立表：

python manage.py makemigrations  #生成记录，每次修改了models里面的内容或者添加了新的app，新的app里面写了models里面的内容，都要执行这两条
python manage.py migrate         #执行上面这个语句的记录来建立表，生成的表名字前面会自带应用的名字，例如：你的book表在mysql里面叫作app01_book表

View Code

　　注意2:确保配置文件中的INSTALLED_APPS中写入咱们建立的app名称

INSTALLED_APPS = [ 'django.contrib.admin',  #这是django给你提供的一些特殊功能的配置（应用，只是我们看不到），也在应用这里给配置的，这些功能若是你注销了，那么咱们执行同步数据库指令以后，就不会生成那些django自带的表了。由于执行数据库同步语句的时候，django会找这里面全部的应用，找到他们的models来建立表
    'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', "book"  #直接写app的名字也行，写'app01.apps.App01Config'也行
]

View Code

　　注意3: 若是想打印orm转换过程当中的sql，须要在settings中进行以下配置：

LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } }

View Code

　　4. 自定义字段

　　<二>. 添加表记录

　　在python中orm的对应关系有三种：

　　　　类 ----------> 表

　　　　类对象 ----------> 行(记录)

　　　　类属性 ----------> 表的字段（重点）

　　方式1:

book_obj=Book(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12") #实例化一个对象表示一行记录，时间日期若是只写日期的话，时间默认是00.00.00，注意日期写法必须是2012-12-12这种格式
book_obj.save() #就是pymysql的那个commit提交

View Code

　　方式2:

# create方法的返回值book_obj就是插入book表中的python葵花宝典这本书籍纪录对象
  book_obj=Book.objects.create(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12") #这个返回值就像是mysql里面我们讲的那个new对象，还记得吗，他跟上面那种建立方式建立的那个对象是同样的
  #这个Book.objects就像是一个Book表的管理器同样，提供了增删改查全部的方法
  print(book_obj.title) #能够基于这个对象来取这个新添加的记录对象的属性值
  dic1 = {'title':'linux','state'=True,'price':100,'publish'='2018-12-12'} #这样写的时候，注意若是你用post提交过来的请求，有个csrf_token的键值对要删除，而且request.POST是不能直接在request.POST里面进行修改和删除的，data = request.POST.dict()转换成普通的字典-->Book.objects.create(**data)
  book.objects.create(**dic1)

View Code

　　<三>, 查询表记录

　　1. 查询API

<1> all(): 查询全部结果，结果是queryset类型 <2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象，结果也是queryset类型 Book.objects.filter(title='linux',price=100) #里面的多个条件用逗号分开，而且这几个条件必须都成立，是and的关系，or关系的咱们后面再学，直接在这里写是搞不定or的
  
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，不是queryset类型，是行记录对象，返回结果有且只有一个， 若是符合筛选条件的对象超过一个或者没有都会抛出错误。捕获异常try。 Book.objects.get(id=1) <4> exclude(**kwargs): 排除的意思，它包含了与所给筛选条件不匹配的对象，没有不等于的操做昂，用这个exclude，返回值是queryset类型 Book.objects.exclude(id=6)，返回id不等于6的全部的对象，或者在queryset基础上调用，Book.objects.all().exclude(id=6) 　　　　　　　　　　　　　　　　 <5> order_by(*field): queryset类型的数据来调用，对查询结果排序,默认是按照id来升序排列的，返回值仍是queryset类型 　　　　　　　　　　　　　　　　 models.Book.objects.all().order_by('price','id') #直接写price，默认是按照price升序排列，按照字段降序排列，就写个负号就好了order_by('-price'),order_by('price','id')是多条件排序，按照price进行升序，price相同的数据，按照id进行升序
        
<6> reverse(): queryset类型的数据来调用，对查询结果反向排序，返回值仍是queryset类型 <7> count(): queryset类型的数据来调用，返回数据库中匹配查询(QuerySet)的对象数量。 <8> first(): queryset类型的数据来调用，返回第一条记录 Book.objects.all()[0] = Book.objects.all().first()，获得的都是model对象，不是queryset <9> last(): queryset类型的数据来调用，返回最后一条记录 <10> exists(): queryset类型的数据来调用，若是QuerySet包含数据，就返回True，不然返回False空的queryset类型数据也有布尔值True和False，可是通常不用它来判断数据库里面是否是有数据，若是有大量的数据，你用它来判断，那么就须要查询出全部的数据，效率太差了，用count或者exits 　　　　　　　　　　　　　　　　 例：all_books = models.Book.objects.all().exists() #翻译成的sql是SELECT (1) AS `a` FROM `app01_book` LIMIT 1，就是经过limit 1，取一条来看看是否是有数据

<11> values(*field): 用的比较多，queryset类型的数据来调用，返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列model的实例化对象，而是一个可迭代的字典序列,只要是返回的queryset类型，就能够继续链式调用queryset类型的其余的查找方法，其余方法也是同样的。 <12> values_list(*field): 它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列 <13> distinct(): values和values_list获得的queryset类型的数据来调用，从返回结果中剔除重复纪录

　　queryset方法大全：

################################################################## # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET # ##################################################################

def all(self) # 获取全部的数据对象

def filter(self, *args, **kwargs) # 条件查询
    # 条件能够是：参数，字典，Q

def exclude(self, *args, **kwargs) # 条件查询
    # 条件能够是：参数，字典，Q

def select_related(self, *fields) 性能相关：表之间进行join连表操做，一次性获取关联的数据。 总结： 1. select_related主要针一对一和多对一关系进行优化。 2. select_related使用SQL的JOIN语句进行优化，经过减小SQL查询的次数来进行优化、提升性能。 def prefetch_related(self, *lookups) 性能相关：多表连表操做时速度会慢，使用其执行屡次SQL查询在Python代码中实现连表操做。 总结： 1. 对于多对多字段（ManyToManyField）和一对多字段，可使用prefetch_related()来进行优化。 2. prefetch_related()的优化方式是分别查询每一个表，而后用Python处理他们之间的关系。 def annotate(self, *args, **kwargs) # 用于实现聚合group by查询

    from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1) # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1) # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names) # 用于distinct去重
    models.UserInfo.objects.values('nid').distinct() # select distinct nid from userinfo
 注：只有在PostgreSQL中才能使用distinct进行去重 def order_by(self, *field_names) # 用于排序
    models.UserInfo.objects.all().order_by('-id','age') def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 构造额外的查询条件或者映射，如：子查询
 Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self): # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse() # 注：若是存在order_by，reverse则是倒序，若是多个排序则一一倒序


 def defer(self, *fields): models.UserInfo.objects.defer('username','id') 或 models.UserInfo.objects.filter(...).defer('username','id') #映射中排除某列数据

 def only(self, *fields): #仅取某个表中的数据
     models.UserInfo.objects.only('username','id') 或 models.UserInfo.objects.filter(...).only('username','id') def using(self, alias): 指定使用的数据库，参数为别名（setting中的设置） ################################################## # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS # ##################################################

def raw(self, raw_query, params=None, translations=None, using=None): # 执行原生SQL
    models.UserInfo.objects.raw('select * from userinfo') # 若是SQL是其余表时，必须将名字设置为当前UserInfo对象的主键列名
    models.UserInfo.objects.raw('select id as nid from 其余表') # 为原生SQL设置参数
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 将获取的到列名转换为指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定数据库
    models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ###################
    from django.db import connection, connections cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields): # 获取每行数据为字典格式

def values_list(self, *fields, **kwargs): # 获取每行数据为元祖

def dates(self, field_name, kind, order='ASC'): # 根据时间进行某一部分进行去重查找并截取指定内容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC" "DESC"
    # 并获取转换后的时间
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC') def datetimes(self, field_name, kind, order='ASC', tzinfo=None): # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC" "DESC"
    # tzinfo时区对象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC) models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """ pip3 install pytz import pytz pytz.all_timezones pytz.timezone(‘Asia/Shanghai’) """

def none(self): # 空QuerySet对象


#################################### # METHODS THAT DO DATABASE QUERIES # ####################################

def aggregate(self, *args, **kwargs): # 聚合函数，获取字典类型聚合结果
   from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> {'k': 3, 'n': 4} def count(self): # 获取个数

def get(self, *args, **kwargs): # 获取单个对象

def create(self, **kwargs): # 建立对象

def bulk_create(self, objs, batch_size=None): # 批量插入
    # batch_size表示一次插入的个数
    objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs): # 若是存在，则获取，不然，建立
    # defaults 指定建立时，其余字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs): # 若是存在，则更新，不然，建立
    # defaults 指定建立时或更新时的其余字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1}) def first(self): # 获取第一个

def last(self): # 获取最后一个

def in_bulk(self, id_list=None): # 根据主键ID进行查找
   id_list = [11,21,31] models.DDD.objects.in_bulk(id_list) def delete(self): # 删除

def update(self, **kwargs): # 更新

def exists(self): # 是否有结果
 方法

View Code

　　关于values和value_list的用法和返回结果举例：

all_books = models.Book.objects.all().values('id','title') print(all_books) #<QuerySet [{'title': 'linux', 'id': 6}, {'title': '你好', 'id': 7}, {'title': 'linux', 'id': 8}, {'title': 'xxx', 'id': 9}, {'title': 'gogogo', 'id': 10}]>
    ''' values作的事情： ret = [] #queryset类型 for obj in Book.objects.all(): temp = { #元素是字典类型 'id':obj.id, 'title':obj.title } ret.append(temp) ''' all_books = models.Book.objects.all().values_list('id','title') print(all_books) #<QuerySet [(6, 'linux'), (7, '你好'), (8, 'linux'), (9, 'xxx'), (10, 'gogogo')]>
    ''' values作的事情： ret = [] #queryset类型 for obj in Book.objects.all(): temp = ( #元素是元祖类型 obj.id,obj.title ) ret.append(temp) '''

View Code

　　关于distinct的用法和返回结果举例：

# all_books = models.Book.objects.all().distinct() #这样写是表示记录中全部的字段重复才叫重复，可是咱们知道有主键的存在，因此不可能全部字段数据都重复
    # all_books = models.Book.objects.all().distinct('price') #报错，不能在distinct里面加字段名称
    # all_books = models.Book.objects.all().values('price').distinct()#<QuerySet [(Decimal('11.00'),), (Decimal('111.00'),), (Decimal('120.00'),), (Decimal('11111.00'),)]>
    all_books = models.Book.objects.all().values_list('price').distinct()#<QuerySet [{'price': Decimal('11.00')}, {'price': Decimal('111.00')}, {'price': Decimal('120.00')}, {'price': Decimal('11111.00')}]> 只能用于valuse和values_list进行去重
　　all_books = models.Book.objects.all().values_list('title','price').distinct() #title和price两个同时重复才算一条重复的记录

View Code

　　打印一个对象，让他显示一个可以看懂的值，__str__，models.py的数据表类里面定义一个__str__方法就能够了

　　models.py的__str__的写法：

#__str__方法的使用
class MyClass: def __init__(self,name,age): self.name = name self.age = age def __str__(self): return self.name + '>>>' + str(self.age) a = MyClass('chao',18) b = MyClass('wc',20) print(a) print(b) from django.db import models # Create your models here.

class Book(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2,) pub_date = models.DateTimeField() #必须存这种格式"2012-12-12"
    publish = models.CharField(max_length=32) def __str__(self): #后添加这个str方法，也不须要从新执行同步数据库的指令
        return self.title #当咱们打印这个类的对象的时候，显示title值

View Code

　　2. 基于双下划綫的模糊查询

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) 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(pub_date__year=2012)

View Code

　　日期查询示例:

# all_books = models.Book.objects.filter(pub_date__year=2012) #找2012年的全部书籍
    # all_books = models.Book.objects.filter(pub_date__year__gt=2012)#找大于2012年的全部书籍
    all_books = models.Book.objects.filter(pub_date__year=2019,pub_date__month=2)#找2019年月份的全部书籍，若是明明有结果，你却查不出结果，是由于mysql数据库的时区和我们django的时区不一样致使的，了解一下就好了，你须要作的就是将django中的settings配置文件里面的USE_TZ = True改成False，就能够查到结果了，之后这个值就改成False，并且就是由于我们用的mysql数据库才会有这个问题，其余数据库没有这个问题。

View Code

　　<四>. 删除表记录

　　delete()方法的调用者能够是一个model对象，也能够是一个queryset集合。

　　删除方法就是 delete()。它运行时当即删除对象而不返回任何值。

　　models_obj.delete()

　　也能够一次性删除多个对象。每一个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中全部的对象。

　　models.Book.objects.filter(pub_date__year=2016).delete()

　　在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象

　　要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 自己。这是一种保护机制，是为了不意外地调用 Entry.objects.delete() 方法致使全部的记录被误删除。若是你确认要删除全部的对象，那么你必须显式地调用：

Entry.objects.all().delete()

　若是不想级联删除，能够设置为:

pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True))

　　<五>. 修改表记录

　　update只能是querset类型才能调用，model对象不能直接调用更新方法，因此使用get方法获取对象的时候是不能update的。

Book.objects.filter(title__startswith="py").update(price=120)  此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你能够同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。