오마르

! [피피 버전](https://img.shields.io/pypi/pyversions/ormar.svg) ! [취재] ](https://codecov.io/gh/collerek/ormar)! [코드 팩터] ](https://www.codefactor.io/repository/github/collerek/ormar)

개요

Ormar 패키지는 Postgres, MySQL 및 SQLite를 지원하는 Python용 비동기 ORM입니다.

ormar 사용의 주요 이점은 다음과 같습니다.

• 비동기 프레임워크(파사피, 스타렛 등)와 함께 사용할 수 있는 비동기 ORM을 얻으십시오.
• 는 하나의 모델만 유지하면 됩니다. 즉, pydantic 및 기타 orm 모델(sqlalchemy, peewee, gino 등)을 유지할 필요가 없습니다.

목표는 데이터 검증(요청 및 응답 모델)을 위해 Pydantic 기반 FastAPI와 함께 직접 사용할 수 있는 간단한 ORM을 만드는 것입니다.

Ormar는 이름에서 분명한 "ORM"을 제외하고 뱀을 의미하는 스웨덴 ormar와 캐비닛을 의미하는 크로아티아 ormar(e)에서 이름을 유래했습니다.

파이썬 ORM의 경우 스네이크 캐비닛보다 더 좋은 이름은 무엇입니까?

ormar를 좋아한다면 GitHub에서 저장소를 촬영하는 것을 잊지 마십시오!

우리가 더 큰 커뮤니티를 구축할수록 버그를 발견하고 기여자를 끌어들이기가 더 쉬워질 것입니다.

문서

자세한 내용은 설명서를 확인하십시오.

간결성을 위해 대부분의 문서 조각은 데이터베이스 생성 및 예약된 비동기 실행 기능의 실행을 생략합니다.

설명서보다 더 많은 실제 예제를 원하는 경우 대부분의 테스트에서 실제로 만들고 데이터베이스에 연결해야 하기 때문에 테스트 폴더를 볼 수 있습니다.

그러나 이러한 솔루션은 테스트일 뿐이며 모든 솔루션이 실제 사용에 적합한 것은 아니라는 점을 명심하십시오.

FastAPI 생태계의 일부

FastAPI 에코시스템의 일부로 Ormar는 어떤 식으로든 데이터베이스와 함께 작동하는 선택된 라이브러리에서 지원됩니다.

Ormar는 여전히 SQL 방언에 구애받지 않으므로 지원되는 모든 백엔드에서 작동하는 열만 구현됩니다.

ormar의 확장으로 특정 방언에 대한 열을 구현하는 것이 상대적으로 쉽습니다.

Postgres 열별 구현:ormar-postgres-extensions

다른 라이브러리를 유지 관리하거나 사용하고 Ormar를 지원하기를 원하는 경우 지원 방법을 알려주십시오.

의존성

Ormar의 구성은 다음과 같습니다.

• 쿼리를 작성하기 위한 SQL Alchemy 코어.
• 데이터베이스 간 비동기 지원을 위한 데이터베이스.
• Pydantic은 데이터 유효성 검사에 사용됩니다.

라이센스

Ormar는 오픈 소스 소프트웨어로 구축되었으며 MIT 라이센스에 따라 완전히 무료로 유지됩니다.

직장에서 일상적인 문제를 해결하거나 강력한 파이썬 커뮤니티를 홍보하고 구축하기 위해 오픈 소스 코드를 작성할 때 감사하다고 말하고 커피 한 잔이나 월간 보조금을 구입하여 작업이 자유롭고 유지되도록 할 수 있습니다.

스폰서

sqlalchemy 및 기존 데이터베이스에서 마이그레이션

현재 sqlalchemy를 사용하고 있고 ormar로 전환하려면 기존 sqlalchemy orm 모델을 변환하는 데 도움이 되는 자동 변환 도구를 확인하여 수동으로 이 작업을 수행할 필요가 없습니다.

베타 버전은 github: sqlalchemistry-to-ormar 또는 간단하게 찾을 수 있습니다. pip install sqlalchemy-to-ormar

프로젝트에서 sqlalchemy를 사용하지 않더라도 sqlacodegen과 함께 sqlacodegen을 사용하여 기존 데이터베이스에서 ormar 모델을 자동으로 매핑/생성할 수 있습니다.

마이그레이션 및 데이터베이스 생성

ormar는 SQL Alchemy 코어를 기반으로 구축되므로 alembic을 사용하여 데이터베이스 마이그레이션(프로덕션 코드에 실제로 수행해야 함)을 제공할 수 있습니다.

테스트 및 기본 응용 프로그램의 경우 sqlalchemy로 충분합니다.

# 이것은 아래의 부분 조각 전체 작업 예입니다.
#1. 수입
sqlalchemy 가져오기
데이터베이스 가져오기
오마르 가져오기

#2. 초기화
DATABASE_URL="sqlite://db.sqlite"
base_ormar_config = ormar. OrmarConfig (
    메타데이터 = sqlalchemy. 메타데이터(),
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    엔진 = sqlalChemy.create_ (DATABASE_URL),
)

여기서 모델 정의

#3. 데이터베이스 작성 및 테이블 작성
base_ormar_config 메타데이터 create_all (엔진)

alembic의 샘플 구성과 마이그레이션 및 데이터베이스 생성에 대한 자세한 내용은 마이그레이션 설명서 섹션을 참조하십시오.

패키지 버전

Ormar는 아직 개발 중입니다. 모든 종속성을 수정하는 것이 좋습니다(예: ormar~=0.9.1).

Ormar는 또한 릴리스 번호를 따릅니다. 즉, 주요 변경 사항은 주요 버전 번호를 증가시키는 반면 다른 변경 사항과 수정 사항은 마이너 버전 번호를 증가시키므로 후자의 경우 안전하게 업데이트해야 하지만 먼저 릴리스 문서를 읽어야 합니다.example: (0.5.2 -> 0.6.0 - breaking, 0.5.2 -> 0.5.3 - non breaking).

비동기 파이썬

ormar는 비동기 ORM이므로 이벤트 루프에서 실행되도록 예약된 메서드에 대한 호출을 기다려야 합니다. 파이썬에는 이 작업을 수행할 수 있는 비동기 모듈이 내장되어 있습니다.

대부분의 "일반" 파이썬 인터프리터는 함수 외부에서 실행될 때까지 기다리지 않습니다(실제로 이 함수를 예약하여 실행을 연기하고 즉각적인 결과를 얻지 못하기 때문입니다).

FastAPI와 같은 최신 웹 프레임워크에서는 프레임워크가 이 문제를 처리하지만 직접 이 작업을 수행하려면 아래 빠른 시작에 설명된 대로 수동으로 수행해야 합니다.

빠른 시작

GitHub의 예제 폴더에서 동일한 스크립트를 찾을 수 있습니다.

입력에서 가져오기 옵션

데이터베이스 가져오기

오마르 가져오기
sqlalchemy 가져오기

DATABASE_URL="sqlite://db.sqlite"
base_ormar_config = ormar. OrmarConfig (
    메타데이터 = sqlalchemy. 메타데이터(),
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    엔진 = sqlalChemy.create_ (DATABASE_URL),
)

# 이 단계는 선택 사항입니다 -> 모든 ormar care는 이름이 있는 필드입니다.
# ormar_config # 및 적절한 매개 변수이지만 이렇게 하면 반복할 필요가 없습니다.
# 하나의 데이터베이스만 사용하는 경우 동일한 매개 변수
#
# 모든 유형의 힌트는 선택 사항입니다.
# 아래는 완벽하게 유효한 모델 선언입니다.
# 클래스 작성자(ormar. 모델):
# ormar_config = base_ormar_config (테이블 이름 = "저자")
#
# id = ormar. 정수(prial_key = True) # < = 필드 유형이 없습니다.
# 이름 = ormar. 문자열(max_long=100)


클래스 작성자(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 = 참)


# 데이터베이스 생성
# 프로덕션에서 마이그레이션을 사용해야 합니다.
# 기존 데이터베이스에 연결하는 경우 필요하지 않습니다.
# 우리가 전에 db를 지웠는지 확인하기 위해
base_ormar_config 메타데이터 drop_all(엔진)
base_ormar_config 메타데이터 create_all (엔진)


# 아래의 모든 기능은 기능 범주로 나뉩니다.
# 모든 기능이 비동기로 어떻게 정의되는지 주목하십시오. 따라서 대기 및 필요를 사용할 수 있습니다.
# 스스로 기다리고 있다
Aync def 생성():
    # QuerySet.create 방법을 통해 작업할 레코드를 만듭니다.
    # 쿼리 세트는 각 모델의 클래스에 개체로 노출됩니다.
    톨킨 = .ts.create를 기다립니다(이름 = "J.R.R. 톨킨")
    책을 기다리고 있습니다.
    책을 기다리고 있습니다.
    책을 기다리고 있습니다.

    # 2단계로 나누어진 물체의 대체 생성
    Sapkowski = 작성자(이름 = "Andrzej Sapkowski")
    # 뭔가를 해
    기다려sapkowski.save()

    # 또는 초기화 후 저장()
    기다리는 책 (작가 = sapkowski, 제목 = "마녀", 연도 = 1990). 저장 ()
    기다리고 있는 책 (작가 = sapkowski, 제목 = "바보의 탑", 연도 = 2002). 저장 ()

    # 데이터베이스에 데이터 삽입에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/create/


Aync def 읽기():
    # 외부 키 관계를 로드하지 않고 인스턴스를 가져옵니다.
    # 장고 스타일
    책 = 기다려 책.ts.get (제목 = "호빗")
    # 또는 파이썬 스타일
    책 = 기다려 책.ts.get (책 제목 == "호빗")
    북 2 = 북을 기다립니다. 첫 번째 ()

    # 먼저() 기본 키 값이 낮은 인스턴스를 가져옵니다.
    주장 책 == 책 2

    # 로드된 모델의 모든 필드에 액세스할 수 있습니다.
    책을 주장하세요.제목 == "호빗"
    책을 주장하십시오. 연도 == 1937년

    # 얻을 수 있는 조건이 통과되지 않을 때 ()
    # 기본 키 열을 기준으로 마지막()으로 작동합니다.
    북3 = 기다려 북.ts.get ()
    책 제목 주장 == "바보의 탑"

    # 관계가 있을 때 ormar는 항상 관련 모델을 정의합니다.
    # 이 예와 같이 로드한 모든 항목이 외부 키 값인 경우에도
    주장은 인스턴스(book.author, 작성자)
    # 기본 키는 책 테이블에 저장된 외래 키에서 채워집니다.
    주장book.author.pk==1
    # 관련 모델이 로드되지 않았기 때문에 다른 모든 필드는 없음
    book.author.name 없음 주장

    # 관련 모델이 이미 있는 경우 데이터베이스에서 관계를 로드합니다.
    # 또는 아래의 조인 섹션을 참조하십시오.
    기다려book.author()
    주장book.author.name== "J.R.R. 톨킨"

    # 주어진 모델에 대한 모든 행 가져오기
    작성자 = 기다립니다 인증.ts.all ()
    주장 렌 (저자) ==2

    # 데이터베이스에서 데이터 읽기에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/read/


Aync def 업데이트():
    # db에서 기존 행 읽기
    톨킨 = .ts.get을 기다립니다(이름 = "J.R.R. 톨킨")
    주장tolkien.name== "J.R.R. 톨킨"
    톨킨_id=tolkien.id

    # 선택한 속성 변경
    tolkien.name="존 로널드 루엘 톨킨"
    # 모델 인스턴스의 통화 업데이트
    tokien.을 기다리고 있습니다 ()

    # 개체가 업데이트되었는지 확인
    톨킨 = .ts.get을 기다립니다(이름 = "존 로널드 루엘 톨킨")
    주장tolkien.name== "존 로널드 루엘 톨킨"
    주장tolkien.id== tokien_id

    # 또는 로드하지 않고 데이터 업데이트
    기다리다 권한.ts.filter (name __ = "Tolkien"). (name = "J.R.R. Tolkien")

    # 데이터베이스의 데이터 업데이트에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/update/


Aync def 삭제():
    Silmarillion = 북.ts.get을 기다립니다 (년 = 1977)
    # 인스턴스에서 삭제()를 호출합니다.
    Silmarillion 삭제 대기 중 ()

    # 또는 로드하지 않고 삭제
    책을 기다리고 있습니다. 삭제 (제목 = "바보의 탑")

    # 기록이 없을 때 NoMatch 예외가 발생합니다.
    시도:
        북.ts.get 대기 중 (년 = 1977)
    오마르를 제외하고. NoMatch:
        인쇄("1977년의 책은 없습니다!")

    # 데이터베이스에서 데이터 삭제에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/delete/

    # 기록이 데이터베이스에 더 이상 존재하지 않음에도 불구하고 참고하십시오.
    # 위의 개체는 여전히 액세스할 수 있으며 다시 사용(및 i.e.save())할 수 있습니다.
    톨킨=silmarillion.author
    책을 기다리고 있습니다.


비동기 def 조인:
    # 두 모델에 가입하려면 _를 사용하십시오.

    # 장고 스타일
    책 = 기다려 책.ts._("저자").get(제목 = "호빗")
    # 파이썬 스타일
    예약 = 대기 북.ts._(Book.author).get(
        책 제목 == "호빗"
    )

    # 이제 저자는 이미 사전 설정되었습니다.
    주장book.author.name== "J.R.R. 톨킨"

    # 기본적으로 관계의 두 번째 측면도 얻습니다.
    # 소문자 소스 모델 이름 +'s'로 구성 (이 경우 책)
    # 매개 변수와 함께 사용자 지정 이름을 제공할 수도 있습니다.

    # 장고 스타일
    작성자 = 기다립니다 인증.ts._("책").all(이름 = "J.R.R. 톨킨")
    # 파이썬 스타일
    작성자 = 기다립니다 작성자.ts._ (인증.).all (
        Author.name== "J.R.R. 톨킨"
    )
    주장 렌 (저자 [0].) == 3

    # 역방향 및 많은 관계에서 많은 관계를 위해 사전 추출 할 수도 있습니다.
    # 각 관련 모델에 대해 별도의 쿼리를 실행합니다.

    # 장고 스타일
    작성자 = 기다립니다 인증.ts.prefetch_("책").get(이름 = "J.R.R. 톨킨")
    # 파이썬 스타일
    작성자 = 기다립니다 작성자.ts.prefetch_(인증.).get(
        Author.name== "J.R.R. 톨킨"
    )
    주장 len (.) == 3

    # 관계에 대해 자세히 알아보기
    # 방문: https://collerek.github.io/ormar/relations/

    # 조인 및 하위 쿼리에 대해 자세히 알아보기
    # 방문: https://collerek.github.io/ormar/queries/joins-and-subqueries/


Async def filer_and_sort():
    # 쿼리를 필터링하려면 필터()를 사용하거나 키 값 파스를 전달할 수 있습니다.
    # get (), all () 등.
    # 특별한 방법을 사용하거나 더블을 사용하여 관련 모델 필드에 액세스하려면
    # 저자의 이름으로 필터링하는 것과 같은 밑줄
    # 장고 스타일
    책 = 기다리다 책.ts.all (저자 __name = "J.R.R. 톨킨")
    # 파이썬 스타일
    책 = 기다리다 책.ts.all (Book.author.name== "J.R.R. 톨킨")
    주장 렌 (책) == 3

    # 필터는 이중 밑줄로 구분된 특수 방법을 허용할 수 있습니다.
    # sql 쿼리를 발행합니다. ` where authors.name like "%tolkien%"` 그것은 아니다
    # 케이스 민감 (따라서 톨킨의 작은 t)
    # 장고 스타일
    책 = 기다리다 책.ts.filter ( __name__containes = "tokien") .all ()
    # 파이썬 스타일
    책 = 기다리다 책.ts.filter (Book.author.name 아이콘 ("톨킨")) .all ()
    주장 렌 (책) == 3

    # 쿼리 세트의 order_by() 함수를 사용하여 정렬합니다.
    # 필드 이름 앞에 하이픈을 사용하여 감소를 정렬하려면
    # 필터와 마찬가지로 이중 밑줄을 사용하여 관련 필드에 액세스할 수 있습니다.
    # 장고 스타일
    책 = (
        북.ts.filter를 기다립니다(저자 __name__ = "톨킨")
        . order _ by ("-년")
        . 모두 ()
    )
    # 파이썬 스타일
    책 = (
        책을 기다립니다. 개체.필터(Book.author.name 아이콘테인("tokien"))
        order_by(북.year.desc())
        . 모두 ()
    )
    주장 렌 (책) == 3
    주장된 책들 [0]. 제목 == "The Silmarillion"
    주장된 책들 [2]. 제목 == "호빗"

    # 필터링 및 주문에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/filter-and-sort/


비동기 def subset_of_():
    # 데이터베이스를 쿼리할 때 일부 열을 로드에서 제외하려면
    # 파일() 방법을 사용할 수 있습니다.
    호빗 = 북.ts.field를 기다립니다(["제목"]).get(제목 = "호빗")
    # 필드에 포함되지 않은 필드는 비어 있습니다(없음으로 설정).
    호빗을 주장하십시오. 년은 없음
    hobbit.author 없음 주장

    # 선택한 필드가 있습니다
    호빗을 주장하세요.제목 == "호빗"

    # 또는 제외할 열을 제공할 수 있습니다.
    호빗 = 기다려 북.ts.ts_field (["년"]).get (제목 = "호빗")
    # 아직 연도가 정해지지 않았다
    호빗을 주장하십시오. 년은 없음
    # 하지만 작가가 돌아왔다
    hobbit.author 없음이 아니라고 주장

    # 또한 기본 키 열을 제외할 수 없습니다. 항상 있습니다.
    # 명시적으로 제외하더라도 거기에 있을 것입니다.

    # 각 모델에는 pk인 prial_key 열에 대한 바로 가기가 있습니다.
    # 그리고 아래와 같이 이 별칭으로 값을 필터링/액세스/설정할 수 있습니다.
    hobbit.pk 없음이 아니라고 주장

    # nullable이 아닌 필드는 제외할 수 없습니다.
    모델 정의에서 # (필수)
    시도:
        북.ts.t_field(["제목"]).get(제목 = "호빗")을 기다립니다.
    피단틱을 제외하고. 유효성 검사 오류:
        인쇄("nullable 필드 제목을 제외할 수 없습니다")

    # 열의 하위 집합 선택에 대한 자세한 내용을 보려면
    # 방문: https://collerek.github.io/ormar/queries/select-columns/


비동기 def 페이지화():
    # 반환된 행 수를 제한하려면 사용 제한()
    책 = 책을 기다립니다. 개체. 제한 (1) .all ()
    주장 렌 (책) ==1
    주장된 책들 [0]. 제목 == "호빗"

    # 반환된 행 수를 오프셋하려면 오프셋을 사용합니다()
    책 = 기다리다 책.ts. (1) . (1) .all ()
    주장 렌 (책) ==1
    주장된 책들 [0]. 제목 == "반지의 제왕"

    # 또는 둘 다 결합한 파기네이트를 사용합니다.
    책 = 기다리다 책.ts.page (페이지 = 2, 페이지 _ 크기 = 2).모두 ()
    주장 렌 (책) == 2
    # 삭제에서 Sapkowski 책 한 권을 삭제했다는 점에 유의하십시오()
    # 그리고 Silmarillion을 재현했습니다 - 기본적으로 순서가 설정되지 않은 경우
    # prial_key 열별 정렬
    주장된 책들 [0]. 제목 == "마녀"
    주장된 책들 [1]. 제목 == "The Silmarillion"

    # 페이지화 및 행 수에 대해 자세히 알아보기
    # 방문: https://collerek.github.io/ormar/queries/pagination-and-rows-number/


비동기 def 집계():
    # 카운트:
    주장 2 == 기다리다 권한. 개체 수()

    # 존재
    주장은 북.ts.filter(제목 = "호빗")를 기다리고 있습니다. ()

    # 최대
    1990 == 북.ts.max를 기다리라고 주장하십시오(열 = ["년"]).

    # 최소
    1937년 주장 == 북.ts.min (열 = ["년"])

    # 평균
    1964.75== 북.ts.avg를 기다리라고 주장하십시오(열 = ["년"]).

    # 합계
    7859== 북.ts.합계를 기다리라고 주장하십시오(열 = ["년"]).

    # 집계된 기능에 대해 자세히 알아보기
    # 방문: https://collerek.github.io/ormar/queries/aggregations/


Async def raw_ata():
    # 딕트 또는 튜플 형태로 원시 데이터를 추출합니다.
    # 이것은 모델이 있는 것처럼 유효성 검사(!)를 건너뜁니다.
    # 분석된 데이터에서 생성되지 않음

    # 개체 목록을 받아쓰기
    주장 대기 북.ts. () == [
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937},
        {"id": 2, "author": 1, "title": "The Lord of the Rings", "year": 1955},
        {"id": 4, "author": 2, "title": "The Witcher", "year": 1990},
        {"id": 5, "author": 1, "title": "The Silmarillion", "year": 1977},
    ]

    # 튜플로 개체 목록 가져오기
    주장 대기 북.ts.s_list () == [
        (1, 1, "호빗", 1937),
        (2, 1, "반지의 제왕", 1955),
        (4, 2, "마녀", 1990),
        (5, 1, "The Silmarillion", 1977),
    ]

    # 필터 데이터 - 항상 목록을 얻는 방법 참고
    주장은 북.ts.filter(제목 = "호빗")를 기다립니다. 값() = = [
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937}
    ]

    # 원하는 필드만 선택
    주장은 북.ts.filter(제목 = "호빗").값(["id", "제목"]) ==[
        {"id": 1, "title": "The Hobbit"}
    ]

    # 열을 하나만 선택하면 값_list로 평평하게 만들 수 있습니다.
    주장은 북.ts.s_list("제목", 플랫 = 참) ==[
        "호빗",
        "반지의 제왕",
        "마녀",
        "The Silmarillion",
    ]

    # 원시 값 추출에 대해 자세히 알아보기
    # 방문: https://collerek.github.io/ormar/queries/aggregations/


