浮躁是人生最大的敌人

Django——ORM

Posted on 2019-06-12 23:02  King'home  阅读(207)  评论(0)    收藏  举报

一、ORM常用的字段和参数

1.0 常用字段

# AutoField:

int自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。

# IntegerField:

一个整数类型,范围在 -2147483648 to 2147483647。(一般不用它来存手机号(位数也不够)，直接用字符串存，)

# CharField:

字符类型，必须提供max_length参数， max_length表示字符长度

# DateField：

日期字段，日期格式  YYYY-MM-DD，相当于Python中的datetime.date()实例

# DateTimeField：

日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime()实例。

1.1 字段合集（争取记忆）

AutoField(Field)
        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"

    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

    BinaryField(Field)
        - 二进制类型

 字段合集
字段合合集
对应关系：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

ORM字段与MySQL字段对应关系
对应关系

1.2 字段参数

# null

用于表示某个字段可以为空

# unique

如果设置为unique = Ture

# db_index

如果db_index=True 则代表着为此字段设置索引。

# default

为该字段设置默认值。

1.3 DateField 和 DateTimeField

# auto_now_add

配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。

# auto_now

配置上auto_now=True，每次更新数据记录的时候会更新该字段。

二、ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。

ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

2.1 字段参数

# to

设置要关联的表

# to_field

设置要关联的表的字段

# on_delete

当删除关联表中的数据时，当前表与其关联的行的行为。

# models.CASCADE

删除关联数据，与之关联也删除

# db_constraint

是否在数据库中创建外键约束，默认为True。

models.DO_NOTHING
删除关联数据，引发错误IntegrityError


models.PROTECT
删除关联数据，引发错误ProtectedError


models.SET_NULL
删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）


models.SET_DEFAULT
删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）


models.SET

删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)
others
def func():
    return 10

class MyModel(models.Model):
    user = models.ForeignKey(
        to="User",
        to_field="id"，
        on_delete=models.SET(func)
    )

2.2 一般操作

# 在Python脚本中调用Django

<img src="https://i.loli.net/2019/06/12/5d00dc63dfab377869.png"/>

配置test文件

这样就可以直接运行你的test.py文件来运行测试

1. 创建数据方法

    # 基于create创建
    # user_obj = models.User.objects.create(name='tank',age=73,register_time='2019-2-14')
    # print(user_obj.register_time)
    # 基于对象的绑定方法创建
    # user_obj = models.User(name='kevin',age=30,register_time='2019-1-1')
    # user_obj.save()

2. 修改数据

# 修改数据
    # 基于对象
    # user_obj = models.User.objects.filter(name='jason').first()
    # user_obj.age = 17
    # user_obj.save()
    # 基于queryset
    # models.User.objects.filter(name='kevin').update(age=66)

3. 删除数据

    # 删除数据
    # 基于queryset
    # models.User.objects.filter(name='egon').delete()
    # 基于对象
    # user_obj = models.User.objects.filter(name='owen').first()
    # user_obj.delete()

4. 查询数据

单表查询

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


# < 2 > filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
# res = models.User.objects.filter(name='jason',age=17)
# filter内可以放多个限制条件但是需要注意的是多个条件之间是and关系
# < 3 > get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。（源码就去搂一眼～诠释为何只能是一个对象）
# 不推荐使用

# < 4 > exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
res = models.User.objects.exclude(name='jason')
print(res)

# < 5 > order_by(*field): 对查询结果排序('-id') / ('price')
# res = models.User.objects.order_by('age')   # 默认是升序
# res = models.User.objects.order_by('-age')  # 可以在排序的字段前面加一个减号就是降序
# res = models.User.objects.order_by('name')
# res = models.User.objects.order_by('-name')
# print(res)


# < 6 > reverse(): 对查询结果反向排序 >> > 前面要先有排序才能反向
# res = models.User.objects.order_by('age').reverse()
# print(res)


# < 7 > count(): 返回数据库中匹配查询(QuerySet) 的对象数量。
# res = models.User.objects.count()
# res = models.User.objects.all().count()
# print(res)


# < 8 > first(): 返回第一条记录
# res = models.User.objects.all().first()
# res = models.User.objects.all()[0]  # 不支持负数的索引取值
# print(res)

# < 9 > last(): 返回最后一条记录
# res = models.User.objects.all().last()
# print(res)

# < 10 > exists(): 如果QuerySet包含数据，就返回True，否则返回False
# res = models.User.objects.all().exists()
# res1 = models.User.objects.filter(name='jason',age=3).exists()
# print(res,res1)


