Django之ORM相关操作

最新推荐文章于 2022-09-20 14:44:18 发布

yangsen99

最新推荐文章于 2022-09-20 14:44:18 发布

阅读量186

点赞数

本文链接：https://blog.csdn.net/yangsen99/article/details/82505679

版权

ForeignKey操作

外键操作主要分为两个部分，一部分是正向查询，另一部分是反向查询，其中正向查询就是从外键字段存在的那张表往另一张表查询就叫做正向查询，反之就叫做反向查询

正向查询

1、对象查找（跨表）

通过外键存在的那张表的类实例出来的对象+ “.” + 外键关联字段，就可以的到被关联表的对象，然后通过这个对象就可以查询其中的属性

语法：

对象.关联字段.字段

示例：

book_obj = models.Book.objects.first()  # 第一本书对象
print(book_obj.publisher)  # 得到这本书关联的出版社对象
print(book_obj.publisher.name)  # 得到出版社对象的名称

2、字段查找（跨表）

语法：

关联字段__字段

示例：

print(models.Book.objects.values_list("publisher__name"))

反向查询

1、对象查找

语法：

obj.表名_set

# 表名 小写

示例：

publisher_obj = models.Publisher.objects.first()  # 找到第一个出版社对象
books = publisher_obj.book_set.all()  # 找到第一个出版社出版的所有书
titles = books.values_list("title")  # 找到第一个出版社出版的所有书的书名

补充：

2、字段查找

语法：

表名__字段

示例：

titles = models.Publisher.objects.values_list("book__title")

ManyToManyField

"关联管理器"是在一对多或者多对多的关联上下文中使用的管理器。

它存在于下面两种情况：

外键关系的反向查询
多对多关联关系

简单来说就是当点后面的对象可能存在多个的时候就可以使用以下的方法

具体方法

create()

创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象。

>>> import datetime
>>> models.Author.objects.first().book_set.create(title="番茄物语", publish_date=datetime.date.today())

add()

把指定的model对象添加到关联对象集中。

添加对象

>>> author_objs = models.Author.objects.filter(id__lt=3)
>>> models.Book.objects.first().authors.add(*author_objs)

添加id

>>> models.Book.objects.first().authors.add(*[1, 2])

set()

更新model对象的关联对象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.set([2, 3])

remove()

从关联对象集中移除执行的model对象

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.remove(3)

clear()

从关联对象集中移除一切对象。

>>> book_obj = models.Book.objects.first()
>>> book_obj.authors.clear()

注意：

对于ForeignKey对象，clear()和remove()方法仅在null=True时存在。

举个例子：

ForeignKey字段没设置null=True时，

class Book(models.Model):
    title = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Publisher)

没有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'

当ForeignKey字段设置null=True时，

class Book(models.Model):
    name = models.CharField(max_length=32)
    publisher = models.ForeignKey(to=Class, null=True)

此时就有clear()和remove()方法：

>>> models.Publisher.objects.first().book_set.clear()

注意：

对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。

聚合查询和分组查询

聚合查询

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。

键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。

用到的内置函数：

from django.db.models import Avg, Sum, Max, Min, Count

示例：

>>> from django.db.models import Avg, Sum, Max, Min, Count
>>> models.Book.objects.all().aggregate(Avg("price"))
{'price__avg': 13.233333}

如果你想要为聚合值指定一个名称，可以向聚合子句提供它。

>>> models.Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 13.233333}

如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。所以，如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

>>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}

分组查询

假设现在有一张公司职员表：

我们使用原生SQL语句，按照部分分组求平均工资：

select dept,AVG(salary) from employee group by dept;

ORM查询:

from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values(dept, "avg")

连表查询的分组：

SQL查询：

select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;

ORM查询：

from django.db.models import Avg
models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg")

F查询和Q查询

F查询

像之前我们所了解的一些过滤的例子和操作都是在针对字段值和某一个常量之间作比较，但是如果我们要针对两个字段值作比较的话就不行了，这就涉及到这个F查询了

我们可以使用Django为我们提供的F（）来做一些这样的比较。F（）的实例可以在查询当中引用字段，来比较同一个model实例中两个不同的字段值

首先要先导入F：

from django.db.models import F

示例：

    # 查询出卖出数大于库存数的商品
    # ret = models.Product.objects.filter(maichu__gt=F("kucun"))
    # print(ret)

    # 将每个商品的价格提高50块
    # models.Product.objects.update(price=F("price")+50)

修改Char字段的方法

首先先导入：

 from django.db.models.functions import Concat
 from django.db.models import Value

