모델 방법

!!!팁과 데이터베이스의 주요 상호 작용은 do orm과 유사하게 각 모델에서 Model.로 노출된 Query세트 개체를 통해 노출됩니다.

**쿼리, 필드 제외 테이블 가입 등에 대해 자세히 알아보려면[쿼리][queries]섹션을 방문하십시오.**

각 모델 인스턴스에는 저장, 업데이트 또는 로드하는 일련의 방법이 있습니다.

사용 가능한 방법은 다음과 같습니다.

현학적인 방법

각 ormar에 유의하십시오. 모델도 pydantic입니다. BaseModel, 따라서 모든 pydantic 방법을 모델, 특히 모델 _dump() 및 모델 _dump_json() 메서드에서도 사용할 수 있으며, 제외, 포함 및 기타 매개 변수도 허용할 수 있습니다.

자세한 내용을 보려면 pydantic 문서를 확인하십시오.

모델_구조()

모델_구조는 새 인스턴스를 구성하는 데 사용되는 __init__ 메서드와 동일한 원본입니다.

차이점은 모델 _가 유효성 검사를 건너 뛰기 때문에 데이터가 정확하고 신뢰할 수 있다는 것을 알 때 사용해야 한다는 것입니다. 구성 사용의 이점은 유효성 검사를 건너 뛰기로 인한 실행 속도입니다.

!!!pydantic.Model_ 방법과 달리 ormar 등가는 중첩 관련 모델도 처리합니다.

경고, 유효성 검사를 건너뛰기 때문에 생성자가 변환, 검사 등을 수행하지 않습니다. 따라서 데이터베이스에서 유효하고 사용할 수 있는 데이터를 제공하는 것은 귀하의 책임입니다.

구성이 여전히 수행하는 유일한 두 가지는 다음과 같습니다.

*  필드를 설정하지 않기 위한 `default` 값 제공
*  사전 또는 기본 키 값을 전달하면 중첩 ormar 모델 초기화

모델 덤프()

Model_dump는 Pydantic에서 상속된 메서드이지만 Ormar는 자체 매개 변수를 추가하고 기본값을 사용하는 데 약간의 뉘앙스가 있으므로 명확성을 위해 여기에 나열되어 있습니다.

모델 _dump는 모델 트리에서 사전으로 데이터를 내보냅니다.

모델 _dump 매개 변수 설명:

포함(또는 수정)

include: Union[Set, Dict] = None

반환된 사전에 포함할 필드 이름 또는 사전 집합입니다.

pydantic에는 인덱스별 목록에서 필드를 포함하거나 제외하는 드문 패턴이 있습니다(중첩 모델도 마찬가지입니다). 모든 하위 항목에서 필드를 제외하려면 __all__ 키를 사전에 전달해야 합니다.

pydantic의 세트에서는 중첩 모델을 제외할 수 없지만 ormar에서는 (관계형 이름에 이중 밑줄을 추가하여 사용할 수 있는 책의 범주 이름 제외)exclude={"book__category__name"} 를 제외할 수 있습니다.

Ormar는 인덱스 제외/포함을 지원하지 않으며 단순화되고 사용자 친화적인 표기법을 사용합니다.

중첩 필드를 포함하여 필드를 포함/제외하는 방법을 확인하려면 설명과 광범위한 예제가 있는 필드 섹션을 확인하십시오.

!!!실제로 ormar에서는 컬렉션에서 중첩 모델을 제외할 수 있으며 응답 _ 모델 _ 제외 및 응답 _ 모델 _ 포함의 전체 모델 트리에서 제외할 수 있습니다!

제외(또는 수정)

exclude: Union[Set, Dict] = None

반환된 사전에서 제외할 필드 이름의 모음 또는 사전입니다.

pydantic에는 인덱스별 목록에서 필드를 포함하거나 제외하는 드문 패턴이 있습니다(중첩 모델도 마찬가지입니다). 모든 하위 항목에서 필드를 제외하려면 __all__key를 사전에 전달해야 합니다.

pydantic의 세트에서는 중첩 모델을 제외할 수 없지만 ormar에서는 (관계 이름에 이중 밑줄을 추가하여, 즉 사용 중인 책의 범주 이름 제외)exclude={"book__category__name"} 를 제외할 수 있습니다.

