콘텐츠로 이동

모델

모델 정의

ormar 모델을 정의하면 해당 Pydantic 모델과 Sqlalchemy 테이블을 무료로 얻을 수 있습니다. 백그라운드에서 관리되므로 직접 만들 필요가 없습니다.

모델 클래스

ormar 모델을 구축하려면 ormar를 상속하기만 하면 됩니다. 모델 클래스.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

필드 정의

다음으로 하나 이상의 필드가 클래스 수준 변수로 할당됩니다.

기본 필드 유형

각 테이블에는 선택한 필드에서 기본 _key = True를 설정하여 지정할 수 있는 기본 키 열이 있어야 합니다.

하나의 기본 키 열만 허용됩니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!경고, 기본 _key 열을 할당하지 않거나 모델당 둘 이상의 열을 할당하지 않으면 ModelDefinitionError 예외가 발생합니다.

기본적으로 기본 키가 정수 필드에 할당된 경우 자동 증가 옵션은 참으로 설정됩니다.

자동 증가 = 거짓을 전달하여 이를 비활성화할 수 있습니다.

1
ID: int = ormar. 정수(prial_key = 참, 자동 증가 = 거짓)

비데이터베이스 필드

모델에 일반 Pydantic 필드가 필요한 경우(모델에 값을 저장하거나 특정 값을 전달하기 위해) 평소와 같이 Pydantic에서 필드를 정의할 수 있습니다.

이와 같이 생성된 필드는 pydantic 모델 필드에 추가되므로 필드 유형에 따라 검증되고 모델 _dump() 및 모델 _dump_json() 결과에도 나타납니다.

차이점은 이러한 필드가 데이터베이스에 저장되지 않는다는 것입니다. 따라서 이러한 필드는 기본 SQL Alchemy 열 또는 테이블 변수에 포함되지 않습니다(필요한 경우 아래 내부 섹션을 확인하여 액세스하는 방법에 대해 알아보십시오).

이후 Pydantic 필드는 마이그레이션 또는 저장, 업데이트 등과 같은 데이터베이스 작업에 포함되지 않습니다.

이와 같은 필드는 FastAPI 요청의 페이로드로 전달될 수 있으며 FastAPI 응답으로 반환됩니다(물론 해당 값이 데이터베이스에서 가져 오지 않았기 때문에 코드의 어딘가에 값을 설정한 경우에만 해당). 빠른 요청에 값을 전달하고 요청 _ 모델에서 빠른 요청이 구성한 것과 동일한 인스턴스를 반환하는 경우 응답에서 정확히 동일한 값을 반환해야 합니다.)

!!! 경고 pydantic 필드는 항상 선택 사항이어야 하며 변경할 수 없습니다(그렇지 않으면 데이터베이스 로드 유효성 검사가 실패함).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)
    non_db_field: str = pydantic.Field(max_length=100)

기본 매개 변수로 pydantic 필드를 설정하고 요청의 실제 값을 전달하지 않으면 항상 기본값이 표시됩니다. 함수가 될 수 있으므로 기본값 = datetime.datetime.now을 설정하고 엔드포인트 등을 호출할 때마다 현재 타임스탬프를 얻을 수 있습니다.

FastAPI의 비데이터베이스 필드

pydantic 및 계산된 _ 필드 수정자 필드는 모두 해당 포함/제외 및 응답 _ 모델 _ 포함/응답 _ 모델 _ 제외를 사용하여 모델 _ 덤프() 및 파사피 응답에 포함/제외할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# <== 명확성을 위해 관련 코드의 일부가 제거되었습니다 ==>
base_ormar_config = ormar. OrmarConfig (
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    메타데이터 = sqlalchemy. 메타데이터(),
    엔진 = sqlalChemy.create_ (DATABASE_URL),
)


클래스 사용자(ormar. 모델):
    ormar_config = base_ormar_config (테이블 이름 = "users2")

    ID: int = ormar. 정수(prial_key = 참)
    이메일: str = ormar. 문자열(max_long = 255, nullable = 거짓)
    암호: str = ormar. 문자열(max_long = 255)
    첫 번째 이름: str = ormar. 문자열(max_long = 255)
    성: str = ormar. 문자열(max_long = 255)
    범주: str = ormar. 문자열(max_long = 255, nullable = True)
    타임 스탬프: datetim.datetime = pydantic. 필드(
        기본값=datetime.datetime.now
    )

# <== 명확성을 위해 관련 코드의 일부가 제거되었습니다 ==>
앱 = 빠른 API ()

@app.post("/사용자/")
비동기 def create_user(사용자: 사용자):
    귀환 대기user.save()

# <== 명확성을 위해 관련 코드의 일부가 제거되었습니다 ==>

