데이터 필터링 및 정렬

다음 방법을 사용하여 데이터를 필터링할 수 있습니다(SQLWHERE 절).

• filter(*args, **kwargs) -> QuerySet

• exclude(*args, **kwargs) -> QuerySet

• 겟(*Args,**kwargs) -> 모델

• get_or_none(*args, **kwargs) -> Optional[Model]

• get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

• all(*args, **kwargs) -> List[Optional[Model]]

• 쿼리 세트 에이전트

  • QuerysetProxy.filter(*args, **kwargs) 방법
  • QuerysetProxy.exclude(*args, **kwargs) 방법
  • QuerysetProxy.get(*args, **kwargs) 방법
  • QuerysetProxy.get_or_none(*args, **kwargs) 방법
  • QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) 방법
  • QuerysetProxy.all(*args, **kwargs) 방법

그리고 다음 방법(절별 SQL 순서)을 사용하여 데이터를 정렬합니다.

• order_by(columns:Union[List, str, OrderAction]) -> QuerySet
• 쿼리 세트 에이전트
  • QuerysetProxy.order_by(columns:Union[List, str, OrderAction]) 방법

필터

필터

filter(*args, **kwargs) -> QuerySet

모델 속성/필드별로 필터링하고 FK 관계 전반에 걸쳐 필터를 사용하여 인스턴스를 가져올 수 있습니다.

클래스 앨범(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)
    is_est_: bool = ormar. 부울(기본값 = 거짓)