# < 11 > values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
# model的实例化对象，而是一个可迭代的字典序列
# res = models.User.objects.values('name')  # 列表套字典
# res = models.User.objects.values('name','age')  # 列表套字典
# print(res)


# < 12 > values_list(*field): 它与values()
# 非常相似，它返回的是一个元组序列，values返回的是一个字典序列
# res = models.User.objects.values_list('name','age')  # 列表套元祖
# print(res)


# < 13 > distinct(): 从返回结果中剔除重复纪录  去重的对象必须是完全相同的数据才能去重
# res = models.User.objects.values('name','age').distinct()
# print(res)

神奇的双下划线语法

models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

models.Tb1.objects.filter(name__contains="ven")  # 获取name字段包含"ven"的
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感

models.Tb1.objects.filter(id__range=[1, 3])      # id范围是1到3的，等价于SQL的bettwen and

类似的还有：startswith，istartswith, endswith, iendswith

date字段还可以：
models.Class.objects.filter(first_day__year=2017)
date字段可以通过在其后加__year,__month,__day等来获取date的特点部分数据
# date
        #
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        # Entry.objects.filter(pub_date__year=2005)
        # Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        # Entry.objects.filter(pub_date__month=12)
        # Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        # Entry.objects.filter(pub_date__day=3)
        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        # Entry.objects.filter(pub_date__week_day=2)
        # Entry.objects.filter(pub_date__week_day__gte=2)
需要注意的是在表示一年的时间的时候，我们通常用52周来表示，因为天数是不确定的，老外就是按周来计算薪资的哦~

集锦
双下划线

多表操作

1 创建数据
    # 创建数据
    # models.Book.objects.create(title='红楼梦',price=66.66,publish_id=1)
    # models.Book.objects.create(title='西游记',price=25.52,publish_id=2)
    # models.Book.objects.create(title='三国演义',price=25.52,publish_id=2)
    publish_obj = models.Publish.objects.filter(pk=3).first()

    models.Book.objects.create(title='水浒传', price=88.88, publish=publish_obj)
创建数据

2 修改数据
    book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.publish_id=3
    # book_obj.save()
    # 基于对象
    publish_obj = models.Publish.objects.filter(pk=2).first()
    book_obj.publish = publish_obj
    book_obj.save()
3 删除数据
  # models.Book.objects.filter(pk=1).delete()
    # models.Publish.objects.filter(pk=1).delete()

    # book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.delete()

 

1. 正向查找（跨表）
语法：

对象.关联字段.字段

要点:先拿到外键关联多对一，一中的某个对象，由于外键字段设置在多的一方，所以这里还是借用Django提供的双下划线来查找

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

结论:如果想通过一的那一方去查找多的一方，由于外键字段不在一这一方，所以用__set来查找即可

2.字段查找

语法：

表名__字段

要点:直接利用双下滑线完成夸表操作

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

三、ManyToManyField

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

它存在于下面两种情况：

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

简单来说就是在多对多表关系并且这一张多对多的关系表是有Django自动帮你建的情况下，下面的方法才可使用。

创建数据
新增
直接写id
models.Book.objects.create(title='红楼梦',price=66.66,publish_id=1)
传数据对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='三国演义',price=199.99,publish=publish_obj)
修改数据
    修改
        queryset修改
        models.Book.objects.filter(pk=1).update(publish_id=3)
        publish_obj = models.Publish.objects.filter(pk=2).first()
        models.Book.objects.filter(pk=1).update(publish=publish_obj)
        对象修改
        book_obj = models.Book.objects.filter(pk=1).first()
        book_obj.publish_id = 3  # 点表中真实存在的字段名
        book_obj.save()
        publish_obj = models.Publish.objects.filter(pk=2).first()
        book_obj.publish = publish_obj  # 点orm中字段名 传该字段对应的表的数据对象
        book_obj.save()
删除
删除
models.Book.objects.filter(pk=1).delete()
models.Publish.objects.filter(pk=1).delete()

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.delete()

多对多需要掌握的方法

add()

把指定的model对象添加到第三张关联表中。

    给书籍绑定与作者之间的关系
    添加关系 add:add支持传数字或对象，并且都可以传多个
    book_obj = models.Book.objects.filter(pk=3).first()
    # book_obj.authors.add(1)
    # book_obj.authors.add(2,3)
    author_obj = models.Author.objects.filter(pk=1).first()
    author_obj1 = models.Author.objects.filter(pk=3).first()
    # book_obj.authors.add(author_obj)
    book_obj.authors.add(author_obj,author_obj1)

