django 에서 F 와 Q 조회 사용

F 조회
위의 모든 예 에서 우리 가 만 든 필 터 는 필드 값 을 우리 가 설정 한 상수 와 비교 할 뿐이다.만약 우리 가 두 필드 의 값 을 비교 하려 고 한다 면 어떻게 해 야 합 니까?
Django 는 F()를 제공 하여 이런 비 교 를 합 니 다.F()의 인 스 턴 스 는 검색 에서 필드 를 참조 하여 같은 model 인 스 턴 스 의 두 필드 의 값 을 비교 할 수 있 습 니 다.
예시 1:
판매 수량 이 재고 수량 보다 많은 상품 을 조회 하 다.

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

F 는 표 의 한 필드 에 대응 하 는 값 을 가 져 와 서 제 선별 조건 으로 삼 을 수 있 습 니 다.제 가 생각 하 는 상수 의 조건 이 아니 라 동적 비교 효 과 를 실현 할 수 있 습 니 다.
Django 는 F()대상 과 F()대상 과 상수 사이 의 가감 승제 와 취 모 를 지원 합 니 다.이 를 바탕 으로 표 의 수치 유형 에 대해 수학 연산 을 할 수 있 습 니 다.
각 상품 의 가격 을 50 위안 올리다

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

설명:
char 필드 를 수정 하려 면 어떻게 합 니까?
예 를 들 어 모든 책 이름 뒤에'신형'을 추가 합 니 다.

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 에 추가 할 연결 값 입 니 다.
질문
filter()등 방법 에서 쉼표 를 분리 하 는 조건 은 관계 입 니 다.더 복잡 한 조회(예 를 들 어 OR 구문)를 실행 하려 면 Q 대상 을 사용 할 수 있 습 니 다.
예시 1:
조회 매출 이 100 위안 이상 이거 나 가격 이 100 위안 이하 인 경우

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

조건 부 패키지 1 층 Q 시 filter 는 교차 및 비교 부 호 를 지원 합 니 다.
예시 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 대상 이 나타 나 면 모든 키워드 인자 앞 에 있어 야 합 니 다.
사무.
트 랜 잭 션 의 정의:여러 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)

기타 잘 알려 지지 않 은 조작
Django ORM 이 네 이 티 브 SQL 을 실행 합 니 다.
조건 가설:블 로그 원 을 예 로 들 면 우리 가 쓴 블 로 그 는 연월 일 에 따라 분류 되 는 것 이 아니 라 연월 에 따라 분류 되 는 것 이다.그리고 우리 의 DateField 시간 형식 은 연월 일 형식 이다.즉,우 리 는 데이터베이스 에서 받 은 시간 형식의 데 이 터 를 다시 한 번 처리 하여 우리 가 원 하 는 시간 형식 을 가 져 와 야 한 다 는 것 이다.이런 수 요 는Django 는 우리 에 게 방법 을 제공 하지 않 았 습 니 다.우리 가 직접 처리 문 구 를 써 야 합 니 다.

# 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()

QuerySet 방법 대전
몇 가지 비교적 중요 한 방법:
update()와 save()의 차이
둘 다 데이터 에 대한 수정 저장 작업 이지 만 save()함 수 는 데이터 열 에 있 는 모든 데이터 항목 을 다시 쓰 는 것 이 고 update()는 수 정 된 항목 에 대한 업데이트 효율 이 높 고 시간 이 적 습 니 다.
그래서 나중에 데이터 수정 저장 용 update()
select_related 와 prefetchrelated
def select_related(self, *fields)
성능 관련:표 간 에 join 연결 표 작업 을 하여 관련 데 이 터 를 한꺼번에 가 져 옵 니 다.
요약:
1. select_related 는 주로 일대일 과 다 대 일 관 계 를 최적화 시킨다.
2. select_related 는 SQL 의 JOIN 문 구 를 사용 하여 최적화 시 키 고 SQL 조회 횟수 를 줄 여 최적화 시 키 고 성능 을 향상 시킨다.
def prefetch_related(self, *lookups)
성능 관련:다 중 표 연결 작업 시 속도 가 느 리 고 여러 번 SQL 조 회 를 통 해 Python 코드 에서 연결 작업 을 수행 합 니 다.
요약:
1.멀 티 필드(ManyToMany Field)와 한 쌍 의 멀 티 필드 에 prefetch 를 사용 할 수 있 습 니 다.related()를 최적화 합 니 다.
2. prefetch_related()의 최적화 방식 은 각각 표를 조회 한 다음 에 Python 으로 그들의 관 계 를 처리 하 는 것 이다.lated

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)