클래스 트랙(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    앨범: 옵션 [앨범] = ormar. ForeignKey (앨범)
    이름: str = ormar. 문자열(max_long = 100)
    위치: int = ormar. 정수()
    플레이 카운트: int = ormar. 정수(nullable = 참)


추적 = 추적.개체.필터(이름 = "새") .get ()
#는 'The Bird'와 같은 이름의 트랙을 반환합니다.

트랙 = Track.ts.filter (__name = "Fantasies").all ()
#는 칼럼 앨범 이름 = 'Fantasies'가 있는 모든 트랙을 반환합니다.

장고 스타일 필터

특수 필터 접미사를 사용하여 필터 피연산자를 변경할 수 있습니다.

• 정확한 - 값과 정확히 일치, sql 열 =\ *는 앨범으로 쓸 수 있습니다 \ _ _name _\ _ = 'Malibuu'
• 정확하지 않음 - 정확한 일치 sql 열 =(대소문자 무감각)
  • 는 앨범__name__i='malibux'로 쓸 수 있습니다.
• 포함 - sql 열 좋아요'%%'*는 앨범으로 쓸 수 있습니다__이름__ 포함 = '말'
• 아이콘테인 - sql 열 LIKE '%%'(대소문자 무감각) \ * 앨범으로 쓸 수 있습니다 \ _ _name _\ _ containes = ' mal'
• in -sql column IN (<VALUE1>, <VALUE2>, ...)*는 album__name__in=['Malibu', 'Barclay'] 로 쓸 수 있습니다.
• Isnull - sql 열이 NULL(및 sql 열이 NULL이 아님)
  • 앨범으로 쓸 수 있습니다__이름__Isnull = True (isnot null 앨범__이름__isnull = 거짓)
• gt - sql 열 >(보다 큰) \ * 위치로 쓸 수 있습니다 \ _ _gt = 3
• gte - sql 열 > =(보다 크거나 같음) \ * 위치로 쓸 수 있습니다 \ _ _gte = 3
• lt - sql 열 <(아래) \ * 위치로 쓸 수 있습니다 \ _ lt = 3
• lte - sql 열 <=(보다 작거나 같음) \ * 위치로 쓸 수 있습니다 \ _ _lte = 3
• starswith - sql 열 LIKE'%'(정확한 시작 일치) \ * 앨범으로 쓸 수 있습니다 \ _ _name _\ _ starswith = ' Mal.
• istartswith - sql 열 LIKE'%' (대소문자 무감각) \ *album__name__istartswith='mal' 로 쓸 수 있습니다
• 끝 - sql 열 좋아요'%'(정확한 끝 일치) \ * 앨범으로 쓸 수 있습니다 \ _ _이름__endswith='ibu.'
• iendswith - sql 열 LIKE '%'(대소문자 무감각) \ * 앨범으로 쓸 수 있습니다 \ _ _name _\ _ iendswith = 'IBU'

일부 샘플:

# sql: (product.name= '테스트' 및 제품.등급>=3.0)
제품.개체.필터(이름 = '테스트', rating__gte = 3.0).get ()

# sql: (product.name= '테스트' 및 제품.등급>=3.0)
# 또는 (categories.name('장난감', '책'))
제품.개체.필터(
    Ormar. 또는 _ (
        Ormar.and_(이름 = '테스트', rating__gte = 3.0),
        카테고리 __name__in = ['장난감', '책'])
    ). 얻다 ()
# 참고: 자세한 내용은 아래의 복잡한 필터 섹션을 참조하십시오.

파이썬 스타일 필터

• 정확한 - 값과 정확히 일치, sql 열 =
  • Track.album.name==' 말리부로 쓸 수 있습니다.
• 정확하지 않음 - 정확한 일치 sql 열 =(대소문자 무감각)
  • 다음과 같이 쓸 수 있습니다. Track.album.name.iexact('malibu')
• 포함 - sql 열 '%%'*는 Track.album.name%'Mal'로 쓸 수 있음) *는 Track.album.name.contains('Mal') 로 쓸 수 있음
• 아이콘테인 - sql 열 LIKE '%%' (대소문자 무감각) \ *Track.album.name.icontains('mal') 로 쓸 수 있습니다
• -sql에서 column IN (<VALUE1>, <VALUE2>, ...) * 다음과 같이 쓸 수 있습니다. Track.album.name << ['Malibu', 'Barclay'] * 다음과 같이 쓸 수 있습니다. Track.album.name.in_(['Malibu', 'Barclay'])
• Isnull - sql 열이 NULL(및 sql 열이 NULL이 아님) * Track.album.name>> 없음\으로 쓸 수 있습니다.* Track.album.name isnull로 쓸 수 있습니다(참) * 다음과 같이 null이 아닌 것으로 쓸 수 있습니다. Track.album.name.isnull(False) * Null은 ~(Track.album.name>> 없음) * Null은 다음과 같이 쓸 수 없습니다. ~(Track.album.name.isnull(True))
• Gt - sql 열> (보다 더 큰) *는 Track.album.name>3으로 쓸 수 있습니다.
• Gte - sql 열 > = (보다 크거나 같음) *는 Track.album.name로 쓸 수 있습니다 > = 3
• lt - sql 열 <(아래) \ *로 쓸 수 Track.album.name<3
• lte - sql 열 <=(보다 작거나 같음) \ *로 쓸 수 Track.album.name <= 3
• 시작 - sql 열 LIKE'%' (정확한 시작 일치) \ *Track.album.name.startswith('Mal') 로 쓸 수 있습니다
• istartswith - sql 열 LIKE'%' (대소문자 무감각) \ *Track.album.name.istartswith('mal') 로 쓸 수 있습니다
• end with - sql 열 LIKE '%' (정확한 끝 일치) \ *Track.album.name.endswith('ibu') 로 쓸 수 있습니다
• iendswith - sql 열 LIKE '%' (대소문자 무감각) \ *Track.album.name.iendswith('IBU') 로 쓸 수 있습니다

일부 샘플:

# sql: (product.name= '테스트' 및 제품.등급>=3.0)
제품.개체.필터(
    (Product.name== '테스트') & (제품.등급>=3.0)
). 얻다 ()

