ORM常用操作

ORM初级简单操作

可以操作数据表、数据行，不能建库、删库。

不含外键的表操作

查询表内容

# 获取表中所有的数据
# ret是 QuerySet 对象列表  【对象】
ret = models.User.objects.all()  

# 获取一个对象（有且唯一）
# 获取不到或者获取到多个对象会报错
obj = models.User.objects.get(username='alex')

# 获取满足条件的对象
ret = models.User.objects.filter(username='alex',password='dasb')  # QuerySet 对象列表，可获取用户名相同的内容

增加数据

obj = models.创建表的类名.objects.create(表字段名=publisher_name)
# obj 是创建的数据对象
# obj.字段名=该字段内创建数据的内容
如：增加数据name = 'xiaoqi'  obj.name = 'xiaoqi'

删除数据

obj_list = models.创建表的类名.objects.filter(pk=pk)  # 获取对象列表
obj_list.delete()

obj = models.Publisher.objects.get(pk=pk)   # 获取指定行 对象
obj.delete()

编辑数据

# 修改数据
obj.name = publisher_name
obj.save()  # 保存数据到数据库中

# 修改数据
obj.name = publisher_name
obj.save(update=['name'])  # 指定更新字段

含外键的表操作

例：出版社与图书管理（图书管理多，多的设置外键，关联出版社）

查询

#########查询注意事项############
all_books = models.Book.objects.all()

for book in all_books:
    print(book.title)
    print(book.pub,type(book.pub))   #  ——> 所关联的出版社对象
    # 注：书籍直接点外键，book.pub是先到book表中获取外键pub_id的内容，然后通过pub_id去出版社表中获取对应的数据，封装成一个对象。相当于做了两次查询
    
    print(book.pub.pk)  #  查id 多一次查询
    print(book.pub_id)  # 直接在book表中查出的pub_id，只查询id推荐使用此方法。
    print(book.pub.name)
    print("*"*32)

新增

models.Book.objects.create(title=book_name,pub=出版社的对象) # pub是对应出版社信息的对象
models.Book.objects.create(title=book_name,pub_id=pub_id)	# pub_id直接对应book表的外键值

删除

pk = request.GET.get('id')  # 获取到id
models.Book.objects.filter(pk=pk).delete()

编辑数据

# 修改数据
book_obj.title = book_name
# book_obj.pub_id = pub_id
book_obj.pub = models.Publisher.objects.get(pk=pub_id)
book_obj.save()

多对多表结构

设计表结构

########django帮我们生成第三张表########
########多对多表结构创建#########
作者与书的关系，一个作者写多本书，一本书可由多个人共同完成
class Author(models.Model):
    name = models.CharFiled(max_length = 32)
    books = models.ManyToManyField('Book') # 多对多，作者表与Book表之间关系

第三张表名 app名_author_books

