Lewati ke isi

Model

Tentukan modelnya

Dengan mendefinisikan model ormar, Anda bisa mendapatkan model Pydantic yang sesuai dan tabel Sqlalchemy secara gratis. Mereka dikelola di latar belakang dan Anda tidak perlu membuatnya sendiri.

Kelas model

Untuk membangun model ormar, Anda cukup mewarisi ormar. Kelas model.

 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)

Tentukan bidang

Selanjutnya, satu atau lebih bidang ditetapkan sebagai variabel tingkat kelas.

Jenis bidang dasar

Setiap tabel harus memiliki kolom kunci utama, yang dapat Anda tentukan dengan mengatur Pratama\ _ key = Benar pada bidang yang dipilih.

Hanya satu kolom kunci utama yang diperbolehkan.

 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)

!!!Peringatan, tidak mengalokasikan Pratama\ _ kolom kunci atau mengalokasikan lebih dari satu kolom per model akan membuang ModelDefinitionError pengecualian.

Secara default, opsi kenaikan otomatis diatur ke benar jika kunci utama ditugaskan ke bidang bilangan bulat.

Anda dapat menonaktifkan ini dengan melewati autoincrement = Salah.

1
Id: int = ormar. Integer (primary _ key = Benar, autoincrement = Salah)

bidang non-database

Harap dicatat bahwa jika Anda memerlukan bidang Pydantic normal dalam model Anda (untuk menyimpan nilai pada model atau melewati nilai-nilai tertentu), Anda dapat menentukan bidang dalam Pydantic seperti biasa.

Bidang yang dibuat seperti ini ditambahkan ke bidang model pydantic - > sehingga divalidasi berdasarkan tipe bidang dan juga muncul pada hasil model\ _ dump () dan model\ _ dump\ _ json ().

Perbedaannya adalah bahwa bidang ini tidak disimpan dalam database. Jadi mereka tidak termasuk dalam kolom SQL Alchemy atau variabel tabel yang mendasarinya (periksa bagian internal di bawah ini untuk mempelajari cara mengaksesnya jika diperlukan).

Selanjutnya, bidang Pydantic tidak akan dimasukkan dalam migrasi atau operasi basis data apa pun seperti menyimpan, memperbarui, dll.

Bidang seperti ini dapat diteruskan ke muatan dalam permintaan FastAPI dan akan dikembalikan dalam respons FastAPI (tentu saja, hanya jika Anda menetapkan nilainya di suatu tempat dalam kode, karena nilai itu tidak diambil dari database). Jika Anda memberikan nilai dalam permintaan fastapidan mengembalikan contoh yang sama yang dibuat fastapi untuk Anda dalam permintaan\ _ model, Anda harus mengembalikan nilai yang sama persis dalam tanggapan.)

!!! Peringatan Bidang pydantic harus selalu opsional dan tidak dapat diubah (jika tidak, validasi beban database akan gagal).

 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)

Jika Anda mengatur bidang pydantic dengan parameter default dan tidak lulus nilai aktual dalam permintaan, Anda akan selalu mendapatkan nilai default. Karena itu bisa menjadi fungsi, Anda dapat mengatur default = datetime.datetime.now dan mendapatkan stempel waktu saat ini setiap kali Anda menelepon titik akhir dll.

Bidang non-database di FastAPI

Perhatikan bahwa bidang pengubah pydantic dan yang dihitung\ _ bidang dapat dimasukkan / dikecualikan dalam model\ _ dump () dan tanggapan fastapi, dengan inklusi / pengucilan dan respons yang sesuai\ _ model\ _ sertakan / respons\ _ model\ _ dikecualikan.

 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
# < = = bagian dari kode terkait dihapus untuk kejelasan = = >
base _ ormar _ config = ormar. OrmarConfig (
    Database = database. Database (DATABASE _ URL),
    Metadata = sqlalchemy. MetaData (),
    Mesin = sqlalchemy.create _ engine (DATABASE _ URL),
)


Pengguna Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "users2")

    Id: int = ormar. Integer (primary _ key = Benar)
    Email: str = ormar. String (max _ length = 255, nullable = Salah)
    Kata sandi: str = ormar. String (max _ length = 255)
    nama _ pertama: str = ormar. String (max _ length = 255)
    Nama belakang: str = ormar. String (max _ length = 255)
    Kategori: str = ormar. String (max _ length = 255, nullable = Benar)
    Timestamp: datetime.datetime = pydantic. Lapangan (
        Default = datetime.datetime.now
    )