Ormar는 인덱스 제외/포함을 지원하지 않으며 단순화되고 사용자 친화적인 표기법을 사용합니다.

중첩 필드를 포함하여 필드를 포함/제외하는 방법을 확인하려면 설명과 광범위한 예제가 있는 필드 섹션을 확인하십시오.

!!!실제로 ormar에서는 컬렉션에서 중첩 모델을 제외할 수 있으며 응답 _ 모델 _ 제외 및 응답 _ 모델 _ 포함의 전체 모델 트리에서 제외할 수 있습니다!

제외_설정 취소

설정되지 않은 제외: 부울 = 거짓

플래그는 모델을 만들 때 명시적으로 설정되지 않은 필드를 반환된 사전에서 제외해야 하는지 여부를 나타냅니다.

!!!경고: 데이터를 데이터베이스에 저장한 후 각 필드에는 사용자가 제공할 수 있는 고유한 값 ->이 있습니다. 기본값 또는 없음.

즉, 데이터베이스에서 데이터를 로드할 때**모든**필드가 설정되고 이 플래그가 기본적으로 작동을 중지합니다!


클래스 카테고리(ormar. 모델):
    ormar_config = base_ormar_config (테이블 이름 = "카테고리")

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100, 기본값 = "테스트")
    가시성: bool = ormar. 부울(기본값 = 참)


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

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)
    가격: 플로트 = 오마. 플로트(기본값 = 9.99)
    카테고리: 목록 [카테고리] = ormar. 많은 것 (카테고리)

카테고리 = 카테고리 (이름 = "테스트 2")
주장 카테고리 model_dump () == {'id': 없음, '항목': [], '이름': '테스트 2',
                           '가시성': 참}
범주를 주장하십시오. model_dump (t_unset = True) == {'items': [], 'name': 'Test 2'}

기다려category.save()
카테고리 2 = 카테고리를 기다립니다.
범주를 주장하십시오. model_dump () == {'id': 1, '항목': [], '이름': '테스트 2',
                            '가시성': 참}
# db에서 로드한 후 모든 필드가 명시적으로 설정된 방법에 유의하십시오.
# db에서 모델을 채울 때 이런 일이 발생합니다.
ymodel_dump 주장 (t_unset = True) == {'id': 1, '항목': [ ],
                                              '이름': '테스트 2', '가시성': 참}

기본값 제외

exclude_defaults: bool = False

기본값(설정 여부에 관계없이)과 동일함을 나타내는 플래그는 반환된 사전에서 제외해야 합니다.

클래스 카테고리(ormar. 모델):
    ormar_config = base_ormar_config (테이블 이름 = "카테고리")

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100, 기본값 = "테스트")
    가시성: bool = ormar. 부울(기본값 = 참)

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

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)
    가격: 플로트 = 오마. 플로트(기본값 = 9.99)
    카테고리: 목록 [카테고리] = ormar. 많은 것 (카테고리)

카테고리 = 카테고리 ()
# 정수 pk는 기본적으로 자동 증분이므로 선택 사항입니다.
범주를 주장하십시오. model_dump () == {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
범주를 주장하십시오. model_dump (t_de=참) == {'items': []}

# 데이터를 저장하고 다시 로드합니다.
기다려category.save()
카테고리 2 = 카테고리를 기다립니다.

범주를 주장합니다. model_dump () == {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
범주를 주장합니다. model_dump (t_de=참) == {'id': 1, 'items': []}

제외_없음

제외_없음: 부울 = 거짓

플래그는 반환된 사전에서 없음과 동일한 필드를 제외해야 하는지 여부를 나타냅니다.

클래스 카테고리(ormar. 모델):
    ormar_config = base_ormar_config (테이블 이름 = "카테고리")

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100, 기본값 = "테스트", nullable = True)
    가시성: bool = ormar. 부울(기본값 = 참)


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

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100)
    가격: 플로트 = 오마. 플로트(기본값 = 9.99)
    카테고리: 목록 [카테고리] = ormar. 많은 것 (카테고리)


카테고리 = 카테고리 (이름 = 없음)
주장 카테고리 model_dump () == {'id': 없음, '항목': [], '이름': 없음,
                           '가시성': 참}
# ID가 아직 설정되지 않았으므로 없음 및 제외
범주를 주장하십시오. model_dump (제외 _ 없음 = 참) == {'items': [], 'visibility': True}