set()

更新某个对象在第三张表中的关联对象。不同于上面的add是添加,set相当于重置

    修改书籍与作者的关系  set()  set传的必须是可迭代对象！！！
    book_obj = models.Book.objects.filter(pk=3).first()
    可以传数字和对象，并且支持传多个
    book_obj.authors.set((1,))
    book_obj.authors.set((1,2,3))

    author_list = models.Author.objects.all()
    book_obj = models.Book.objects.filter(pk=3).first()
    book_obj.authors.set(author_list)

remove()

从关联对象集中移除执行的model对象(移除对象在第三张表中与某个关联对象的关系)

 # 删除书籍与作者的绑定关系
    # book_obj = models.Book.objects.filter(pk=3).first()
    # # book_obj.authors.remove(1)
    # # book_obj.authors.remove(2,3)
    # # author_obj = models.Author.objects.all().first()
    # author_list = models.Author.
    # objects.all()
    # # book_obj.authors.remove(author_obj)
    # book_obj.authors.remove(*author_list)  # 需要将queryset打散

clear()

从关联对象集中移除一切对象。(移除所有与对象相关的关系信息)

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

四、正向查询反向查询概念

# 正向与方向的概念解释

# 一对一
# 正向：author---关联字段在author表里--->authordetail		按字段
# 反向：authordetail---关联字段在author表里--->author		按表名小写
	# 查询jason作者的手机号   正向查询
	# 查询地址是 :山东 的作者名字   反向查询

# 一对多
# 正向：book---关联字段在book表里--->publish		按字段
# 反向：publish---关联字段在book表里--->book		按表名小写_set.all() 因为一个出版社对应着多个图书

# 多对多
# 正向：book---关联字段在book表里--->author		按字段
# 反向：author---关联字段在book表里--->book		按表名小写_set.all() 因为一个作者对应着多个图书



# 连续跨表
	# 查询图书是三国演义的作者的手机号，先查书，再正向查到作者，在正向查手机号

# 总结：基于对象的查询都是子查询，这里可以用django配置文件自动打印sql语句的配置做演示
    # 基于对象的表查询
    # 正向
    # 查询书籍是三国演义的出版社邮箱
    # book_obj = models.Book.objects.filter(title='三国演义').first()
    # print(book_obj.publish.email)
    # 查询书籍是的作者的姓名
    # book_obj = models.Book.objects.filter(title='').first()
    # print(book_obj.authors)  # app01.Author.None
    # print(book_obj.authors.all())
    # 查询作者为jason电话号码
    # user_obj = models.Author.objects.filter(name='jason').first()
    # print(user_obj.authordetail.phone)

    # 反向
    # 查询出版社是东方出版社出版的书籍                  一对多字段的反向查询
    # publish_obj = models.Publish.objects.filter(name='东方出版社').first()
    # print(publish_obj.book_set)  # app01.Book.None
    # print(publish_obj.book_set.all())

    # 查询作者jason写过的所有的书                      多对多字段的反向查询
    # author_obj = models.Author.objects.filter(name='jason').first()
    # print(author_obj.book_set)  # app01.Book.None
    # print(author_obj.book_set.all())

    # 查询作者电话号码是110的作者姓名                   一对一字段的反向查询
    # authordetail_obj = models.AuthorDetail.objects.filter(phone=110).first()
    # print(authordetail_obj.author.name)

    # 基于双下滑线的查询
    # 正向
    # 查询书籍为三国演义的出版社地址
    # res = models.Book.objects.filter(title='三国演义').values('publish__addr','title')
    # print(res)
    # 查询书籍为的作者的姓名
    # res = models.Book.objects.filter(title='啥蜀道难').values("authors__name",'title')
    # print(res)
    # 查询作者为jason的家乡
    # res = models.Author.objects.filter(name='jason').values('authordetail__addr')
    # print(res)

    # 反向
    # 查询南方出版社出版的书名
    # res = models.Publish.objects.filter(name='南方出版社').values('book__title')
    # print(res)
    # 查询电话号码为120的作者姓名
    # res = models.AuthorDetail.objects.filter(phone=120).values('author__name')
    # print(res)
    # 查询作者为jason的写的书的名字
    # res = models.Author.objects.filter(name='jason').values('book__title')
    # print(res)
    # 查询书籍为三国演义的作者的电话号码
    # res = models.Book.objects.filter(title='三国演义').values('authors__authordetail__phone')
    # print(res)

    # 查询jason作者的手机号
    # 正向
    # res = models.Author.objects.filter(name='jason').values('authordetail__phone')
    # print(res)
    # 反向
    # res = models.AuthorDetail.objects.filter(author__name='jason').values('phone')
    # print(res)

    # 查询出版社为东方出版社的所有图书的名字和价格
    # 正向
    # res = models.Publish.objects.filter(name='东方出版社').values('book__title','book__price')
    # print(res)
    # 反向
    # res = models.Book.objects.filter(publish__name='东方出版社').values('title','price')
    # print(res)

    # 查询东方出版社出版的价格大于400的书
    # 正向
    # res = models.Publish.objects.filter(name="东方出版社",book__price__gt=400).values('book__title','book__price')
    # print(res)
    # 反向
    # res = models.Book.objects.filter(price__gt=400,publish__name='东方出版社').values('title','price')
    # print(res)