Def test_ing_Fields_in_endpoint():
    클라이언트 = TestClient (앱)
    클라이언트를 클라이언트로 사용:
        타임스탬프=datetime.datetime.now()

        사용자={
            "이메일": "test@domain.com",
            "비밀번호": "^*^%A*DA*IAAA",
            "_name": "John",
            "last_name": "Doe",
            "타임스탬프": str(타임스탬프),
        }
        응답=client.post("/사용자/", json=사용자)
        주장 목록 (se.json () .key ()) == [
            "Id",
            "이메일",
            "첫 번째 이름",
            "last_name",
            "카테고리",
            "타임 스탬프",
        ]
        # 반환된 것은 동일한 타임스탬프입니다.
        응답을 주장하십시오. json () .get ("타임스탬프") == str (타임스탬프). 교체(", "T")


# <== 명확성을 위해 관련 코드의 일부가 제거되었습니다 ==>

필드 이름 및 열 이름

기본 필드 이름은 기본 Pydantic 모델 및 SQL Alchemy 테이블에 사용됩니다.

어떤 이유로 데이터베이스에서 이름을 변경하고 모델에 이름을 남기려면 필드 선언 중에 이름 매개 변수를 지정하여 이 작업을 수행할 수 있습니다.

다음은 이름이 변경된 예제 모델입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

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

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)

외래 키 열 이름도 변경할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from typing import Optional

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///test.db", force_rollback=True)
metadata = sqlalchemy.MetaData()


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="music_albums",
    )

    id: int = ormar.Integer(name="album_id", primary_key=True)
    name: str = ormar.String(name="album_name", max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist, name="artist_id")

그러나 현재 ManyToMan 열 이름은 어쨌든 다른 모델을 통과하기 때문에 변경할 수 없습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import databases
import ormar
import sqlalchemy

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

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)


class ArtistChildren(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children_x_artists",
    )


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")
    children = ormar.ManyToMany(Child, through=ArtistChildren)

기본 쿼리 세트 재정의

Ormar가 실행하는 쿼리를 사용자 정의하려면 기본 쿼리 집합인 Model 클래스에서 자체 쿼리 세트 클래스(Ormar Query세트 확장)를 정의할 수 있습니다.

클래스의 ormar_config에 새 클래스를 쿼리 집합_클래스 인수로 제공할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
오마르 가져오기
ormar.queryset.queryset에서 쿼리 세트 가져오기
HTTP빠른 API에서 가져온 예외


클래스 MyQuerySet클래스(쿼리 세트):

    Async def first_or_404(자체, * args, * kwargs):
        엔티티 = 자신을 기다립니다. get_or_no (*args, **kwargs)
        엔티티가 없는 경우:
            # 파사피 또는 스타렛에서
            HTTP 예외 올리기(404)


클래스 북(ormar. 모델):
    ormar_config = base_ormar_config 사본(
        쿼리셋class=MyQuerySetClass,
        표 이름 = "책",
    )

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


# 책을 찾을 수 없을 때 보기에서 `404` 를 올리십시오.
예약 = 대기 북.ts.first_or_404 (이름 = "123")

힌트 입력

더 나은 IDE 지원 및 mypy 확인을 위해 유형 힌트를 제공할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

유형 힌트는 선택 사항이므로 완전히 유효한 ormar 코드는 다음과 같이 보일 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id = ormar.Integer(primary_key=True)
    name = ormar.String(max_length=100)
    completed = ormar.Boolean(default=False)

!!!경고: 유형 힌트를 사용하더라도 Ormar는 이를 사용하여 Pydantic 필드를 구성하지 않습니다!

1
2
유형 힌트는 정적 체커 및 라이팅을 지원하기 위한 것입니다.
`ormar` 는 소유 필드의 `pydantic` 에서 사용하는 주석을 구성합니다.

의존성

ormar는 데이터베이스 조인 및 테이블 생성을 위해 데이터베이스와 sqlal-core에 의존하므로 각 모델에 두 개의 특수 매개 변수를 할당해야 합니다.

데이터베이스

하나는 sqlalchemy 연결 문자열 형식의 데이터베이스 URL을 사용하여 만든 데이터베이스 인스턴스입니다.

생성된 인스턴스는 각 모델에 전달된 ormar_config 개체 데이터베이스 매개 변수를 사용해야 합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!팁, 데이터베이스 인스턴스를 한 번만 생성하고 모든 모델에 사용하면 됩니다. 여러 데이터베이스를 사용하려면 여러 데이터베이스를 만들 수 있습니다.

연금술

두 번째 종속성은 sqlalchemy MetaData 인스턴스입니다.