###############自己创建第三张表#############
class AuthorBook(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    date = models.DateField()

######自建的表和 ManyToManyField 联合使用########
class Author(models.Model):
    name = models.CharField(max_length=32)
    books = models.ManyToManyField('Book',through='AuthorBook')  # 不在Author表中生产字段，生产第三张表

class AuthorBook(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    date = models.DateField()

查询

obj_list = models.Author.objects.all()
# 获取Author  QuerySet 对象列表<QuerySet [<Author: Author object>....]>
    for obj in obj_list:
        # 循环获取每行数据的对象 Author object <class 'app01.models.Author'>
        print(obj, type(obj))
        print(obj.author_name, type(obj.author_name))
        # 获取对应行的author_name字段的值 mjj <class 'str'>
        print(obj.books, type(obj.books))
        # 关系管理对象app01.Book.None
        print(obj.books.all(),type(obj.books.all()))
        # 获取Book表的QuerySet对象列表 <QuerySet [<Book: Book object>, <Book: Book object>]>

展示

# 展示作者
def author_list(request):    # 查询所有的作者    
	all_authors = models.Author.objects.all()    
	return render(request,'author_list.html',{'all_authors':all_authors})

# 写模板
{% for author in all_authors %}
    <tr>
        <td>{{ forloop.counter }}</td>
        <td>{{ author.pk }}</td>
        <td>{{ author.name }}</td>
        <td>
            {% for book in author.books.all %}
                {% if forloop.last %}
                    《{{ book.title }}》
                {% else %}
                    《{{ book.title }}》、
                {% endif %}
            {% endfor %}
        </td>
    </tr>
{% endfor %}

增加

all_book = models.Book.objects.all()	# 获取Book表中对象列表
book_name = request.POST.getlist('book_name')	# 获取提交的数据，getlist以列表形式
author_obj = models.Author.objects.create(name=author_name) # 只插入book表中的内容
author_obj.books.set(book_name)  # 设置作者和书籍多对多的关系

修改

books = request.POST.getlist('books')

# 修改对象的数据
author_obj.name = name
author_obj.save()
# 多对多的关系
author_obj.books.set(books)  #  每次重新设置

批量插入

bulk_create()：批量插入数据，减少SQL查询次数，没插入一条数据就要查询一次

querysetlist=[]
for i in resultlist:
    # models.Account(name=i)，
    querysetlist.append(models.Account(name=i))     
models.Account.objects.bulk_create(querysetlist,batch_size=10)
# querysetlist:对象列表
# batch_size=10：单次插入数据量，一次插入10条，如果一共五十条数据，就插入五次

ORM中的常用方法

返回queryset对象列表的方法

all()：获取所有数据，返回一个queryset对象列表
filter()：获取指定内容的所有数据，返回一个queryset对象列表

exclude()：获取不满足条件的所有数据

ret = models.Person.objects.exclude(pk=1)	# 获取除了pk=1以外的所有数据

values()：

# values():获取对象所有的字段和字段的值,一个字典对应一行数据
ret = models.Person.objects.values()	# Queryset [{'字段':'值'}，{'字段':'值'}...]

# values('name','pid')：获取对应字段和值
ret = models.Person.objects.values('name','pid') # Queryset [{'name':'值','pid':'值'}...]

# values(flat=True): 添加该参数可直接获取对象的id

values_list()：

# values_list()：拿到对象所有字段的值，以元组形式存于列表中
ret = models.Person.objects.values_list()  # QuerySet  [ () ,() ]
# values_list('name','pid')：拿到对象指定字段的值，以元组形式存于列表中
ret = models.Person.objects.values_list('name','pid')

order_by()：排序

# 默认是升序，如果按降序排列在字段前加-，如：-pid
ret = models.Person.objects.all().order_by('age','-pid')
# 先以age按照升序排列后，再按照pid按照降序排列

reverse()：反转，反向排序

# 注：必须是已经排序好的Queryset列表，才能使用反转
ret = model.Person.objects.all().order_by('name')
r = ret.reverse()

distinct()：去重

# 完全相同的内容才能去重
ret = models.Person.objects.values('age').distinct()

orm操作返回对象的方法

get()：获取满足条件的一个数据

first()：获取第一个元素，没有返回None

ret = models.Person.objects.filter(pk=1).values().first()

last()：取最后一个元素，没有返回None

ret = models.Person.objects.filter(pk=1).first()

orm操作返回数字的方法

count()：计数

ret = models.Person.objects.all().count()	# 计算列表中有多少个对象

orm操作返回布尔值的方法

exists()：查询数据是否存在

ret = models.Person.objects.filter(pk=1000).exists()

单表的双下划线

__gt：大于 greater than

ret = models.Person.objects.filter(pk__gt=1)  # 取pk>1的数据

__gte：大于等于 greater than equal

ret = models.Person.objects.filter(pk__gte=1)	# 取pk>=1的数据

__lt：小于 less than

ret = models.Person.objects.filter(pk__lt=1)  # 取pk<1的数据

__lte：小于等于 less than equal

ret = models.Person.objects.filter(pk__lte=1)  # 取pk<=1的数据

__range：取范围数据

ret = models.Person.objects.filter(pk__range=[1,4])	# 取pk在1-4之间的数据，包含1，4

__in：取成员

ret = models.Person.objects.filter(pk__in=[1,2,4])	# 取pk在[1,2,4]中的数据

__contains：包含，相当于mysql中的模糊查询

ret = models.Person.objects.filter(name__contains='A') # 取name包含A的数据
ret = models.Person.objects.filter(name__icontains='A') # 忽略大小写

__startswith：以...开头

ret = models.Person.objects.filter(name__startswith='A') # 取name以A开头的数据
ret = models.Person.objects.filter(name__istartswith='A') # 忽略大小写

__endswith：以...结尾

ret = models.Person.objects.filter(name__endswith='A') # 取name以A结尾的数据
ret = models.Person.objects.filter(name__iendswith='A') # 忽略大小写

__year：筛选年份

ret = models.Person.objects.filter(birth__year='2019') # 取birth年份是2019的数据

__isnull：判断是否为空

ret  = models.Person.objects.filter(phone__isnull=False) # 取phone不为null的数据
""空字符串不为null。

外键的操作

外键表示了表与表之间的关系

建表语句，以下操作均是基于此表

from django.db import models
class Publisher(models.Model):
    name = models.CharField(max_length=32, verbose_name="名称")

    def __str__(self): 
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=32)
    pub = models.ForeignKey(
        Publisher, related_name='books',related_query_name='xxx',on_delete=models.CASCADE
    )
    def __str__(self):	# 指定__str__,方便查看区分对象
        return self.title

基于对象的

# 正向查询
book_obj = models.Book.objects.get(title='菊花怪大战MJJ')
book_obj.pub  # 获取到title这本书的queryset关系管理对象
book_obj.pub.all()	# 获取对应的出版社信息queryset对象
# 反向查询
pub_obj = models.Publisher.objects.get(pk=1)
pub_obj.book_set	# 获取到出版社id=1的对应书的queryset关系管理对象
pub_obj.book_set.all()  # 获取出版社信息对应的书queryset对象
# book_set 类名小写_set	没有指定related_name时使用
# 如果指定related_name,则不使用“类名小写_set”，直接使用related_name的值

基于字段的

# 查询老男孩出版社的书
ret = models.Book.objects.filter(pub__name='老男孩出版社')  # __表示跨表，从pub所在表跨到name所在表
print(ret)	# 得到book表 Queryset对象列表

# 查询出版菊花怪大战MJJ的出版社
ret= models.Publisher.objects.filter(books__title='菊花怪大战MJJ') #设置related_name的值
ret= models.Publisher.objects.filter(book__title='菊花怪大战MJJ')  # 未设置related_name的值，用类名小写

ret= models.Publisher.objects.filter(xxx__title='菊花怪大战MJJ')  # 如果设置了related_query_name='xxx'，就要用他的值xxx

关系管理对象：外键中不能使用id只能使用对象

# set方法
pub_obj.books.set(models.Book.objects.filter(pk__in=[4,5]))  # 不能用id  只能用对象
# add方法
pub_obj.books.add(*models.Book.objects.filter(pk__in=[1,2]))
# create方法
pub_obj.books.create(title='python')

# 外键可为空时才有remove  clear
pub_obj.books.remove(*models.Book.objects.filter(pk__in=[1,2]))
pub_obj.books.clear()

一对多关系管理对象的方法

关系管理对象

pub_obj = models.Publisher.objects.get(pk=1)	# pk=1对应的出版社对象
pub_obj.books	# 关系管理对象

set()：设置一对多关系

# 只能为对象
pub_obj.books.set(models.Book.objects.filter(pk__in=[1,2,4,5]))

add()：添加一对多关系

# 只能为对象
pub_obj.books.add(*models.Book.objects.filter(pk__in=[4,5]))
# 添加对象时，由于filter获取的是对象关系列表，所以要获取其中每个对象，通过*解包

remove()：删除一对多关系，只有当外键设置null=True时才行

# 只能为对象
pub_obj.books.remove(*models.Book.objects.filter(pk__in=[4,5]))

clear()：清空所有多对多关系，只有当外键设置null=True时才行
```
pub_obj.books.clear() # 清空所有obj对应书籍的一对多关系
```

多对多

建表代码

class Publisher(models.Model):
    name = models.CharField(max_length=32, verbose_name="名称")

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=6, decimal_places=2)  # 9999.99
    sale = models.IntegerField()
    kucun = models.IntegerField()
    pub = models.ForeignKey(Publisher, null=True,on_delete=models.CASCADE)

    def __str__(self):
        return self.title

