<1> all():                 查询所有结果
 
<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 
<3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 
<4> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
 
<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
 
<6> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<7> order_by(*field):      对查询结果排序
 
<8> reverse():             对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
 
<9> distinct():            从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             如果QuerySet包含数据，就返回True，否则返回False

1）惰性查询：只有在实际使用查询集中的数据的时候才会发生对数据库的真正查询。
2）缓存：当使用的是同一个查询集时，第一次使用的时候会发生实际数据库的查询，然后把结果缓存起来，之后再使用这个查询集时，使用的是缓存中的结果。

例：查询书名包含'传'的图书。contains
BookInfo.objects.filter(btitle__contains='传')

例：查询书名以'部'结尾的图书 endswith 开头:startswith
BookInfo.objects.filter(btitle__endswith='部')

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

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

例：查询书名不为空的图书。isnull
select * from booktest_bookinfo where btitle is not null;
BookInfo.objects.filter(btitle__isnull=False)

　__gt 大于
　　__gte 大于等于
　　__lt 小于
　　__lte 小于等于

例：查询id大于3的图书。

Select * from booktest_bookinfo where id>3;

BookInfo.objects.filter(id__gt=3)

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

例：查询id为1或3或5的图书。

select * from booktest_bookinfo where id in (1,3,5);
BookInfo.objects.filter(id__in = [1,3,5])

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(id__range=[1, 3])      # id范围是1到3的，等价于SQL的bettwen and

例：查询1980年发表的图书。

BookInfo.objects.filter(bpub_date__year=1980)

例：查询1980年1月1日后发表的图书。

from datetime import date

BookInfo.objects.filter(bpub_date__gt=date(1980,1,1))

date字段还可以：
models.Class.objects.filter(first_day__year=2017)

例：查询id不为3的图书信息。

BookInfo.objects.exclude(id=3)

作用：进行查询结果进行排序。

例：查询所有图书的信息，按照id从小到大进行排序。

BookInfo.objects.all().order_by('id')

例：查询所有图书的信息，按照id从大到小进行排序。

BookInfo.objects.all().order_by('-id')

例：把id大于3的图书信息按阅读量从大到小排序显示。

BookInfo.objects.filter(id__gt=3).order_by('-bread')

from django.db import models

# Create your models here.
from django.db import models

# Create your models here.


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

from django.shortcuts import render,HttpResponse

# Create your views here.


from app01 import models