생성된 인스턴스는 ormar_config 개체 메타데이터 매개 변수를 사용하여 각 모델에 전달되어야 합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!팁, 메타 데이터 인스턴스를 한 번만 생성하고 모든 모델에 사용하면 됩니다. 여러 데이터베이스를 사용하려면 여러 데이터베이스를 만들 수 있습니다.

모범 사례

ormar에는 OrmarConfig 클래스의 인스턴스인 ormar_config라는 필드가 필요합니다. 구성 관리를 단순화하기 위해 OrmarConfig 클래스는 복제 방법을 제공합니다. 따라서 모든 모델에 동일한 매개 변수를 반복적으로 제공하지 말고 기본 개체를 만들고 모든 모델에 걸쳐 복사본을 사용해야 합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from typing import Optional

import databases
import ormar
import sqlalchemy

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

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


class Artist(ormar.Model):
    # note that tablename is optional
    # if not provided ormar will user class.__name__.lower()+'s'
    # -> artists in this example
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    first_name: str = ormar.String(max_length=100)
    last_name: str = ormar.String(max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist)

테이블 이름

기본적으로 테이블 이름은 모델 클래스 이름, 즉 소문자 이름과 "s"에서 생성됩니다.

ormar_config 개체에 대한 테이블 이름 매개 변수를 제공하여 이 매개 변수를 재정의할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # if you omit this parameter it will be created automatically
        # as class.__name__.lower()+'s' -> "courses" in this example
        tablename="my_courses",
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

제약 조건

모델 수준에서 SQL 열에 모델별 제약 조건을 설정할 수도 있습니다.

현재 인덱스 열, 고유 열 및 체크 열 제약 조건만 지원됩니다.

!!!제약 조건에 이름을 설정하거나 여러 열에 인덱스를 설정하려면 두 제약 조건을 모두 사용해야 합니다. 그렇지 않으면 ormar 필드의 인덱스 및 고유 속성이 선호됩니다.

!!!팁 기본 키, 고유 키, 외래 키 등에 대한 열 제약 조건에 대해 자세히 알아보려면 필드를 방문하십시오.

고유 열