비동기 def with _link (함수):
    # sqlite가 아닌 다른 백엔드의 경우 실제로 필요합니다.
    # 데이터베이스에 연결하여 db 작업을 수행합니다.
    데이터베이스와 비동기화:
        대기 기능()

    #`fastapi` 와 같은 프레임워크를 사용하는 경우 연결하지 않아야 합니다.
    # 엔드포인트에 있지만 글로벌 연결 풀이 있습니다.
    # db 연결https://collerek.github.io/ormar/fastapi/and 섹션 확인


# 모든 기능을 수집하고 실행합니다.
# 참고 - 일반적으로 가져오기는 파일의 시작 부분에 있어야 합니다.
비신시오 가져오기

# 일반적으로 수집() 기능을 사용하여 여러 기능을 실행합니다.
# 동시에 그러나 우리는 실제로 데이터를 수정하고 함수의 순서에 의존합니다.
[에서 재미를 위해
    창조,
    읽기,
    업데이트,
    삭제,
    가입,
    filer_and_sort,
    subset_of_,
    파기네이션,
    집단,
    원시 데이터,
]:
    인쇄(f "실행:{func.__name__}")
    asyncio.run(with _link (func))

# 데이터베이스 테이블 삭제
drop_all(엔진)

오마르 사양

쿼리 세트 방법

