ORM回顾 之 单，多表查询 many2many 中介模型

Posted 2020-12-03 jsp0

 

 

python独立的ORM框架

1 SQLAlchemy

ORM:对象关系映射

模型类 --------- 表
类下的属性变量 --------- 字段名称
类下的属性变量对应的值--------- 字段约束关系
类的实例对象 --------- 表的一条记录数据

class Book(models.Model):
id=models.AutoField(primary_key=True)
title=models.CharField(max_length=32)
state=models.BooleanField()
pub_date=models.DateField()
price=models.DecimalField(max_digits=8,decimal_places=2)
publish=models.CharField(max_length=32)

一 单表操作
添加记录：
方式1： book=Book.objects.create()
方式2：
book=Book(title="A")
book.save()

book=Book()
book.title="B"
book.save()

查询API：
<1> all(): 查询所有结果

<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象

<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
如果符合筛选条件的对象超过一个或者没有都会抛出错误。

<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象

<5> order_by(*field): 对查询结果排序

<6> reverse(): 对查询结果反向排序

<8> count(): 返回数据库中匹配查询(QuerySet)的对象数量。

<9> first(): 返回第一条记录

<10> last(): 返回最后一条记录

<11> exists(): 如果QuerySet包含数据，就返回True，否则返回False

<12> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
model的实例化对象，而是一个可迭代的字典序列
<13> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

<14> distinct(): 从返回结果中剔除重复纪录


总结：
1 方法是由谁调用，返回值是什么类型
2 queryset支持链式操作
Book.objects.filter().order_by().reverse().count()

3 修改

queryset.update(price=100)
queryset.update(**{"price":100})

4 删除
queryset.delete()
model_obj.delete()


多表操作

 

class Author(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
age=models.IntegerField()

# 与AuthorDetail建立一对一的关系
authorDetail=models.OneToOneField(to="AuthorDetail",on_delete=models.CASCADE)

class AuthorDetail(models.Model):

nid = models.AutoField(primary_key=True)
birthday=models.DateField()
telephone=models.BigIntegerField()
addr=models.CharField( max_length=64)

class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField( max_length=32)
city=models.CharField( max_length=32)
email=models.EmailField()

class Book(models.Model):

nid = models.AutoField(primary_key=True)
title = models.CharField( max_length=32)
publishDate=models.DateField()
price=models.DecimalField(max_digits=5,decimal_places=2)

# 与Publish建立一对多的关系,外键字段建立在多的一方
publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE)
# 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表
authors=models.ManyToManyField(to=‘Author‘,)

一 添加记录：

绑定一对多的关系：

book=Book(title="A",publish_id=1)
book.save()

book=Book(title="A",publish=publish_obj)
book.save()


book=Book()
book.title="B"
book.publish=publish_obj
book.save()


print(book.publish)
print(book.publish_id)

绑定多对多的关系：

book_authors

id book_id author_id
1 1 1
2 1 2
3 1 3
4 1 8

book_obj=Book.objects.get(pk=1)
book_obj.authors.add(1,2,3,4)

author_01=Author.objects.get(pk=1)
book_obj.authors.add(author_01)
book_obj.authors.add(1)

book_obj.authors.add(*[1,2,3,4])
###################################
book_obj=Book.objects.get(pk=1)
book_obj.authors.remove(3)
author_obj=Author.objects.get(pk=3)
book_obj.authors.remove(author_obj)
book_obj.authors.remove(2,3)
book_obj.authors.remove(*[2,3])
###################################
book_obj=Book.objects.get(pk=1)
book_obj.authors.clear()
###################################
book_obj=Book.objects.get(pk=1)
book_obj.authors.set(8)



中介模型：

student
id name
1 alex
2 egon

course
id name
1 人体艺术
2 瑜伽

student_course

id student_id course_id score
1 1 1

class Student():
name=....
courses=models.ManyToManyFiled(to="Course",through="student_course")

class Course():
name=....

class student_course():
id
student_id
course_id
score

中介模型注意点：
add/remove/set

redis:
1 NoSql
2 缓存在内存中
3 支持持久化
4 key-value（value可以是字符串，数字，数组，哈希，集合）

redis:

redis-----> {



}



0010 0000
1010 0101
与运算 0010 0000
或运算 1010 0101
异或运算1000 0101

 

from django.db import transaction

with transaction.atomic():

artcle_id=artcle_id
ArticleUpDown.objects.create(artcle_id=artcle_id,.......)

Articel.objects.filter(pk=artcle_id).update(up_count=F("up_count")+1)