기다려category.save()
카테고리 2 = 카테고리를 기다립니다.
범주를 주장하십시오. model_dump () == {'id': 1, '항목': [], '이름': 없음,
                            '가시성': 참}
ymodel_dump를 주장하십시오(제외 _ 없음 = 참) == {'id': 1, '항목': [ ],
                                             '가시성': 참}

_ 기본 _ 키 제외(ormar 전용)

exclude_primary_keys: bool = False

플래그를 참으로 설정하면 중첩 모델을 포함하여 트리의 모든 기본 키 열이 제외됩니다.

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

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

항목 1 = 항목(id = 1, 이름 = "테스트 항목")
주장 항목1. model_dump () == {"id": 1, "name": "Test Item"}
주장 item1.model_dump (t_prial_key = 참) == {"name": "Test Item"}

_스루_모델 제외(ormar 전용)

exclude_through_models: bool = False

통과 모델은 각 다대다 관계에 대해 자동으로 추가되며 링크된 모델/테이블에 추가 매개 변수가 있습니다.

_스루_모델을 제외한 설정 = True는 하위 모델의 패스스루 모델을 포함하여 모든 패스스루 모델을 제외합니다.

클래스 카테고리(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 = 참)
    이름: str = ormar. 문자열(max_long = 100)
    카테고리: 목록 [카테고리] = ormar. 많은 것 (카테고리)

# 모델을 정의하는 나무
item_dict={
            "이름": "테스트",
            "카테고리": [{"name": "test cat"}, {"name": "test cat2"}],
        }
# 나무 전체를 구하다
대기 항목(**item_dict). save_ (팔로우 = 트루, save_all = 트루)

# 저장된 값 가져오기
항목 = Item.ts._("") .get()을 기다립니다.

# 기본적으로 전체 모델(항목 범주)을 볼 수 있습니다.
주장 항목. model_dump () == {'id': 1, '이름': '테스트',
                       '카테고리': [
                           {'Id': 1, '이름': '테스트 고양이',
                            '항목 범주': {'id': 1, 'category': None, 'item': None}}, 
                           {'ID':2, '이름': '테스트 캣2',
                            '항목 범주': {'id': 2, 'category': None, 'item': None}}
                       ]}