• 생성(**kwargs):-> 모델
• get(*args, **kwargs): -> Model
• get_or_none(*args, **kwargs): -> Optional[Model]
• get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]
• first(*args, **kwargs): -> Model
• update(each: bool = False, **kwargs) -> int
• update_or_create(**kwargs) -> Model
• bulk_create(objects: List[Model]) -> None
• bulk_update(objects: List[Model], columns: List[str] = None) -> None
• delete(*args, each: bool = False, **kwargs) -> int
• all(*args, **kwargs) -> List[Optional[Model]]
• iterate(*args, **kwargs) -> AsyncGenerator[Model]
• filter(*args, **kwargs) -> QuerySet
• exclude(*args, **kwargs) -> QuerySet
• select_related(related: Union[List, str]) -> QuerySet
• prefetch_related(related: Union[List, str]) -> QuerySet
• limit(limit_count: int) -> QuerySet
• offset(offset: int) -> QuerySet
• count(distinct: bool = True) -> int
• 존재 () -> 부울
• max(columns: List[str]) -> Any
• min(columns: List[str]) -> Any
• avg(columns: List[str]) -> Any
• sum(columns: List[str]) -> Any
• fields(columns: Union[List, str, set, dict]) -> QuerySet
• exclude_fields(columns: Union[List, str, set, dict]) -> QuerySet
• order_by(columns:Union[List, str]) -> QuerySet
• values(fields: Union[List, str, Set, Dict])
• values_list(fields: Union[List, str, Set, Dict])