# < = = bagian dari kode terkait dihapus untuk kejelasan = = >
Aplikasi = FastAPI ()

@app.post ("/ pengguna /")
Async def create _ user (pengguna: Pengguna):
    Kembali menunggu user.save

# < = = bagian dari kode terkait dihapus untuk kejelasan = = >

Tes pasti _ tidak termasuk _ field _ in _ endpoints ():
    Klien = TestClient (aplikasi)
    Dengan klien sebagai klien:
        Timestamp = datetime.datetime.now

        Pengguna = {
            "Email": "test@domain.com,"
            "Kata Sandi": "^*^% A*DA * IAAA,"
            "nama depan": "John,"
            "nama belakang": "Doe,"
            "Stempel waktu": str (stempel waktu),
        }
        Response = client.post ("/ user /," json = user)
        Daftar pencuci mulut (response.json ().keys ()) = = [
            "Id,"
            "Email,"
            "nama depan,"
            "nama belakang,"
            "Kategori,"
            "Stempel waktu,"
        ]
        # kembali adalah stempel waktu yang sama
        Tegaskan response.json ().get ("timestamp") = = str (timestamp).ganti (,"" "T")


# < = = bagian dari kode terkait dihapus untuk kejelasan = = >

Nama bidang dan nama kolom

Nama bidang default digunakan untuk model Pydantic yang mendasari dan tabel SQL Alchemy.

Jika karena alasan tertentu Anda ingin mengubah nama di database tetapi meninggalkan nama di model, Anda dapat melakukannya dengan menentukan parameter nama selama deklarasi bidang

Berikut adalah contoh model dengan nama yang diubah

 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)

Harap dicatat bahwa Anda juga dapat mengubah nama kolom kunci asing

 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")

Namun saat ini Anda tidak dapat mengubah nama kolom ManyToMany karena tetap akan melewati model lain.

 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)

Ganti set kueri default

Jika Anda ingin menyesuaikan kueri yang di jalankan Ormar, Anda dapat menentukan kelas Query Set Anda sendiri (memperpanjang Ormar QuerySet) di kelas Model, yang merupakan QuerySet default.

Anda dapat menyediakan kelas baru di kelas ormar\ _ konfigurasi sebagai argumen kelas 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
Asrama impor
Dari ormar.queryset.queryset impor QuerySet
HTTPException diimpor dari fastAPI


Kelas MyQuerySetClass (QuerySet):

    Async def first _ atau _ 404 (diri, * args, * * kwargs):
        Entitas = menunggu diri sendiri. get _ or _ none (* args, * * kwargs)
        Jika entitas Tidak Ada:
            # di fastapi atau starlette
            Meningkatkan HTTPException (404)


Buku Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy (
        Queryset _ class=MyQuerySetClass,
        Nama meja = "buku,"
    )

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 32)


# ketika buku tidak ditemukan, tingkatkan `404` menurut pandangan Anda.
Buku = menunggu Book.objeks.first _ atau _ 404 (nama = "123")

Ketik petunjuk

Harap dicatat bahwa untuk dukungan IDE yang lebih baik dan pemeriksaan mypy, Anda dapat memberikan petunjuk tipe.

 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)

Harap dicatat bahwa petunjuk jenis adalah opsional, sehingga kode ormar yang sepenuhnya valid dapat terlihat seperti ini:

 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)

!!!Peringatan: Bahkan jika Anda menggunakan petunjuk tipe, Ormar tidak akan menggunakannya untuk membangun bidang Pydantic!

1
2
Ketik petunjuk hanya ada untuk mendukung catur statis dan linting,
`ormar` membangun anotasi yang digunakan oleh `pydantic` dari ladang yang dimiliki.

ketergantungan

Karena ormar bergantung pada database dan sqlalchemistry-core untuk database joins dan pembuatan tabel, Anda perlu menetapkan dua parameter khusus untuk setiap model.

basis data

Salah satunya adalah instance database yang dibuat menggunakan URL database dalam format string koneksi sqlalchemy.

Instansi yang dibuat perlu menggunakan parameter basis data objek konfigurasi ormar\ _ yang diteruskan ke setiap model.

 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)

!!!Tip, Anda hanya perlu membuat instance database sekali dan menggunakannya untuk semua model. Jika Anda ingin menggunakan beberapa database, Anda dapat membuat beberapa database.

Alkimia

Ketergantungan kedua adalah instance MetaData sqlalchemy.

Instansi yang dibuat perlu diteruskan ke setiap model menggunakan parameter metadata objek konfigurasi 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)