查询例题

五、聚合查询和分组查询

1、聚合查询：利用用聚合函数

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

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

导入聚合函数

 # 聚合查询  aggregate
    from django.db.models import Max,Min,Count,Sum,Avg # 先导入
    # 查询所有书籍的作者个数
    # res = models.Book.objects.filter(pk=3).aggregate(count_num=Count('authors'))
    # print(res)
    # 查询所有出版社出版的书的平均价格
    # res = models.Publish.objects.aggregate(avg_price=Avg('book__price'))
    # print(res)  # 4498.636
    # 统计东方出版社出版的书籍的个数
    # res = models.Publish.objects.filter(name='东方出版社').aggregate(count_num=Count('book__id'))
    # print(res)

2、分组查询

 分组查询(group_by)   annotate
    # 统计每个出版社出版的书的平均价格
    # res = models.Publish.objects.annotate(avg_price=Avg('book__price')).values('name','avg_price')
    # print(res)
    # 统计每一本书的作者个数
    # res = models.Book.objects.annotate(count_num=Count('authors')).values('title','count_num')
    # print(res)
    # 统计出每个出版社卖的最便宜的书的价格
    # res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name','min_price')
    # print(res)
    # 查询每个作者出的书的总价格
    # res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name','sum_price')
    # print(res)

六、F查询与Q查询、事务

# F查询

F可以帮我们取到表中某个字段对应的值来当作我的筛选条件，而不是我认为自定义常量的条件了，实现了动态比较的效果

Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作

示例1

Django 提供 F() 来做这样的比较

from django.db.models import F
ret1=models.Product.objects.filter(maichu__gt=F('kucun'))
print(ret1)

将每个商品的价格提高50块 

models.Product.objects.update(price=F('price')+50)

引申：

如果要修改char字段咋办(千万不能用上面对数值类型的操作！！！)？

如：把所有书名后面加上'新款',(这个时候需要对字符串进行拼接Concat操作，并且要加上拼接值Value)

from django.db.models.functions import Concat
from django.db.models import Value
ret3=models.Product.objects.update(name=Concat(F('name'),Value('新款')))
# Concat表示进行字符串的拼接操作，参数位置决定了拼接是在头部拼接还是尾部拼接，Value里面是要新增的拼接值

# Q查询

filter() 等方法中逗号隔开的条件是与的关系。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象

示例:

查询 卖出数大于100 或者 价格小于100块的

from django.db.models import Q
models.Product.objects.filter(Q(maichu__gt=100)|Q(price__lt=100))

示例2：

查询 库存数是100 并且 卖出数不是0 的产品

models.Product.objects.filter(Q(kucun=100)&~Q(maichu=0))

我们可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。

同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询。

示例3：

查询产品名包含新款， 并且库存数大于60的

models.Product.objects.filter(Q(kucun__gt=60), name__contains="新款")

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

Q 查询补充

# 事务

事务的定义:将多个sql语句操作变成原子性操作，要么同时成功，有一个失败则里面回滚到原来的状态，保证数据的完整性和一致性(NoSQL数据库对于事务则是部分支持)

  # 事务
    # 买一本 跟老男孩学Linux 书
    # 在数据库层面要做的事儿
    # 1. 创建一条订单数据
    # 2. 去产品表 将卖出数+1， 库存数-1
    from django.db.models import F
    from django.db import transaction
    # 开启事务处理
    try:
        with transaction.atomic():
            # 创建一条订单数据
            models.Order.objects.create(num="110110111", product_id=1, count=1)
            # 能执行成功
            models.Product.objects.filter(id=1).update(kucun=F("kucun")-1, maichu=F("maichu")+1)
    except Exception as e:
        print(e)

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3