QuerySet 방법 대전

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################

def all(self)
#          

def filter(self, *args, **kwargs)
#     
#      ：  ，  ，Q

def exclude(self, *args, **kwargs)
#     
#      ：  ，  ，Q

def select_related(self, *fields)
    ：     join    ，          。

  ：
1. select_related                。
2. select_related  SQL JOIN      ，    SQL          、    。

def prefetch_related(self, *lookups)
    ：           ，       SQL   Python         。

  ：
1.        （ManyToManyField）      ，    prefetch_related()     。
2. prefetch_related()             ，   Python         。

def annotate(self, *args, **kwargs)
#       group by  

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

v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
# SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
# SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
# SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
#   distinct  
models.UserInfo.objects.values('nid').distinct()
# select distinct nid from userinfo

 ：   PostgreSQL     distinct    

def order_by(self, *field_names)
#     
models.UserInfo.objects.all().order_by('-id','age')

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
#              ， ：   

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

def reverse(self):
#   
models.UserInfo.objects.all().order_by('-nid').reverse()
#  ：    order_by，reverse    ，           


def defer(self, *fields):
models.UserInfo.objects.defer('username','id')
 
models.UserInfo.objects.filter(...).defer('username','id')
#         

def only(self, *fields):
#         
models.UserInfo.objects.only('username','id')
 
models.UserInfo.objects.filter(...).only('username','id')

def using(self, alias):
        ，     （setting    ）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
#     SQL
models.UserInfo.objects.raw('select * from userinfo')

#   SQL     ，          UserInfo       
models.UserInfo.objects.raw('select id as nid from    ')

#    SQL    
models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

#               
name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

#      
models.UserInfo.objects.raw('select * from userinfo', using="default")

###################   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() # fetchall()/fetchmany(..)


def values(self, *fields):
#            

def values_list(self, *fields, **kwargs):
#          

def dates(self, field_name, kind, order='ASC'):
#                        
# kind   ："year"（ ）, "month"（ - ）, "day"（ - - ）
# order   ："ASC" "DESC"
#          
- year :  -01-01
- month:  - -01
- day :  - - 

models.DatePlus.objects.dates('ctime','day','DESC')

def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
#                        ，            
# kind    "year", "month", "day", "hour", "minute", "second"
# order   ："ASC" "DESC"
# tzinfo    
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

"""
pip3 install pytz
import pytz
pytz.all_timezones
pytz.timezone(‘Asia/Shanghai')
"""

def none(self):
#  QuerySet  


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
#     ，          
from django.db.models import Count, Avg, Max, Min, Sum
result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
===> {'k': 3, 'n': 4}

def count(self):
#     

def get(self, *args, **kwargs):
#       

def create(self, **kwargs):
#     

def bulk_create(self, objs, batch_size=None):
#     
# batch_size         
objs = [
models.DDD(name='r11'),
models.DDD(name='r22')
]
models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
#     ，   ，  ，  
# defaults      ，      
obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})

def update_or_create(self, defaults=None, **kwargs):
#     ，   ，  ，  
# defaults               
obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})

def first(self):
#      

def last(self):
#       

def in_bulk(self, id_list=None):
#     ID    
id_list = [11,21,31]
models.DDD.objects.in_bulk(id_list)

def delete(self):
#   

def update(self, **kwargs):
#   

def exists(self):
#      

django 에서 F 와 Q 조회 에 사용 되 는 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 django F 와 Q 조회 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!