# 해당 필드/모델을 제외할 수 있습니다.
주장 항목. model_dump (t_through_=참) =={
                       'ID': 1, '이름': '테스트',
                       '카테고리': [
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

모델_dump_json()

모델_dump_json()의 매개 변수는 모델_dump()와 정확히 동일하므로 위의 내용을 확인하십시오.

물론 최종 결과는 사전이 아니라 JSON으로 대표되는 문자열입니다.

Get_pydantic ()

get_pydantic(include: Union[Set, Dict] = None, exclude: Union[Set, Dict] = None)

이 방법을 사용하면 모든 필드를 다시 입력하지 않고도 Ormar 모델에서 Pydantic 모델을 생성할 수 있습니다.

중첩 모델이 있는 경우 전체 Pydantic 모델 트리가 생성됩니다! 그러나 순환 참조 문제를 방지하는 방식으로.

또한 제외 항목을 전달하거나 매개 변수를 포함시켜 중첩 모델을 포함하여 원하는 필드만 유지할 수 있습니다.

즉, FastAPI에서 요청 및 응답에 대한 Pydantic 모델을 쉽게 만들 수 있습니다.

!!! 참고 가능한 제외/포함 및 제외 사전 또는 설정을 작성하는 방법에 대해 자세히 알아보려면 설명서의 필드 섹션을 방문하십시오.

주어진 ormar 모델의 예는 다음과 같습니다.

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


클래스 카테고리(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 = 참)
    이름: str = ormar. 문자열(max_long = 100, 기본값 = "테스트")
    카테고리: 옵션 [카테고리] = ormar. 외래 키(카테고리, nullable = True)

간단한 호출로 Pydantic 모델을 생성할 수 있습니다.

1	`피단티 카테고리 = 카테고리. get_pydantic (포함 ={"id", "name"})`

그러면 다음과 같은 모델이 생성됩니다.

클래스 카테고리(기본 모델):
    ID: 옵션 [int]
    이름: 옵션 [str] = "테스트"

!!! 경고, 모듈에 같은 이름의 클래스가 여러 개 있는 것은 좋은 습관이 아니며 Fasapi 문서를 위반할 것입니다. 그렇기 때문에 ormar는 클래스 이름에 대문자 3 개를 랜덤으로 추가합니다. 위의 예에서 이것은 클래스의 이름이 실제로 카테고리 _XIP(BaseModel)임을 의미합니다.

중첩 필드를 제외하거나 포함하려면 사전 또는 이중 밑줄을 사용할 수 있습니다.

# 두 통화 모두 동일합니다.
피단티 카테고리 = 카테고리. get_pydantic (포함 ={"id", "items__id"})
Pydanticory = ory. get_pydantic(포함 = {"id":. .., "항목":{"id"}})

결과 구조는 다음과 같습니다.

클래스 항목(기본 모델):
    ID: 옵션 [int]

클래스 카테고리(기본 모델):
    ID: 옵션 [int]
    항목: 선택 사항 [목록 [항목]]

물론 깊이 내포된 구조를 사용할 수도 있으며 Ormar는 루프를 제외한 방식으로 Pydantic 등가물을 생성합니다.

Ormar에서 관계가 양방향(및 ormar)임에도 불구하고 위의 항목 모델이 범주에 대한 참조가 없는 방법에 주목하십시오. 항목에는 범주 필드가 있습니다.)

경고: 결과 Pydantic 모델은 Pydantic.ator 데코레이터를 사용하여 정의된 Ormar 선택 검증자 및 검증자를 포함하여 원래 Ormar 모델에서 모든 필드 검증자를 상속합니다.

그러나 동시에 모든 루트 검증자가 에 있습니다. `ormar` 모델이 될 것입니다 **아니** 생성된 피단틱 모델에 복사됩니다.

루트 검증자는 모든 필드에서 작동할 수 있고 사용자는 피단틱 모델을 생성하는 동안 일부 필드를 제외할 수 있으므로 해당 검증자를 복사하는 것은 안전하지 않습니다. 필요한 경우 피단틱 모델을 생성하려면 해당 모델을 재정의/수동으로 복사해야 합니다.

로드()

기본적으로 관련 모델을 미리 입력하지 않고 테이블을 쿼리할 때 Ormar는 여전히 관련 모델을 구성하지만 pk 값으로만 채웁니다. 로드() 메서드를 호출하여 관련 모델을 로드할 수 있습니다.

다른 프로세스에 의해 모델이 변경된 경우 로드()를 사용하여 데이터베이스에서 모델을 새로 고칠 수도 있습니다.

추적 = 대기 추적.ts.get (이름 = '새')
track.album.pk#은 말리부 앨범 pk를 반환할 것입니다 (1)
track.album.name

# 실제로 데이터를 먼저 로드해야 합니다.
트랙을 기다리고 있습니다.알범.로드()
track.album.name#는 '말리부'를 반환할 것입니다.

모두 로드 ()

load_all(follow: bool = False, exclude: Union[List, str, Set, Dict] = None) -> Model

메소드는 로드()와 유사하게 작동하지만 메소드를 호출한 모델의 모든 관계를 반복하고 데이터베이스에서 다시 로드합니다.

기본적으로 로드_all 메서드는 메서드를 호출하는 모델과 직접 관련된(한 단계 떨어진) 모델만 로드합니다.

그러나 다음 = 참 매개 변수를 지정하여 중첩된 모델을 반복하고 모두 관계 트리에 로드할 수 있습니다.

경고: 팔로우 = 트루 설정으로 반복되는 업데이트를 방지하기 위해 load_all은 방문한 모델 집합을 유지하고 방문한 모델에 중첩 로드를 수행하지 않습니다.

따라서 다이아몬드 또는 원형 관계 유형이 있는 경우 수동으로 부하를 수행해야 합니다.

```python
# in example like this the second Street (coming from City) won't be load_all, so ZipCode won't be reloaded
Street -> District -> City -> Street -> ZipCode
```

메소드는 또한 쿼리 세트의 필드 제외 메서드와 동일하게 작동하는 선택적 제외 매개 변수를 허용합니다. 이렇게 하면 새로 고치는 관련 모델에서 필드를 제거하거나 전체 관련 모델을 건너뛸 수 있습니다.

메소드는 데이터베이스 쿼리를 수행하므로 관련 모델에서 로드() 및 모든()에 대한 중첩 호출보다 효율적입니다.

!!!팁 제외에 대해 자세히 알아보려면 _field를 제외하고 읽으십시오.

!!!경고 모든 관계는 로드_all()에서 지워지므로 일부 중첩 모델을 제외하면 호출 후 비어 있습니다.

저장()

저장() -> 셀프

QuerySet.create() 메서드를 사용하거나 모델을 일반 Pydantic 모델로 초기화한 다음 Save() 메서드를 호출하여 새 모델을 만들 수 있습니다.

기본 키가 설정되지 않았거나 모델이 데이터베이스에 없는 경우 저장()을 사용하여 모델에 대한 변경 사항을 저장할 수도 있습니다.

저장() 메서드는 모델이 데이터베이스에 있는지 여부를 확인하지 않으므로 모델을 기존 기본 키로 저장하려고 하면 선택한 데이터베이스 백엔드에서 무결성 오류가 발생합니다.

트랙 = 트랙 (이름 = '새')
기다려track.save() #는 데이터베이스에서 모델을 유지합니다.

추적 = 대기 추적.ts.get (이름 = '새')
기다려track.save()

업데이트()

update(_columns: List[str] = None, **kwargs) -> self

QuerySet.() 메서드를 사용하거나 모델 속성(필드)을 업데이트하고 업데이트() 메서드를 호출하여 모델을 업데이트할 수 있습니다.

기본 키를 설정하지 않고 모델을 업데이트하려고 하면 ModelPersistenceError 예외가 발생합니다.

새로 만든 모델을 유지하려면 저장() 또는 up(**kwargs) 방법을 사용하십시오.

추적 = 대기 추적.ts.get (이름 = '새')
트랙 업데이트 대기 중 (이름 = '새가 다시 공격합니다')

모델에서 선택한 열만 데이터베이스로 업데이트하려면 _ 매개 변수로 업데이트된 열 목록을 제공하십시오.

예:

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

    ID: int = ormar. 정수(prial_key = 참)
    이름: str = ormar. 문자열(max_long = 100, nullable = 거짓, 이름 = "제목")
    연도: int = ormar. 정수()
    이익: 플로트 = 오마. 플로트 ()

터미네이터 = 영화를 기다립니다(이름 = '터미네이터', 연도 = 1984, 이익 = 0.078).저장()

terminator.name="터미네이터 2"
종료 연도 = 1991
터미네이터.이익 = 0.520

# 업데이트 전용 이름
터미네이터를 기다립니다.업데이트(_=["이름"])

# 터미네이터 인스턴스가 다시 로드되지 않았으므로 참고하십시오.
주장된 터미네이터. 연도 == 1991

# 하지만 db에서 데이터를 로드하면 업데이트되지 않은 것을 알 수 있습니다.
대기 중인 터미네이터.로드()
주장된 터미네이터. 연도 == 1984

!!!경고 업데이트()는 모델의 인스턴스를 새로 고치지 않으므로 _ 목록에서 전달한 것보다 더 많은 열을 변경하면 모델 인스턴스의 값이 데이터베이스와 다릅니다!

업데이트 삽입()

업서트(**kwargs) -> 셀프

위의 저장() 또는 업데이트(**kwargs) 메서드에 대한 프록시입니다.

기본 키가 ->로 설정되면 업데이트 방법이 호출됩니다.

pk가 설정되지 않은 경우 저장() 메서드가 호출됩니다.

트랙 = 트랙 (이름 = '새')
트랙을 기다립니다. up () # pk가 비어 있으므로 저장을 호출합니다.

추적 = 대기 추적.ts.get (이름 = '새')
대기 중인 track.up (이름 = 'The Bird Strikes Again') # pk가 이미 채워져 있으므로 업데이트를 호출합니다.

삭제()

QuerySet.delet() 메서드를 사용하거나 모델을 사용하고 delet() 메서드를 호출하여 모델을 삭제할 수 있습니다.

추적 = 대기 추적.ts.get (이름 = '새')
추적 대기 중. 삭제() # 데이터베이스에서 모델을 삭제합니다.

!!!추적 개체는 변경되지 않고 데이터베이스의 레코드만 삭제됩니다.