관계 유형

• 일대다 - ForeignKey 사용(to: Model)
• 많은 것에서 많은 것 - ManyToMany(to: Model, Optional[through]: Model)

모델 필드 유형

사용 가능한 모델 필드(필수 매개 변수 포함 - 문서에서 선택 사항):

• 끈(최대 길이)
• 텍스트()
• 부울 ()
• 정수()
• 플로트()
• 날짜()
• 시간()
• 날짜 시간 ()
• JSON()
• 큰 정수()
• 작은 정수()
• 소수(소수 자릿수, 정밀도)
• UUID()
• 큰 이진수(최대 길이)
• 열거(열거 클래스)
• 필드와 유사한 열거 - 선택 영역을 다른 필드 유형으로 전달하여
• 암호화 문자열 - 암호 암호화 _ 비밀 및 암호화 _ 백엔드 전달
• 외래 키(to)
• 많은 것에서 많은 것 (에게)

사용 가능한 필드 옵션

모든 필드 유형은 다음 키워드 매개 변수를 지원합니다.

• 기본 키: 부울
• Nullable: 부울
• 기본값: 임의
• 서버 기본값: 모든
• 색인: 부울
• 고유: 부울
• 이름: str

다음 중 하나를 설정하지 않는 한 모든 필드가 필요합니다.

• Nullable - Nullable 열을 만듭니다. 기본값을 거짓으로 설정합니다. 자세한 내용은 필드 공통 매개 변수를 읽으십시오.
• sql_nullable - pydantic 및 데이터베이스에 대한 다른 설정을 설정하는 데 사용됩니다. 기본값을 nullable 값으로 설정합니다. 자세한 내용은 필드 공통 매개 변수를 읽으십시오.
• 기본값 - 필드의 기본값을 설정합니다. 관계형 필드에는 적용되지 않음
• 서버_기본값 - 서버 측 필드(예: sqlalchemy의 func.now()))의 기본값을 설정합니다. 관계형 필드에는 적용되지 않습니다.
• 자동 증분이 있는 기본 키 - 열이 기본 키로 설정되고 해당 열에 자동 증분이 설정된 경우. 기본적으로 int 기본 키는 자동 증분을 설정합니다.

사용 가능한 신호

신호를 사용하면 지정된 모델에서 지정된 이벤트에 대해 기능을 트리거할 수 있습니다.

• 사전 저장
• 저장 후
• 사전 업데이트
• 업데이트 후
• 사전 삭제
• 삭제 후
• 관계 전 추가
• 포스트 관계 추가
• 관계 전 삭제
• 관계를 삭제한 후