# sql: (product.name= '테스트' 및 제품.등급>=3.0)
# 또는 (categories.name('장난감', '책'))
제품.개체.필터(
        (((Product.name== '테스트') & (제품.등급>=3.0)) |
        (Product.categories.name<['장난감', '책'])
    ). 얻다 ()

!!!행을 반환하지 않는 모든 메서드는 쿼리 세트 인스턴스를 명시적으로 반환하여 함께 연결할 수 있습니다.

따라서 `filter()`,`select_related()`,`limit()` 및 `offset()` 등과 같은 작업을 체인으로 연결할 수 있습니다.

뭔가 `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

!!!경고. 포함 및 기타 필터에서 % 와일드카드를 지정할 필요가 없으며 추가됩니다. 검색 값에 %를 포함하면 이스케이프되고 텍스트 내에서 문자 그대로 백분율 기호로 처리됩니다.

제외

exclude(*args, **kwargs) -> QuerySet

필터와 정확히 동일하게 작동하며 모든 한정자(접미사)는 동일하지만 not 조건이 반환됩니다.

따라서 필터(이름 = 'John')를 사용하는 경우 이는 여기서 이름 = 'John'과 동일합니다. 여기서 이름 = 'John')은 여기서 이름 <> 'John'과 동일합니다.

모든 조건이 연결되므로 여러 값을 통과하면 조건의 결합이 됩니다.

제외(이름 = '존', 나이 > = 35)가 됩니다. where not (name='John' and age>=35)

클래스 앨범(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)
    is_est_: bool = ormar. 부울(기본값 = 거짓)

클래스 트랙(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    앨범: 옵션 [앨범] = ormar. ForeignKey (앨범)
    이름: str = ormar. 문자열(max_long = 100)
    위치: int = ormar. 정수()
    플레이 카운트: int = ormar. 정수(nullable = 참)


참고 = Track.ts.(위치_gt = 3).all()을 기다립니다.
# 위치가 있는 모든 트랙을 반환합니다 <3

복잡한 필터(OR 포함)

기본적으로 필터() 및 제외() 메서드는 제공된 필터 옵션을 AND 조건과 결합하여 filter(name="John", age__gt=30) 가 WHERE name = 'John' AND age > 30 로 변환됩니다.

때로는 다음과 같이 공동으로 적용해서는 안 되는 조건을 사용하여 데이터베이스를 쿼리하는 것이 유용합니다. WHERE name = 'John' OR age > 30 또는 더 많은 제어를 원하는 복잡한 WHERE 쿼리를 구축하십시오. 결국 WHERE (name = 'John' OR age > 30) and city='New York' 완전히 다른 WHERE name = 'John' OR (age > 30 and city='New York') ...

OR 및 중첩 조건을 구축하기 위해 Ormar는 필터()에서 사용할 수 있는 두 가지 기능을 제공하며 Queryset 및 QuerysetProxy에서는 ()를 제외합니다.

!!!get() 또는 all()과 같이 \ * args를 수락하는 다른 방법에서 이러한 방법을 제공할 수 있습니다.

또는 _및 _에 대한 호출은 서로 내포되거나 키워드 인수와 결합될 수 있습니다. 실제보다 더 복잡하게 들리기 때문에 몇 가지 예를 살펴보겠습니다.

다음과 같은 예제 모델이 제공됩니다.

base_ormar_config = ormar. OrmarConfig (
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    메타데이터 = sqlalchemy. 메타데이터(),
)


클래스 작성자(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)


클래스 북(ormar. 모델):
    ormar_config = base_ormar_config 사본()

    ID: int = ormar. 정수(prial_key = 참)
    작성자: 선택 사항 [작성자] = ormar. 외래 키(작성자)
    제목: str = ormar. 문자열(max_long = 100)
    연도: int = ormar. 정수(nullable = 참)

몇 가지 예제 데이터를 만들어 보겠습니다.

톨킨 = 저자를 기다립니다(이름 = "J.R.R. 톨킨").저장()
기다리는 책 (작가 = 톨킨, 제목 = "호빗", 연도 = 1933년). 저장 ()
기다리는 책 (작가 = 톨킨, 제목 = "반지의 제왕", 연도 = 1955). 저장 ()
기다리는 책 (작가 = 톨킨, 제목 = "실마릴리언", 연도 = 1977). 저장 ()
Sapkowski = 저자를 기다립니다(이름 = "Andrzej Sapkowski").저장()
기다리는 책 (작가 = sapkowski, 제목 = "마녀", 연도 = 1990). 저장 ()
기다리고 있는 책 (작가 = sapkowski, 제목 = "바보의 탑", 연도 = 2002). 저장 ()

몇 가지 복잡한 쿼리를 만들 수 있습니다.

1970년 이후에 쓰여진 톨킨의 책이나 책을 선택합시다

SQL: WHERE ( authors.name = 'J.R.R. Tolkien' OR books.year > 1970 )

장고 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (ormar. 또는 _ (저자__name="J.R.R. 톨킨", year__gt=1970)
    . 모두 ()
)
주장 렌 (책) == 5

파이썬 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 ((Book.author.name== "J.R.R. 톨킨") | (북.년 > 1970))
    . 모두 ()
)
주장 렌 (책) == 5

이제 톨킨이 1960년 이후나 1940년 이전에 쓴 책을 골라봅시다.

SQL: WHERE ( books.year > 1960 OR books.year < 1940 ) AND authors.name = 'J.R.R. Tolkien'

장고 스타일

# 옵션 1 - 별도의 통화로 분할
책 = (
    북.ts._("저자")를 기다립니다.
    . 필터(ormar. 또는 _ (year__gt=1960, year__lt=1940))
    . 필터(저자__name="J.R.R. 톨킨")
    . 모두 ()
)
주장 렌 (책) == 2

# 옵션 2 - 모두 하나로
책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        Ormar. 그리고 _ (
            Ormar. 또는 _ (year__gt = 1960, year__lt = 1940),
            저자__name="J.R.R. 톨킨",
        )
    )
    . 모두 ()
)

주장 렌 (책) == 2
주장된 책들 [0]. 제목 == "호빗"
주장된 책들 [1]. 제목 == "The Silmarillion"

파이썬 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (((북.년 > 1960) | (북.년 <1940))
    . 필터(Book.author.name== "J.R.R. 톨킨")
    . 모두 ()
)
주장 렌 (책) == 2

# 옵션 2 - 모두 하나로
책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        (
            (북.이어>1960) | (북.이어<1940)
        ) & (Book.author.name== "J.R.R. 톨킨")
    )
    . 모두 ()
)

주장 렌 (책) == 2
주장된 책들 [0]. 제목 == "호빗"
주장된 책들 [1]. 제목 == "The Silmarillion"

2000년 이전의 Sapkowski의 책 또는 1960년 이후의 Tolkien의 책

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND authors.name = 'Andrzej Sapkowski' ) )

장고 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        Ormar. 또는 _ (
            Ormar. and _ (year__gt = 1960, er__name = "J.R.R. Tolkien"),
            Ormar. and _ (year__lt=2000, er__name="Andrzej Sapkowski"),
        )
    )
    . 모두 ()
)
주장 렌 (책) == 2

파이썬 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        ( ( ( ( ( ) ) & (Book.author.name== "J.R.R. 톨킨") ) |
        (((북.년 <2000) & (Book.author.name== "Andrzej Sapkowski"))
    )
    . 모두 ()
)
주장 렌 (책) == 2

물론 이러한 기능은 두 가지 이상의 조건을 가질 수 있으므로 "호빗"이 포함된 책을 원한다면 다음과 같습니다.

SQL: WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND os0cec_authors.name = 'Andrzej Sapkowski' ) OR books.title LIKE '%hobbit%' )

장고 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        Ormar. 또는 _ (
            Ormar. and _ (year__gt = 1960, er__name = "J.R.R. Tolkien"),
            Ormar. and _ (year__lt=2000, er__name="Andrzej Sapkowski"),
            제목 __아이콘테인 = "호빗",
        )
    )
    . 모두 ()
)

파이썬 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        ( ( ( ( ( ) ) & (Book.author.name== "J.R.R. 톨킨") ) |
        (((북.년 <2000) & (Book.author.name== "Andrzej Sapkowski")) |
        (북.제목.아이콘테인("호빗"))
    )
    . 모두 ()
)

원하거나 필요한 경우 다음 쿼리 구현과 같이 필요에 따라 더 깊은 조건을 중첩할 수 있습니다.

SQL:

어디 ( ( (
authors.name= 'J.R.R. 톨킨') 또는
(책.년 <2000 AND authors.name= 'Andrzej Sapkowski'))

다음과 같이 쿼리를 구성할 수 있습니다.

장고 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        Ormar. 또는 _ (
            Ormar. 그리고 _ (
                Ormar. 또는 _ (year__gt = 1960, year__lt = 1940),
                저자__name="J.R.R. 톨킨",
            ),
            Ormar. and _ (year__lt=2000, er__name="Andrzej Sapkowski"),
        )
    )
    . 모두 ()
)
주장 렌 (책) == 3
주장된 책들 [0]. 제목 == "호빗"
주장된 책들 [1]. 제목 == "The Silmarillion"
주장된 책들 [2]. 제목 == "마녀"

파이썬 스타일

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (
        (
            (
            (북.년 > 1960) |
            (책. 년 <1940)
            ) &
            (Book.author.name== "J.R.R. 톨킨")
        ) |
        (
            (북.이어 <2000) &
            (Book.author.name== "Andrzej Sapkowski")
        )
    )
    . 모두 ()
)
주장 렌 (책) == 3
주장된 책들 [0]. 제목 == "호빗"
주장된 책들 [1]. 제목 == "The Silmarillion"
주장된 책들 [2]. 제목 == "마녀"

이제 ormar.or\를 알아야 합니다._ 그리고 오마. 그리고 _ 물론 쿼리 세트의 다른 메서드에 연결할 수 있으므로 예제에서 완전히 유효한 쿼리는 다음과 같이 보일 수 있습니다.

책 = (
    북.ts._("저자")를 기다립니다.
    . 필터 (ormar. 또는 _ (year__gt = 1980, __name = "Andrzej Sapkowski")
    . 필터(title__starswith="The")
    . 한계 (1)
    . 오프셋 (1)
    . order_by ("-id")
    . 모두 ()
)
주장 렌 (책) ==1
주장된 책들 [0]. 제목 == "마녀"

이것은 파이썬 스타일의 연결 및 중첩에도 적용됩니다.

장고 스타일

Do 스타일에서는 동일한 키워드 인수를 여러 번 제공할 수 없으므로 다음과 같이 filter(ormar.or_(name='Jack', name='John')) 를 쿼리할 수 없습니다. 동일한 열에 대해 여러 값을 확인하려면 in:filter(name__in=['Jack','John']) 를 사용하십시오.

함수 또는 _또는 _에 하나의 인수만 전달되면 괄호로 묶여서 실제 쿼리에 영향을 미치지 않으므로 세 개의 쿼리가 모두 동일합니다.

대기 중인 책.개체.필터(제목 = '호빗').get()
책을 기다리세요. ts. 필터 (ormar.or_ (제목 = '호빗') .get ()
기다리다 북.ts.filter (ormar.and_ (제목 = 'The Hobbit')) .get ()

!!!메모 또는 _ 그리고 _ 쿼리에는 WHERE(제목 = 'The Hobbit')가 있지만 괄호는 중복되어 실제 효과가 없습니다.

동일한 필드 이름을 두 번 사용해야 하는 경우 이 기능을 사용할 수 있습니다. 동일한 키워드 인수를 함수에 두 번 전달할 수 없다는 점을 기억하십시오. 예에서 WHERE (authors.name LIKE '%tolkien%') OR (authors.name LIKE '%sapkowski%')) 를 어떻게 쿼리합니까?

당신은 이것을 할 수 없습니다.

책 = (
    북.ts._("저자")를 기다립니다.
        . 필터(ormar. 또는 _(
        저자 __name __아이콘테인 = "톨킨",
        작성자 __name __아이콘테인 = "sapkowski" # 또는 _에서 동일한 키워드를 두 번 사용할 수 없습니다!
    )) # python 구문 오류
        . 모두 ()
)

그러나 당신은 이것을 할 수 있습니다:

책 = (
    북.ts._("저자")를 기다립니다.
        . 필터(ormar. 또는 _(
        Ormar.and_ (저자 __name __아이콘테인 = "톨킨"), # 하나의 인수 == 방금 포장 ()
        Ormar and _ (저자 __name __아이콘테인 = "sapkowski")
    ))
        . 모두 ()
)
주장 렌 (책) == 5

파이썬 스타일

파이썬 스타일을 사용하면 동일한 필드를 필요에 따라 여러 번 사용할 수 있습니다.

책 = (
    북.ts._("저자")를 기다립니다.
        . 필터 (
        (Book.author.name
        (Book.author.name아이콘테인("sapkowski"))
    ))                                      
        . 모두 ()
)

겟

겟(*Args,**kwargs) -> 모델

kwargs 설정 조건을 만족하는 데이터베이스에서 첫 번째 행을 가져옵니다.

args 및/또는 kwargs를 전달할 때 필터를 호출하는 것과 같습니다(*Args,**kwargs).get () 바로 가기

!!!팁 필터에 대해 자세히 알아보려면 필터로 이동하십시오.

`get` 에 대해 자세히 알아보려면[읽기/가져오기](../read/#get)로 이동하십시오.

얻거나 아무것도

이는 위에서 설명한 것과 정확히 동일하지만 기준과 일치하는 데이터베이스 레코드를 찾을 수 없으면 예외가 발생하는 대신 없음이 반환됩니다.

획득 또는 생성

get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

방법의 조합을 만들고 가져옵니다.

args 및/또는 kwargs를 통과할 때 바로 가기를 호출하는 것과 같습니다. filter(*args, **kwargs).get_or_create()

!!!팁 필터에 대해 자세히 알아보려면 필터로 이동하십시오.

`get_or_create` 에 대해 자세히 알아보려면[read/get_or_create](../read/#get_or_create)로 이동하십시오.

!!!경고 지정된 항목이 없는 경우 기본 _key 열을 포함하되 이에 국한되지 않는 모델의 모든 필수 필드에 대해 kwargs를 전달해야 합니다(자동 증가가 아닌 경우).

모두

all(*args, **kwargs) -> List[Optional["Model"]]

필터 설정 옵션의 경우 지정된 모델에 대한 데이터베이스의 모든 행을 반환합니다.

kwargs를 통과할 때 필터링 바로 가기(*args,**kwargs)를 호출하는 것과 같습니다. 모두()

!!!팁 필터에 대해 자세히 알아보려면 필터로 이동하십시오.

에 대해 더 읽으려면 `all` 로 이동 [읽기/모두](../read/#all)

QuerysetProxy 방법

관련 ManyTo많이 필드 및 ReverseForeignKey에 직접 액세스하면 관련 모델 목록이 반환됩니다.

그러나 쿼리 세트 API의 하위 집합도 표시되므로 상위 모델에서 직접 필터링, 생성, 관련 모델 선택 등을 할 수 있습니다.

필터

위와 동일한 필터링 기능을 사용하지만 관계의 다른 쪽 끝에서 관련 개체를 필터링할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.

제외

제외 함수는 위와 정확히 동일하지만 관계의 반대편에서 관련 개체를 필터링할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.

겟

위의 get 함수와 동일하지만 관계의 다른 끝에서 관련 개체를 필터링할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.

얻거나 아무것도

이는 위에서 설명한 것과 정확히 동일하지만 기준과 일치하는 데이터베이스 레코드를 찾을 수 없으면 예외가 발생하는 대신 없음이 반환됩니다.

획득 또는 생성

위의 get \ _ 또는 \ _ 생성 함수와 정확히 동일하지만 관계의 다른 끝에서 관련 개체를 필터링할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.

모두

위의 모든 것과 동일하지만 관계의 반대편에서 관련 개체를 필터링할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.

정렬

주문 기준

order_by(columns: Union[List, str, OrderAction]) -> QuerySet

순서_by()를 사용하여 선택한 필드별로 데이터베이스의 결과를 정렬할 수 있습니다.

필드 이름이 있는 문자열 또는 다른 필드가 있는 문자열 목록을 제공할 수 있습니다.

SQL로 정렬하는 것은 순서대로 제공하는 이름의 순서로 적용됩니다.

팁

!!!경고: 중첩 모형별로 정렬하면 결과 행이 주 모형별로 정렬되지 않습니다. 그렇지 않으면 이 하위 행이 하나의 주 모형으로 병합됩니다.

원시 데이터베이스 행 결과 샘플(하위 모델 설명별로 정렬):
```
MODEL: 1 - Child Model - 3
MODEL: 2 - Child Model - 2
MODEL: 1 - Child Model - 1
```

두 줄의 결과가 발생합니다.
```
MODEL: 1 - Child Models: [3, 1] # encountered first in result, all children rows combined
MODEL: 2 - Child Models: [2]
```

기본 모델은 결과에서 복제되지 않습니다.

주어진 예제 모델은 다음과 같습니다.

import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL),
    metadata=sqlalchemy.MetaData(),
)


class Owner(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="owners")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


class Toy(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="toys")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    owner: Owner = ormar.ForeignKey(Owner)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    # build some sample data
    aphrodite = await Owner.objects.create(name="Aphrodite")
    hermes = await Owner.objects.create(name="Hermes")
    zeus = await Owner.objects.create(name="Zeus")

    await Toy.objects.create(name="Toy 4", owner=zeus)
    await Toy.objects.create(name="Toy 5", owner=hermes)
    await Toy.objects.create(name="Toy 2", owner=aphrodite)
    await Toy.objects.create(name="Toy 1", owner=zeus)
    await Toy.objects.create(name="Toy 3", owner=aphrodite)
    await Toy.objects.create(name="Toy 6", owner=hermes)


asyncio.run(run_query())

마스터 모델 필드별로 정렬하려면 필드 이름을 제공하기만 하면 됩니다.

장고 스타일

장난감 = 기다리다 장난감.ts._("소유자").order_by("이름").all()
장난감의 x에 대해 [x.name("장난감", "")을 주장하십시오] ==[
    범위 내 x에 대한 STR(x + 1) (6)
]
주장된 장난감 [0]. 소유자 == 제우스
주장된 장난감 [1]. 소유자 == 아프로디테

파이썬 스타일

장난감 = 기다리다 장난감.ts._ ("소유자") order_by (Toy.name) .all ()
장난감의 x에 대해 [x.name("장난감", "")을 주장하십시오] ==[
    범위 내 x에 대한 STR(x + 1) (6)
]
주장된 장난감 [0]. 소유자 == 제우스
주장된 장난감 [1]. 소유자 == 아프로디테

중첩 모델을 정렬하려면 '__'로 필드 이름을 구분하십시오.

모든 관계 유형을 정렬할 수 있습니다 -> Foreign Key, Reverse 가상 FK 및 ManyTo다양하다 필드를 이 방법으로 정렬할 수 있습니다.

장고 스타일

장난감 = 기다리다 장난감.ts._("소유자").order_by("소유자__name").all()
장난감 주장[0].owner.name== 장난감 [1].owner.name== "아프로디테"
장난감[2]을 주장합니다. owner.name== 장난감[3]. owner.name== "헤르메스"
장난감[4]을 주장합니다. owner.name== 장난감[5]. owner.name== "제우스"

파이썬 스타일

장난감 = 기다리다 장난감.ts._ ("소유자") order_by (Toy.owner.name) .all ()
장난감 주장[0].owner.name== 장난감 [1].owner.name== "아프로디테"
장난감[2]을 주장합니다. owner.name== 장난감[3]. owner.name== "헤르메스"
장난감[4]을 주장합니다. owner.name== 장난감[5]. owner.name== "제우스"

내림차순으로 정렬하려면 필드 이름 앞에 하이픈을 제공하십시오.

장고 스타일

소유자 =(
    기다립니다 소유자.ts._("장난감")
        . order_by ("- __ name")
        . 필터(이름 = "제우스")
        . 얻다 ()
)
주장owner.toys[0]. 이름 == "장난감 4"
주장owner.toys [1]. 이름 == "장난감 1"

파이썬 스타일

소유자 =(
    기다립니다 소유자.ts._("장난감")
        . order_by (Owner.toys.name())
        . 필터(Owner.name== "제우스")
        . 얻다 ()
)
주장owner.toys[0]. 이름 == "장난감 4"
주장owner.toys [1]. 이름 == "장난감 1"

!!!행을 반환하지 않는 모든 메서드는 쿼리 세트 인스턴스를 명시적으로 반환하여 함께 연결할 수 있습니다.

따라서 `filter()`,`select_related()`,`limit()` 및 `offset()` 등과 같은 작업을 체인으로 연결할 수 있습니다.

뭔가 `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

Ormar의 기본 정렬

데이터베이스의 행 순서를 보장할 수 없으므로 Ormar는 사용자가 직접 주문을 제공하지 않더라도 항상 각 (부분) 쿼리에 sql 절별로 주문을 발행합니다.

기본적으로 지정된 모델로 데이터베이스를 쿼리할 때 모델은 기본 _key 열에 따라 오름차순으로 정렬됩니다. 기본 동작을 변경하려면 Orders_by 매개 변수를 ormar_config에 제공하여 변경할 수 있습니다.

!!! 팁 모델 정렬 순서에 대해 자세히 알아보려면 설명서의 모델 섹션을 방문하십시오.

기본적으로 관계는 동일한 순서를 따르지만 순서_by 및 관련_order_by 매개 변수와의 관계를 제공하여 쿼리 중에 관련 모델이 로드되는 순서를 수정할 수 있습니다.

!!! 팁 모델 정렬 순서에 대한 자세한 내용을 보려면 문서의 관계 섹션을 방문하십시오.

주문_by 절은 다음 순서로 적용됩니다.

• 쿼리에서 _by() 호출을 명시적으로 전달합니다.
• 주문에 의한 관계_by 및 관련_order_by(있는 경우)
• 모델 ormar_config 개체 순서_by
• 모델의 기본 _key 열이 오름차순으로 표시됩니다(폴백, 위의 항목이 제공되지 않은 경우 사용).

단일 쿼리에서 항상 재정의할 수 있도록 하나의 소스에서만 주문을 각 모델에 적용합니다.

즉, 쿼리에서 모델에 대해 명시적 순서_by를 제공하면 관계 및 모델 순서 순서가 건너뜁니다.

관계 1을 제공하면 모델 순서가 건너뜁니다.

마지막으로 모델을 제공하는 경우 기본 _key의 기본값은 건너뜁니다.

QuerysetProxy 방법

관련 ManyTo많이 필드 및 ReverseForeignKey에 직접 액세스하면 관련 모델 목록이 반환됩니다.

그러나 쿼리 세트 API의 하위 집합도 표시되므로 상위 모델에서 직접 필터링, 생성, 관련 모델 선택 등을 할 수 있습니다.

주문 기준

위의 순서_by 함수와 정확히 동일하지만 관계의 반대편에서 관련 개체를 정렬할 수 있습니다.

!!!QuerysetProxy에 대해 자세히 알아보려면 QuerysetProxy 섹션을 방문하십시오.