!!!Tip, Anda hanya perlu membuat instance MetaData sekali dan menggunakannya untuk semua model. Jika Anda ingin menggunakan beberapa database, Anda dapat membuat beberapa database.

praktik terbaik

Perhatikan bahwa ormar membutuhkan bidang bernama ormar\ _ config, yang merupakan contoh dari kelas OrmarConfig. Untuk menyederhanakan manajemen konfigurasi, kelas OrmarConfig menyediakan metode replikasi. Oleh karena itu, Anda harus membuat objek dasar dan menggunakan salinannya di semua model, daripada memberikan parameter yang sama untuk semua model berulang kali.

 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)

nama meja

Secara default, nama tabel dibuat dari nama kelas model, yaitu nama huruf kecil plus "s."

Anda dapat mengesampingkan parameter ini dengan memberikan parameter nama tabel untuk objek konfigurasi ormar\ _.

 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)

kendala

Pada level model, Anda juga dapat mengatur batasan model-bijaksana pada kolom SQL.

Saat ini hanya batasan IndexColumns, UniqueColumns, dan CheckColumns yang didukung.

!!!Perhatikan bahwa Anda harus menggunakan kedua batasan hanya jika Anda ingin menetapkan nama pada batasan atau jika Anda ingin menetapkan indeks pada beberapa kolom, jika tidak, indeks dan properti unik di bidang ormar lebih disukai.

!!!Tip Untuk mempelajari lebih lanjut tentang batasan kolom untuk kunci utama, kunci unik, kunci asing, dan banyak lagi, kunjungi Fields.

Kolom unik

Anda dapat mengatur parameter ini dengan menyediakan parameter batasan objek ormar\ _ konfigurasi.

 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)

!!!Perhatikan bahwa batasan adalah untuk kombinasi kolom yang harus unik. Untuk membuat kolom unik, gunakan parameter umum yang unik. Tentu saja, Anda dapat membuat banyak kolom unik menggunakan parameter ini, tetapi setiap kolom akan diperiksa satu per satu.

kolom indeks

Anda dapat mengatur parameter ini dengan menyediakan parameter batasan objek ormar\ _ konfigurasi.

 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)

!!!Perhatikan bahwa batasan adalah untuk kombinasi kolom yang harus dimasukkan dalam indeks. Untuk mengatur indeks satu kolom, gunakan parameter publik yang unik. Tentu saja, Anda dapat menggunakan parameter ini untuk mengatur banyak kolom sebagai indeks, tetapi setiap kolom akan menjadi indeks terpisah.

kolom cek

Anda dapat mengatur parameter ini dengan menyediakan parameter batasan objek ormar\ _ konfigurasi.

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

!!!Perhatikan bahwa beberapa basis data tidak secara aktif mendukung kendala pemeriksaan (misalnya MySQL).

struktur kantilever

Sejak setiap ormar. Model juga merupakan model pydantic, Anda mungkin perlu menyesuaikan pengaturan konfigurasi pydantic Anda.

Cara melakukan ini dalam pydantic adalah dengan menyesuaikan pengaturan pada model\ _ kamus konfigurasi yang disediakan untuk model, yang bekerja dengan cara yang persis sama untuk model ormar.

Jadi untuk mengatur preferensi Anda sendiri, Anda perlu menyediakan model tidak hanya dengan kelas ormar\ _ config, tetapi juga dengan kelas model\ _ config = ConfigDict ().

!!!Catatan Untuk mempelajari lebih lanjut tentang pengaturan yang tersedia, kunjungi halaman konfigurasi Pydantic.

Harap dicatat bahwa jika Anda tidak menyediakan konfigurasi Anda sendiri, ormar akan melakukannya untuk Anda. Konfigurasi default yang disediakan adalah sebagai berikut:

1
Model _ config = ConfigDict (validate _ task = Benar, ser _ json _ bytes = "base64")

Oleh karena itu, untuk mengesampingkan pengaturan atau memberikan contoh model Anda sendiri, lihat seperti ini:

 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)

Bidang tambahan dalam model

Secara default, Ormar melarang Anda melewati bidang ekstra ke model.

Jika Anda mencoba melakukan ini, ModelError akan dinaikkan.

Karena bidang tambahan tidak dapat disimpan dalam database, menonaktifkan bidang tersebut secara default tampaknya seperti opsi yang layak.

Sebaliknya, dalam pydantic, opsi default adalah mengabaikan bidang tambahan seperti itu, jadi ormar menyediakan pengaturan ekstra ormar\ _ konfigurasi untuk bekerja dengan cara yang sama.