示例

# 将所有商品的名称后面加一个 '新款'
# models.Product.objects.update(name=Concat(F("name"), Value("新款")))

Q查询

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。

首先先导入Q：

from django.db.models import Q

可以组合& 和| 操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询。

示例1：

 # 查询 卖出数大于100 或者 价格小于100块的
 # ret = models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))
 # print(ret)

示例2：

 # 查询 库存数是100 并且 卖出数不是0 的产品
 # ret = models.Product.objects.filter(Q(kucun=100) & ~Q(maichu=0))
 # print(ret)

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。

示例：

    # 查询产品名包含新款， 并且库存数大于60的
    # ret = models.Product.objects.filter(Q(kucun__gt=60), name__contains="新款")
    # print(ret)

事务

在MySQL数据库当中也有事务这一个概念，它是用于将某些操作的多个SQL作为原子性操作，一旦有某一个出现错误，即可回滚到原来的状态，从而保证数据库数据完整性。

事务有几大特性，分别是：1、数据的原子性 2、隔离性 3、持久性 4、一致性

ORM事务

首先要先导入事务处理

from django.db import transaction

示例：

开启事务

    try:
        with transaction.atomic():
            # 创建一条订单数据
            models.Order.objects.create(num="110110111", product_id=1, count=1)
            # 去产品表 将卖出数+1， 库存数-1 (报错)
            # models.Product.objects.get(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)
            # 能执行成功
            models.Product.objects.filter(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)
    except Exception as e:
        print(e)

不开启事务

 try:
        # 创建一条订单数据
        models.Order.objects.create(num="110110110", product_id=1, count=1)
        # 去产品表 将卖出数+1， 库存数-1
        models.Product.objects.get(id=1).update(kucun=F("kucun") - 1, maichu=F("maichu") + 1)
    except Exception as e:
        print(e)

QuerySet方法大全

重点示例

1、updata和save

updata和save这两周方法都是用来对数据进行保存的，只不过updata方法是针对你要修改的那部分内容进行操作，而save是会将所有的数据全部重新保存一遍，二者相比明显是updata更加效率更加节省资源

2、select_related和prefetch_related

1. select_related 利用 SQL的JOIN来减少查询数据库的次数适用于一对一和多对一的查询的情况

2. prefetch_related 利用 Python 来做类似JOIN操作

像之前我们使用外键操作进行跨表查询，如果想要将被关联表中的某些字段查询出来就需要一次一次的查询，非常浪费效率，但是如果使用select_related我们就可以只查询一次就将你想要查询的所有记录都查询出来。

2、bulk_create

这个方法主要是用来进行批量插入的，像正常我们插入记录插入一条就需要执行一条SQL语句，这样会非常的浪费时间、浪费资源了，使用bulk_create方法的话就可以使用一条SQL语句插入所有的记录了

示例：

传统方式

    data = ["".join([str(random.randint(65, 99)) for i in range(4)]) for j in range(100)]
    for i in data:
        models.A.objects.create(name=i)

这个需要执行100条SQL语句

bulk_create方法

    data = ["".join([str(random.randint(65, 99)) for i in range(4)]) for j in range(100)]
    obj_list = [models.A(name=i) for i in data]
    models.A.objects.bulk_create(obj_list)

只需要执行一条SQL语句

ORM执行原生SQL的方法

语法：

extra

在QuerySet的基础上继续执行子语句

extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

示例：

# select和select_params是一组，where和params是一组，tables用来设置from哪个表
# 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'])

举个例子：
models.UserInfo.objects.extra(
                    select={'newid':'select count(1) from app01_usertype where id>%s'},
                    select_params=[1,],
                    where = ['age>%s'],
                    params=[18,],
                    order_by=['-age'], tables=['app01_usertype'] ) """ select app01_userinfo.id, (select count(1) from app01_usertype where id>1) as newid from app01_userinfo,app01_usertype where app01_userinfo.age > 18 order by app01_userinfo.age desc """ # 执行原生SQL # 更高灵活度的方式执行原生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()

yangsen99

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Django之ORM相关操作

&#13; ForeignKey操作&#13;外键操作主要分为两个部分，一部分是正向查询，另一部分是反向查询，其中正向查询就是从外键字段存在的那张表往另一张表查询就叫做正向查询，反之就叫做反向查询&#13;正向查询&#13;1、对象查找（跨表）&#13;通过外键存在的那张表的类实例出来的对象+ “.” + 外键关联字段，就可以的到被关联表的对象，然后通过这个对象就可...
复制链接

扫一扫