class Author(models.Model):
    name = models.CharField(max_length=32, )
    books = models.ManyToManyField(Book)

    def __str__(self):
        return self.name

基于对象的

"""正向查询"""
obj = models.Author.objects.get(pk=1)
obj.books	# 关系管理对象
obj.books.all()	# 获取book的queryset对象列表

"""反向查询"""
book_obj = models.Book.objects.filter(title='桃花怪大战菊花怪').first()
# 不指定related_name
book_obj.author_set	# 关系管理对象
book_obj.author_set.all()	# 获取author的queryset对象列表
# related_name='authors'
book_obj.authors	# 关系管理对象
book_obj.authors.all()

基于字段的

obj = models.Author.objects.filter(books__title='菊花怪大战Mjj')	# 这里的__表示跨表
# 查询'菊花怪大战Mjj'这本书对应作者的对象列表，从books跨到title所在这个表

obj = models.Book.objects.filter(author__name='Mjj')	# 不指定related_name
# 查询作者'Mjj'对应的书的对象列表
obj = models.Book.objects.filter(authors__name='Mjj')	# related_name='authors'
obj = models.Book.objects.filter(xxx__name='Mjj')	# related_query_name='xxx'

多对多关系管理对象的方法

author_obj = models.Author.objects.get(pk=1)	# pk=1对应的作者对象
author_obj.books	# 关系管理对象