Untuk mengabaikan bidang tambahan yang diteruskan ke ormar, atur pengaturan ini ke Extra.abaikan alih-alih Extra.forbid.

Harap dicatat bahwa ormar tidak mengizinkan bidang tambahan untuk diterima. Anda hanya dapat mengabaikan mereka atau menonaktifkan mereka (membuang pengecualian jika ada).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Impor ekstra dari ormar, OrmarConfig

Anak Kelas (ormar. Model):
    ormar _ config = OrmarConfig (
        Tablename = "anak-anak,"
        Ekstra = Ekstra. Abaikan # setel pengaturan tambahan untuk mencegah pengecualian kehadiran bidang ekstra
    )

    Id: int = ormar. Integer (nama = "child _ id," primary _ key = Benar)
    first _ name: str = ormar. String (nama = "fname," max _ length = 100)
    Nama belakang: str = ormar. String (nama = "lname," max _ length = 100)

Untuk mengatur pengaturan yang sama pada semua model, periksa praktik terbaik dan konsep konfigurasi dasar\ _ ormar\ _.

Penyortiran model

Secara default, saat menanyai database dengan model tertentu, model diurutkan dalam urutan menaik oleh kolom\ _ kunci Primer. Jika Anda ingin mengubah perilaku default, Anda dapat melakukannya dengan memasok pesanan\ _ dengan parameter ke model atau mar\ _ objek konfigurasi.

Contoh urutan default (tidak ditentukan - jadi ditentukan oleh kunci utama):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base _ ormar _ config = ormar. OrmarConfig (
    Database = database. Database (DATABASE _ URL),
    Metadata = sqlalchemy. MetaData (),
)


# default diurutkan berdasarkan kolom id ascending
Kelas Penulis (ormar. Model):
    ormar _ config = base _ ormar _ config copy (
        Nama tabel = "penulis,"
    )

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)

modifikasi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
base _ ormar _ config = ormar. OrmarConfig (
    Database = database. Database (DATABASE _ URL),
    Metadata = sqlalchemy. MetaData (),
)

# sekarang default diurutkan berdasarkan nama turun
Kelas Penulis (ormar. Model):
    ormar _ config = base _ ormar _ config copy (
        order _ by = ["-name"],
        Nama tabel = "penulis,"
    )

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)

inisialisasi model

Ada dua cara untuk membuat dan menyimpan contoh model dalam database.

Jika Anda berencana untuk mengubah instance nanti saat program berjalan, Anda dapat memulai model sebagai kelas normal dan menunggu panggilan save ().

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

Jika Anda ingin memulai model dan menyimpannya di database secara bersamaan, gunakan metode QuerySet buat ().

Untuk membuat beberapa objek sekaligus, gunakan metode QuerySet massal\ _ buat ().

Setiap model memiliki seperangkat pertanyaan yang diinisialisasi sebagai parameter objek

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

!!!Info Untuk mempelajari lebih lanjut tentang set kueri (termasuk operasi massal) dan metode yang tersedia, kunjungi Kueri

model menyelamatkan negara

Setiap contoh model adalah objek Python terpisah yang tidak tahu apa-apa tentang satu sama lain.

1
2
3
4
5
6
7
8
Track1 = menunggu Track.objeks.get (nama = 'Burung')
Track2 = menunggu Track.objeks.get (nama = 'Burung')
Tegaskan track1 = = track2 # Benar

track1.name = 'The Bird2'
Tunggu track1.save
Tegaskan track1.name = = track2.name
# track2 tidak memperbarui dan tidak tahu apa-apa tentang track1

Objek itu sendiri memiliki keadaan tersimpan, ditetapkan sebagai berikut:

  • Simpan model setelah menyimpan / memperbarui / memuat / memperbarui metode penyisipan pada model Model* disimpan setelah metode create/get/first/all/get_or_create/update_or_create
  • Model disimpan ketika diteruskan ke massal\ _ update dan massal\ _ buat
  • Simpan model setelah menambahkan / menghapus Banyak objek terkait (simpan / hapus secara otomatis melalui contoh model)
  • Model tidak disimpan setelah mengubah bidang sendiri (termasuk pk sebagai alias Model.pk)
  • Model tidak disimpan setelah menambahkan / menghapus Objek terkait ForeignKey (kolom fk tidak disimpan)
  • Menggunakan\ __Di dalam_\ _ Jangan menyimpan model setelah instantiation (tanpa menggunakan QuerySet.buat atau sebelum memanggil simpan)

Anda dapat menggunakan ModelInstant. Properti yang disimpan untuk memeriksa apakah model telah disimpan