def query(request):

    # #####################基于对象查询(子查询)##############################
    #                按字段（publish）
    # 一对多   book  ----------------->  publish
    #               <----------------
    #                 book_set.all()

    # 正向查询按字段：

    # 查询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)

    #                按字段（authors.all()）
    # 多对多   book  ----------------------->  author
    #               <----------------
    #                  book_set.all()


    # 查询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)

    #                  按字段 authorDetail
    # 多对多   author  ----------------------->  authordetail
    #                <----------------
    #                  按表名  author


    #查询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
    
    
    '''




    # #####################基于queryset和__查询（join查询）############################

    # 正向查询：按字段  反向查询：表名小写


    # 查询python这本书籍的出版社的邮箱
    # ret=models.Book.objects.filter(title="python").values("publish__email")
    # print(ret.query)

    '''
    select publish.email from Book 
    left join Publish on book.publish_id=publish.nid 
    where book.title="python"
    '''

    # 苹果出版社出版的书籍名称
    # 方式1：
    ret1=models.Publish.objects.filter(name="苹果出版社").values("book__title")
    print("111111111====>",ret1.query)
    #方式2：
    ret2=models.Book.objects.filter(publish__name="苹果出版社").values("title")
    print("2222222222====>", ret2.query)

    #查询alex的手机号
    # 方式1：
    ret=models.Author.objects.filter(name="alex").values("authorDetail__telephone")

    # 方式2：
    models.AuthorDetail.objects.filter(author__name="alex").values("telephone")

    # 查询手机号以151开头的作者出版过的书籍名称以及书籍对应的出版社名称

    ret=models.Book.objects.filter(authors__authorDetail__telephone__startswith="151").values('title',"publish__name")
    print(ret.query)


    return HttpResponse("OK")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

例：查询所有图书的数目。

BookInfo.objects.all().aggregate(Count('id'))

{'id__count': 5}

例：查询所有图书阅读量的总和。

BookInfo.objects.aggregate(Sum('bread'))

{'bread__sum': 126}

count函数 返回值是一个数字

作用：统计满足条件数据的数目。

例：统计所有图书的数目。

BookInfo.objects.all().count()

BookInfo.objects.count()

例：统计id大于3的所有图书的数目。

BookInfo.objects.filter(id__gt=3).count()

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}

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

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

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

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

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

>>> book_list = models.Book.objects.all().annotate(author_num=Count("author"))
>>> for obj in book_list:
...     print(obj.author_num)
...
2
1
1

>>> publisher_list = models.Publisher.objects.annotate(min_price=Min("book__price"))
>>> for obj in publisher_list:
...     print(obj.min_price)
...     
9.90
19.90

>>> models.Book.objects.values("publisher__name").annotate(min_price=Min("price"))
<QuerySet [{'publisher__name': '沙河出版社', 'min_price': Decimal('9.90')}, {'publisher__name': '人民出版社', 'min_price': Decimal('19.90')}]>

>>> models.Book.objects.annotate(author_num=Count("author")).filter(author_num__gt=1)
<QuerySet [<Book: 番茄物语>]>

>>> models.Book.objects.annotate(author_num=Count("author")).order_by("author_num")
<QuerySet [<Book: 香蕉物语>, <Book: 橘子物语>, <Book: 番茄物语>]>

>>> models.Author.objects.annotate(sum_price=Sum("book__price")).values("name", "sum_price")
<QuerySet [{'name': '小精灵', 'sum_price': Decimal('9.90')}, {'name': '小仙女', 'sum_price': Decimal('29.80')}, {'name': '小魔女', 'sum_price': Decimal('9.90')}]>

例：查询图书阅读量大于评论量图书信息。

BookInfo.objects.filter(bread__gt=F('bcomment'))

例：查询图书阅读量大于2倍评论量图书信息。

BookInfo.objects.filter(bread__gt=F('bcomment')*2)

from django.db.models import F
models.Book.objects.filter(commnet_num__gt=F('keep_num'))

models.Book.objects.filter(commnet_num__lt=F('keep_num')*2)

models.Book.objects.all().update(price=F("price")+30)

>>> from django.db.models.functions import Concat
>>> from django.db.models import Value
>>> models.Book.objects.all().update(title=Concat(F("title"), Value("("), Value("第一版"), Value(")")))

例：查询id大于3且阅读量大于30的图书的信息。

BookInfo.objects.filter(id__gt=3, bread__gt=30)

BookInfo.objects.filter(Q(id__gt=3)&Q(bread__gt=30))

例：查询id大于3或者阅读量大于30的图书的信息。

BookInfo.objects.filter(Q(id__gt=3)|Q(bread__gt=30))

例：查询id不等于3图书的信息。

BookInfo.objects.filter(~Q(id=3))

models.Book.objects.filter(Q(authors__name="小仙女")|Q(authors__name="小魔女"))

>>> models.Book.objects.filter(Q(author__name="小仙女") & ~Q(publish_date__year=2018)).values_list("title")
<QuerySet [('番茄物语',)]>

>>> models.Book.objects.filter(Q(publish_date__year=2018) | Q(publish_date__year=2017), title__icontains="物语")
<QuerySet [<Book: 番茄物语>, <Book: 香蕉物语>, <Book: 橘子物语>]>

entries = Entry.objects.select_for_update().filter(author=request.user)

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    import datetime
    from app01 import models

    try:
        from django.db import transaction
        with transaction.atomic():#原子性操作要么都成功，要么都失败
            new_publisher = models.Publisher.objects.create(name="火星出版社")
            models.Book.objects.create(title="橘子物语", publish_date=datetime.date.today(), publisher_id=10)  # 指定一个不存在的出版社id
    except Exception as e:
        print(str(e))

class Person(models.Model):
    first_name = models.CharField(...)
    last_name = models.CharField(...)
    birth_date = models.DateField(...)

>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):
...     print(p)

ret = models.Student.objects.raw('select id, tname as hehe from app02_teacher')
    for i in ret:
        print(i.id, i.hehe)

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher', translations=d)
    for i in ret:
        print(i.id, i.sname, i.haha)

d = {'tname': 'haha'}
    ret = models.Student.objects.raw('select * from app02_teacher where id > %s', translations=d, params=[1,])
    for i in ret:
        print(i.id, i.sname, i.haha)

from django.db import connection, connections
cursor = connection.cursor()  # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
ret = cursor.fetchone()

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

import os

if __name__ == '__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings")
    import django
    django.setup()

    from app01 import models

    books = models.Book.objects.all()
    print(books)