set()：设置多对多关系

# 参数可以是id，也可以是对象
author_obj.books.set([1,2,3])	# 将查询出的obj对应作者与pk为[1,2,3]的书设置多对多关系
# 内部是先将原来的删除，然后把新的内容添加进去
author_obj.books.set(models.Book.objects.filter(pk__in=[1,2,4,5]))

add()：添加多对多关系

author_obj.books.add(4,5)	# 给obj对应的作者添加pk为4和5的多对多关系
内部已经有的不会再新增
author_obj.books.add(*models.Book.objects.filter(pk__in=[4,5]))
# 添加对象时，由于filter获取的是对象关系列表，所以要获取其中每个对象，通过*解包

remove()：删除多对多关系

author_obj.books.remove(4,5) # 给obj对应的作者删除pk为4和5的多对多关系
author_obj.books.remove(*models.Book.objects.filter(pk__in=[4,5]))

clear()：清空所有多对多关系

author_obj.books.clear() # 清空所有obj对应作者的多对多关系

create()：创建一个所关联的对象，并且和当前对象添加多对多关系

author_obj.books.create(title='天龙八部'，pub_id=1) 
# 通过作者对象创建书的内容，书中有title和pub外键

book_obj = models.Book.object.filter(pk=2).first() # 通过书籍对象创建作者的内容
book_obj.author_set.create(name='xiaoqi')

update()：批量更新数据

models.Customer.objects.filter(pk__in=pk).update(consultant=self.request.user_obj)
# 筛选出pk字段在pk中的数据，所有数据更新consultant字段值为self.request.user_obj

分组聚合