ormar_config 개체 제약 조건 매개 변수를 제공하여 이 매개 변수를 설정할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have to be unique in db
        constraints=[ormar.UniqueColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!구속조건은 고유해야 하는 열의 조합에 대한 것입니다. 열을 고유하게 만들려면 고유한 공통 매개 변수를 사용하십시오. 물론 이 매개 변수를 사용하여 많은 열을 고유하게 만들 수 있지만 각 열은 개별적으로 확인됩니다.

인덱스 열

ormar_config 개체 제약 조건 매개 변수를 제공하여 이 매개 변수를 설정할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a compound index in the db
        constraints=[ormar.IndexColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!인덱스에 포함되어야 하는 열의 조합에 대한 제약 조건입니다. 한 열 인덱스를 설정하려면 고유한 공개 매개 변수를 사용하십시오. 물론 이 매개 변수를 사용하여 많은 열을 인덱스로 설정할 수 있지만 각 열은 별도의 인덱스가 됩니다.

열 확인

ormar_config 개체 제약 조건 매개 변수를 제공하여 이 매개 변수를 설정할 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import datetime

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a level check in the db
        constraints=[
            ormar.CheckColumns("start_time < end_time", name="date_check"),
        ],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    start_date: datetime.date = ormar.Date()
    end_date: datetime.date = ormar.Date()

!!!일부 데이터베이스는 제약 조건 확인(예: MySQL)을 적극적으로 지원하지 않습니다.

캔틸레버 구조

각 ormar 이후로. 모델은 또한 pydantic 모델이므로 pydantic 구성의 설정을 조정해야 할 수도 있습니다.

pydantic에서 이 작업을 수행하는 방법은 모델에 제공된 모델 _config 사전의 설정을 조정하는 것입니다. 이는 ormar 모델에서도 동일한 방식으로 작동합니다.

따라서 자신의 기본 설정을 설정하려면 ormar_config 클래스뿐만 아니라 모델 _config=ConFigDict() 클래스에도 모델을 제공해야 합니다.

!!!참고 사용 가능한 설정에 대해 자세히 알아보려면 Pydantic 구성 페이지를 방문하십시오.

자신의 구성을 제공하지 않으면 ormar가 대신합니다. 제공된 기본 구성은 다음과 같습니다.

1
model_config = ConFigDict (ate_ = True, ser_json_bytes = "base64")

따라서 설정을 재정의하거나 자신의 예제 모델을 제공하려면 다음과 같이 하십시오.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    model_config = pydantic.ConfigDict(frozen=True)

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

모델의 추가 필드

기본적으로 Ormar는 모델에 추가 필드를 전달하는 것을 금지합니다.

이 작업을 수행하려고 하면 모델 오류가 발생합니다.

데이터베이스에 추가 필드를 저장할 수 없으므로 기본적으로 해당 필드를 비활성화하는 것이 가능한 옵션처럼 보입니다.

대신 pydantic에서 기본 옵션은 이러한 추가 필드를 무시하는 것이므로 ormar는 동일한 방식으로 작동하도록 ormar_config 추가 설정을 제공합니다.

ormar에 전달된 추가 필드를 무시하려면 이 설정을 기본 Extra.for 대신 Extra.로 설정하십시오.

ormar는 추가 필드를 허용하지 않습니다. 무시하거나 비활성화할 수만 있습니다(있는 경우 예외 제기).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Ormar, OrmarConfig에서 추가 수입

클래스 차일드(ormar. 모델):
    ormar_config = OrmarConfig (
        테이블 이름 = "아이들",
        추가 = 추가 필드 존재에 대한 예외를 방지하기 위해 추가 설정을 설정합니다.
    )

    ID: int = ormar. 정수(이름 = "chard_id", prial_key = 참)
    첫 번째 이름: str = ormar. 문자열(이름 = "fname", max_long = 100)
    성: str = ormar. 문자열(이름 = "lname", max_long = 100)

모든 모델에서 동일한 설정을 설정하려면 모범 사례 및 기본 _ormar_config 개념을 확인하십시오.

모델 정렬

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

기본 정렬 예제(지정되지 않음 - 기본 키로 지정됨):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base_ormar_config = ormar. OrmarConfig (
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    메타데이터 = sqlalchemy. 메타데이터(),
)


# 열 ID 오름차순별 기본 정렬
클래스 작성자(ormar. 모델):
    ormar_config = base_ormar_config 사본(
        표 이름 = "저자",
    )

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

수정

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base_ormar_config = ormar. OrmarConfig (
    데이터베이스 = 데이터베이스. 데이터베이스(DATABASE_URL),
    메타데이터 = sqlalchemy. 메타데이터(),
)

# 이제 이름 내림차순별 기본 정렬
클래스 작성자(ormar. 모델):
    ormar_config = base_ormar_config 사본(
        ords_by=["-name"],
        표 이름 = "저자",
    )

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

모델 초기화

데이터베이스에 모델 인스턴스를 만들고 저장하는 방법에는 두 가지가 있습니다.

나중에 프로그램이 실행될 때 인스턴스를 수정할 계획이라면 모델을 일반 클래스로 시작하고 저장() 호출을 기다릴 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

모델을 시작하고 동시에 데이터베이스에 저장하려면 쿼리 세트 메서드 생성()을 사용하십시오.

한 번에 여러 개체를 생성하려면 bulk_create() Queryset 방법을 사용하십시오.

각 모델에는 개체 매개 변수로 초기화된 쿼리 집합이 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

!!!정보 쿼리 세트(대량 작업 포함) 및 사용 가능한 방법에 대해 자세히 알아보려면 쿼리를 방문하십시오.

모델 저장 상태

각 모델 인스턴스는 서로에 대해 아무것도 모르는 별도의 파이썬 개체입니다.

1
2
3
4
5
6
7
8
트랙 1 = 트랙을 기다립니다.ts.get (이름 = 'The Bird')
트랙 2 = 트랙.ts.get을 기다립니다(이름 = '새')
트랙1==트랙2#트루 주장

track1.name='The Bird2'
기다려track1.save()
주장track1.name==track2.name
# track2는 업데이트되지 않으며 track1에 대해 아무것도 모릅니다.

개체 자체에 저장된 상태가 있으며 다음과 같이 설정됩니다.

  • 모델에 삽입 방법을 저장/업데이트/로드/업데이트한 후 모델 저장 create/get/first/all/get_or_create/update_or_create 방법 이후에 저장된* 모델
  • 모델은 대량_업데이트 및 대량_생성에 전달되면 저장됩니다.
  • ManyToAll 관련 개체를 추가/제거한 후 모델 저장(모델 인스턴스를 통해 자동으로 저장/삭제)
  • 모델은 자체 필드를 변경한 후 저장되지 않습니다(Model.pk 별칭으로 pk 포함).
  • ForeignKey 관련 개체를 추가/제거한 후 모델이 저장되지 않음(fk 열이 저장되지 않음)
  • 는 __init_init__를 사용하여 Instantiation 후 모델을 저장하지 않습니다(QuerySet.create를 사용하지 않거나 저장을 호출하기 전에).

ModelInstant. 속성을 사용하여 모델이 저장되었는지 확인할 수 있습니다.