#获取id大于1且小于10的值
print(models.Book.objects.filter(id__lt=10,id__gt=1))
# 查询 id 在 [1, 4, 5, 7]中的结果
print(models.Book.objects.filter(id__in=[1,4,5,7]))
# contains 字段包含指定值的
print(models.Book.objects.filter(title__contains="小单"))
# icontains 忽略大小写包含指定值
print(models.Book.objects.filter(title__icontains="NI"))
# 判断id值在 哪个区间的 SQL语句中的between and  1<= <=3
print(models.Book.objects.filter(id__range=[1,3]))
# 日期和时间字段还可以有以下写法
ret = models.Person.objects.filter(birthday__year=2000)
ret = models.Person.objects.filter(birthday__year=2000, birthday__month=5)

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',)

View Code

 正向查询按字段：查询python这本书籍的出版社的邮箱python=models.Book.objects.filter(title="python").first()print(python.publish.email)反向查询按     表名小写_set.all()苹果出版社出版的书籍名称publish_obj=models.Publish.objects.filter(name="苹果出版社").first()for obj in publish_obj.book_set.all():print(obj.title)

    查询python作者的年龄python = models.Book.objects.filter(title="python").first()for author in python.authors.all():print(author.name ,author.age)查询alex出版过的书籍名称alex=models.Author.objects.filter(name="alex").first()for book in alex.book_set.all():print(book.title)

    查询alex的手机号alex=models.Author.objects.filter(name='alex').first()print(alex.authorDetail.telephone)查询家在山东的作者名字ad_list=models.AuthorDetail.objects.filter(addr="shandong")for ad in ad_list:print(ad.author.name)对应的sql：select publish_id from Book where title="python"select email from Publish where nid =   1

# 1.正向查询 基于对象 跨表查询
book_obj = models.Book.objects.all().first()  #对象
ret = book_obj.publisher  # 和我这本书关联的出版社对象
print(ret, type(ret))
ret = book_obj.publisher.name  # 和我这本书关联的出版社对象
print(ret, type(ret))
# 2.利用双下划线 跨表查询 双下划线就表示跨了一张表，基于Queryset
ret = models.Book.objects.filter(id=1).values_list("publisher__name")
print(ret) #等同于 print( models.Book.objects.all().first().publisher.name)
print("反向查询".center(80, "*"))
# 反向查询 1. 基于对象查询
publisher_obj = models.Publisher.objects.get(id=1)  # 得到一个具体的对象
# ret = publisher_obj.book_set.all()  #表名_set
ret = publisher_obj.books.all() #如果设置了related_name="books"
print(ret)
# 2. 基于双下划线 基于Queryset
ret = models.Publisher.objects.filter(id=1).values_list("book__title")
print(ret)

View Code

1.ORM中values或者values_list 里面写什么字段，就相当于select 什么字段ORM分组查询 每个部门名称及部门的平均年龄
ret = models.Employee.objects.all().values("dept", "age")
SQL语句
"""
SELECT `employee`.`dept`, `employee`.`age` FROM `employee` LIMIT 21; args=()
"""
2.ORM中 annotate 前面是什么就按照什么分组
from django.db.models import Avg
ret = models.Employee.objects.values("province").annotate(a=Avg("salary")).values("province", "a")
相当于：
SELECT `employee`.`province`, AVG(`employee`.`salary`) AS `a` FROM `employee` GROUP BY `employee`.`province` ORDER BY NULL LIMIT 21; args=()
print("分组查询".center(80, "*"))
3. ORM跨表分组查询，queryset对象跨表查询时使用双下划线
ret = models.Person.objects.values("dept_id").annotate(a=Avg("salary")).values("dept__name", "a")
反向：
"""
SELECT `dept`.`name`, AVG(`person`.`salary`) AS `a` FROM `person` INNER JOIN `dept` ON (`person`.`dept_id` = `dept`.`id`) GROUP BY `person`.`dept_id`, `dept`.`name` ORDER BY NULL LIMIT 21; args=()
"""
4.查询每一个部门的名称和人数
#正向查询：
models.emp.objects.values("dept_id").annotate(c=Count("name")).values("dept__name","c")
#反向查询
models.dep.objects.values("name").annotate(c=Count("emp__name")).values("name","c")
SQL: select dep_name Count(emp.name) from emp inner join dep on  .... group by dep_id5.查询每一个作者的名字及出版过的书籍的最高价
models.Author.objects.values('id').annotate(c=Max('book__price')).values("name","c")
##多对多的关系，在sql中跨了多张表
select __ from author inner join book_authors on .... inner join ... group by author.name
6.查询每一本书作者的个数
models.Book.objects.values("id").annotate(c=Count("authors__name")).values("title","c")

ret=models.Book.objects.all().annotate(author_num=Count("author"))
for book in ret:print("书名：{}，作者数量：{}".format(book.title, book.author_num))

#查询每一个分类的名称及对应的文章数 models.Category.objects.values("id").annotate(c=Count("article__title")).values("title","c") 7.统计不止一个作者的图书(过滤完后显示） models.Book.objects.values("title").annotate(c=Count("authors__name")).filter(c__gt=1).values('name',"c") 8.查询各个作者出的书的总价格 ret = models.Author.objects.all().annotate(price_sum=Sum("books__price")) for i in ret: print(i, i.name, i.price_sum)

# 查询person表，判断每个人的工资是否大于2000
ret = models.Person.objects.all().extra(select={"gt": "salary > 2000"}
)
相当于：
SELECT (salary > 2000) AS `gt`, `person`.`id`, `person`.`name`, `person`.`salary`, `person`.`dept_id` FROM `person` LIMIT 21; args=()

from django.db import connection
cursor = connection.cursor()  # 获取光标，等待执行SQL语句
cursor.execute("""SELECT * from person where id = %s""", [1])
row = cursor.fetchone()
print(row)

要对两个字段的值做比较,Django 提供 F() 来做这样的比较。
F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
1.查询评论数大于收藏数的书籍
from django.db.models import F
models.Book.objects.filter(commnet_num__gt=F('keep_num'))
2.Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)
3修改操作也可以使用F函数,比如将每一本书的价格提高30元
# 具体的对象没有update()，QuerySet对象才有update()方法
models.Book.objects.all().update(price=F("price")+30)
刷单 把每一本书的卖出数都乘以3
obj = models.Book.objects.first()
obj.maichu = 1000 * 3
obj.save()
4.给每一本书的书名后面加上 第一版
from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F("title"), Value("第一版")))

如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。
from django.db.models import Q
1.查询 卖出数大于1000，并且 价格小于100的所有书
ret = models.Book.objects.filter(maichu__gt=1000, price__lt=100)
print(ret)
2.查询 卖出数大于1000，或者 价格小于100的所有书
ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100))
3. Q查询和字段查询同时存在时， 字段查询要放在Q查询的后面
ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100), title__contains="金老板")

Q().children，通过字段字符串查询q=Q()##查询出title字段中值为go的对象q.children.append(("title","go"))Book.objects.filter(q)Out[11]: <QuerySet [<Book: go>]>##查询出title字段中值含有g的对象q.children.append(("title__contains","g"))Book.objects.filter(q)Out[13]: <QuerySet [<Book: go>]>q=Q()  #不同的字段之间的关系默认为andq.children.append(("title__contains","g"))q.children.append(("price",100))Book.objects.filter(q)Out[17]: <QuerySet []>q=Q()q.connector="or"  #不同的字段之间的关系更改为orq.children.append(("title__contains","g"))q.children.append(("price",100))Book.objects.filter(q)Out[22]: <QuerySet [<Book: go>]>