Lewati ke isi

metode model

!!!Interaksi utama tip dengan database diekspos melalui objek QuerySet yang diekspos sebagai Model.object pada setiap model, mirip dengan orm django.

1
Untuk membaca lebih lanjut tentang **Quering, bergabung dengan tabel, tidak termasuk bidang, dll. kunjungi [Pertanyaan][queries] Bagian.**

Setiap contoh model memiliki seperangkat metode untuk menyimpan, memperbarui, atau memuat dirinya sendiri.

Metode yang tersedia adalah sebagai berikut.

metode bertele-tele

Perhatikan bahwa setiap ormar. Model juga berbentuk pydantic. BaseModel, jadi semua metode pydantic juga dapat digunakan pada model, terutama metode model\ _ dump () dan model\ _ dump\ _ json (), yang juga dapat menerima pengecualian, inklusi, dan parameter lainnya.

Untuk membaca lebih lanjut, lihat dokumentasi pydantic

Model\ _ konstruksi ()

Konstruksi model_adalah padanan asli dari metode__init_\ _ yang digunakan untuk membangun contoh baru.

Perbedaannya adalah model\ _ membangun validasi lompat, jadi Anda harus menggunakannya ketika Anda tahu datanya benar dan dapat dipercaya. Manfaat menggunakan konstruksi adalah kecepatan eksekusi karena melewatkan validasi.

!!!Perhatikan bahwa sebagai lawan dari metode pydantic.model\ _ konstruksi - setara ormar juga akan menangani model terkait bersarang.

Peringatan, ingat bahwa konstruktor tidak melakukan konversi, pemeriksaan, dll. karena validasi dilewati. Oleh karena itu, Anda bertanggung jawab untuk menyediakan data yang valid dan dapat digunakan oleh database.

1
2
3
4
Hanya dua hal yang masih dilakukan oleh konstruksi adalah:

*  Memberikan nilai `default` untuk tidak mengatur bidang
*  Inisialisasi model ormar bersarang jika Anda lulus kamus atau nilai kunci utama

Tempat pembuangan model ()

Model\ _ dump adalah metode yang diwarisi dari Pydantic, tetapi Ormar menambahkan parameternya sendiri dan memiliki beberapa nuansa dalam menggunakan nilai default, jadi tercantum di sini untuk kejelasan.

Model\ _ dump mengekspor data dari pohon model ke kamus.

Model\ _ deskripsi parameter dump:

Sertakan (atau modifikasi)

include: Union[Set, Dict] = None

Kumpulan nama bidang atau kamus untuk dicantumkan dalam kamus yang dikembalikan.

Perhatikan bahwa pydantic memiliki pola yang tidak umum untuk memasukkan / mengecualikan bidang dari daftar berdasarkan indeks (seperti halnya model bersarang). Jika Anda ingin mengecualikan bidang dari semua anak, Anda harus menempatkan\ __Semuanya_\ _ kunci diteruskan ke kamus.

Anda tidak dapat mengecualikan model bersarang di Set dalam pydantic, tetapi Anda bisa di ormar (dengan menambahkan garis bawah ganda ke nama relasional, yaitu tidak termasuk nama kategori buku yang dapat Anda gunakan)exclude={"book__category__name"}.

Ormar tidak mendukung pengecualian / inklusi indeks dan menerima notasi yang disederhanakan dan lebih ramah pengguna.

Untuk memeriksa cara memasukkan / mengecualikan ladang, termasuk ladang bersarang, periksa bagian Ladang dengan penjelasan dan contoh ekstensif.

!!!Perhatikan bahwa sebenarnya, di ormar, Anda dapat mengecualikan model bersarang dalam koleksi, dan Anda dapat mengecualikan dari seluruh pohon model sebagai tanggapan\ _ model\ _ dikecualikan dan respons\ _ model\ _ termasuk dalam fastapi!

Kecualikan (atau modifikasi)

exclude: Union[Set, Dict] = None

Pengumpulan atau kamus nama lapangan untuk dikeluarkan dari kamus yang dikembalikan.

Perhatikan bahwa pydantic memiliki pola yang tidak umum untuk memasukkan / mengecualikan bidang dari daftar berdasarkan indeks (seperti halnya model bersarang). Jika Anda ingin mengecualikan bidang dari semua anak, Anda harus menempatkan\ __Semuanya_\ _ kunci diteruskan ke kamus.

Anda tidak dapat mengecualikan model bersarang di Set dalam pydantic, tetapi Anda dapat melakukannya di ormar (dengan menambahkan garis bawah ganda ke nama relasional, yaitu tidak termasuk nama kategori buku yang Anda gunakan)exclude={"book__category__name"}).

Ormar tidak mendukung pengecualian / inklusi indeks dan menerima notasi yang disederhanakan dan lebih ramah pengguna.

Untuk memeriksa cara memasukkan / mengecualikan ladang, termasuk ladang bersarang, periksa bagian Ladang dengan penjelasan dan contoh ekstensif.

!!!Perhatikan bahwa sebenarnya, di ormar, Anda dapat mengecualikan model bersarang dalam koleksi, dan Anda dapat mengecualikan dari seluruh pohon model sebagai tanggapan\ _ model\ _ dikecualikan dan respons\ _ model\ _ termasuk dalam fastapi!

Kecualikan\ _ Batalkan Pengaturan

Kecualikan Tidak Set: Boolean = Salah

Bendera menunjukkan apakah bidang yang tidak diatur secara eksplisit ketika model dibuat harus dikeluarkan dari kamus yang dikembalikan.

!!!Peringatan, harap dicatat bahwa setelah menyimpan data ke database, setiap bidang memiliki nilainya sendiri - >, yang dapat diberikan oleh Anda, nilai default, atau tidak sama sekali.

 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
Itu berarti bahwa ketika Anda memuat data dari database,**semua bidang**diatur, dan bendera ini pada dasarnya berhenti bekerja!


Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100, default = "Test")
    Visibilitas: bool = ormar. Boolean (default = Benar)


Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    Harga: float = ormar. Mengambang (default = 9,99)
    Kategori: Daftar [Kategori] = ormar. ManyToMany (Kategori)

Kategori = Kategori (nama = "Tes 2")
Assert kategori model _ dump () = = {'id': None, 'item': [], 'name': 'Test 2',
                           'Visibilitas': Benar}
Tegaskan kategori. model _ dump (tidak termasuk _ unset = Benar) = = {'items': [], 'name': 'Test 2'}

Tunggu category.save
Kategori 2 = menunggu Kategori. Objek. Dapatkan ()
Tegaskan kategorik2. model _ dump () = = {'id': 1, 'item': [], 'name': 'Test 2',
                            'Visibilitas': Benar}
# CATATAN bagaimana setelah memuat dari db semua bidang diatur secara eksplisit
# karena inilah yang terjadi ketika Anda mengisi model dari db
Tegaskan kategorymodel _ dump (tidak termasuk _ unset = Benar) = = {'id': 1, 'item': [],
                                              'Nama': 'Tes 2', 'visibilitas': Benar}

Tidak termasuk nilai default

exclude_defaults: bool = False

Bendera yang menunjukkan bahwa itu sama dengan nilai default (apakah ditetapkan atau tidak) harus dikeluarkan dari kamus yang dikembalikan

 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
Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100, default = "Test")
    Visibilitas: bool = ormar. Boolean (default = Benar)

Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    Harga: float = ormar. Mengambang (default = 9,99)
    Kategori: Daftar [Kategori] = ormar. ManyToMany (Kategori)

Kategori = Kategori ()
# perhatikan bahwa Integer pk adalah dengan autoincrement default jadi opsional
Tegaskan kategori. model _ dump () = = {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
Tegaskan kategori. model _ dump (tidak termasuk _ default= Benar) = = {'items': []}

# simpan dan muat ulang data
Tunggu category.save
Kategori 2 = menunggu Kategori. Objek. Dapatkan ()

Tegaskan kategorik2. model _ dump () = = {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
Tegaskan kategorik2. model _ dump (tidak termasuk _ default= Benar) = = {'id': 1, 'items': []}

Tidak termasuk\ _ Tidak ada

Tidak termasuk\ _ Tidak ada: Boolean = Salah

Bendera menunjukkan apakah bidang yang sama dengan Tidak ada harus dikecualikan dari kamus yang dikembalikan.

 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
Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100, default = "Test," nullable = True)
    Visibilitas: bool = ormar. Boolean (default = Benar)


Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    Harga: float = ormar. Mengambang (default = 9,99)
    Kategori: Daftar [Kategori] = ormar. ManyToMany (Kategori)


Kategori = Kategori (nama = Tidak ada)
Assert kategori model _ dump () = = {'id': Tidak ada, 'item': [], 'name': Tidak ada,
                           'Visibilitas': Benar}
# perhatikan id belum disetel jadi Tidak ada dan dikecualikan
Tegaskan kategori. model _ dump (tidak termasuk _ none = Benar) = = {'items': [], 'visibility': True}

Tunggu category.save
Kategori 2 = menunggu Kategori. Objek. Dapatkan ()
Tegaskan kategorik2. model _ dump () = = {'id': 1, 'item': [], 'name': Tidak ada,
                            'Visibilitas': Benar}
Tegaskan kategorymodel _ dump (tidak termasuk _ none = Benar) = = {'id': 1, 'item': [],
                                             'Visibilitas': Benar}

Kecuali\ _ primer\ _ kunci (hanya ormar)

exclude_primary_keys: bool = False

Menetapkan bendera ke True tidak termasuk semua kolom kunci utama di pohon, termasuk model bersarang.

1
2
3
4
5
6
7
8
9
Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

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

1 = Barang (id = 1, nama = "Barang Uji")
Menegaskan item1. model _ dump () = = {"id": 1, "name": "Test Item"}
Menegaskan item1.model _ dump (tidak termasuk _ primary _ keys = Benar) = = {"name": "Test Item"}

Kecuali\ _ melalui\ _ model (hanya ormar)

exclude_through_models: bool = False

Model pass-through secara otomatis ditambahkan untuk setiap hubungan banyak-ke-banyak, dan mereka memegang parameter tambahan pada model / tabel terkait.

Pengaturan kecuali\ _ melalui\ _ model = Benar tidak termasuk semua model passthrough, termasuk model passthrough untuk submodel.

 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
Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

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


Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100)
    Kategori: Daftar [Kategori] = ormar. ManyToMany (Kategori)

# pohon mendefinisikan model
item _ dict = {
            "Nama": "tes,"
            "Kategori": [{"name": "test cat"},{"name": "test cat2"}],
        }
# selamatkan seluruh pohon
Aawait Item (* * item _ dict). save _ terkait (ikuti = Benar, save _ all = Benar)

# dapatkan nilai yang disimpan
Item = await Item.objeks.select _ related ("kategori").get ()

# secara default Anda dapat melihat model tembus (itemkategori)
Menegaskan item. model _ dump () = = {'id': 1, 'name': 'test',
                       'Kategori': [
                           {'Id': 1, 'nama': 'kucing uji',
                            'Kategori':{'id': 1, 'category': None, 'item': None}},
                           {'Id': 2, 'nama': 'test cat2',
                            'Masukkan Kategori':{'id': 2, 'category': None, 'item': None}}
                       ]}

# Anda dapat mengecualikan bidang / model tersebut
Menegaskan item. model _ dump (tidak termasuk _ through _ model = Benar) = {
                       'Id': 1, 'nama': 'tes',
                       'Kategori': [
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

Model\ _ dump\ _ json ()

Model\ _ dump\ _ json () memiliki parameter yang sama persis dengan model\ _ dump (), jadi periksa di atas.

Tentu saja, hasil akhirnya adalah string yang diwakili oleh JSON, bukan kamus.

Dapatkan\ _ pydantic ()

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

Metode ini memungkinkan Anda menghasilkan model Pydantic dari model Ormar tanpa harus memasuki kembali semua bidang.

Harap dicatat bahwa jika Anda memiliki model bersarang, itu akan menghasilkan seluruh pohon model Pydantic untuk Anda! Tetapi dengan cara yang mencegah masalah referensi melingkar.

Selain itu, Anda dapat mengeluarkan pengecualian dan / atau menyertakan parameter untuk menyimpan hanya bidang yang Anda inginkan, termasuk dalam model bersarang.

Ini berarti Anda dapat dengan mudah membuat model Pydantic untuk permintaan dan tanggapan di FastAPI.

!!! Catatan Untuk membaca lebih lanjut tentang kemungkinan pengecualian / inklusi dan cara membuat kamus atau pengaturan pengecualian, silakan kunjungi bagian Fields dari dokumentasi

Contoh model ormar yang diberikan adalah sebagai berikut:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
base _ ormar _ config = ormar. OrmarConfig (
    Metadata = sqlalchemy. MetaData (),
    Database = database. Database (DATABASE _ URL, force _ rollback = Benar),
)


Kategori Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

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


Item Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100, default = "test")
    Kategori: Opsional [Kategori] = ormar. ForeignKey (Kategori, nullable = Benar)

Anda dapat menghasilkan model Pydantic dengan panggilan sederhana.

1
PydanticKategori = Kategori. get _ pydantic (termasuk ={"id", "name"})

Ini akan menghasilkan model yang setara dengan yang berikut:

1
2
3
Kategori Kelas (BaseModel):
    ID: Opsional [int]
    Nama: Opsional [str] = "tes"

!!! Peringatan, bukanlah kebiasaan yang baik untuk memiliki beberapa kelas dengan nama yang sama dalam modul, dan itu akan merusak dokumentasi fastapi. Itu sebabnya ormar menambahkan acak 3 huruf besar ke nama kelas. Pada contoh di atas, ini berarti bahwa kelas tersebut sebenarnya akan diberi nama Kategori\ _ XIP (BaseModel).

Untuk mengecualikan atau menyertakan ladang bersarang, Anda dapat menggunakan kamus atau garis bawah ganda.

1
2
3
# kedua panggilan itu setara
PydanticKategori = Kategori. get _ pydantic (termasuk ={"id", "items__id"})
PydanticKategori = Kategori. get _ pydantic (termasuk = {"id":..., "item":{"id"}})

Struktur yang dihasilkan adalah sebagai berikut:

1
2
3
4
5
6
Item Kelas (Model Dasar):
    ID: Opsional [int]

Kategori Kelas (BaseModel):
    ID: Opsional [int]
    Item: Opsional [Daftar [Barang]]

Tentu saja, Anda juga dapat menggunakan struktur yang bersarang dalam, dan Ormar akan menghasilkan padanan Pydantic untuk Anda (dengan cara yang tidak termasuk loop).

Perhatikan bagaimana model Item di atas tidak memiliki referensi ke Kategori, meskipun dalam ormar hubungannya dua arah (dan ormar. Item memiliki bidang kategori).

Peringatan: Model Pydantic yang dihasilkan mewarisi semua validator lapangan dari model Ormar asli, termasuk validator dan validator seleksi Ormar yang didefinisikan menggunakan dekorator Pydantic.validator.

1
Tetapi, pada saat yang sama semua validator root yang hadir pada model `ormar` akan**BUKAN**disalin ke model pydantic yang dihasilkan.

Karena validator root dapat beroperasi di semua bidang dan pengguna dapat mengecualikan beberapa bidang selama pembuatan model pydantic, tidak aman untuk menyalin validator tersebut. Jika diperlukan, Anda perlu mendefinisikan ulang / menyalinnya secara manual untuk menghasilkan model pydantic.

Beban ()

Secara default, ketika Anda menanyakan tabel tanpa model terkait prefetching, Ormar masih akan membangun model terkait Anda, tetapi hanya mengisinya dengan nilai pk. Anda dapat memuat model terkait dengan memanggil metode beban ().

Load () juga dapat digunakan untuk me-refresh model dari database jika telah diubah oleh proses lain.

1
2
3
4
5
6
7
Track = menunggu Track.objeks.get (nama = 'Burung')
track.album.pk akan kembali malibu album pk (1)
track.album.name # tidak akan kembali

# Anda harus benar-benar memuat data terlebih dahulu
Menunggu track.album.load ()
track.album.name # akan mengembalikan 'Malibi'

Muat semua ()

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

Metode ini bekerja sama dengan memuat (), tetapi juga mengulangi semua hubungan model yang disebut metode dan memuat ulang dari database.

Secara default, metode load\ _ all hanya memuat model yang berhubungan langsung (satu langkah lagi) dengan model yang memanggil metode.

Namun, Anda dapat menentukan follow = Parameter yang benar untuk diulang melalui model bersarang dan memuat semuanya ke dalam pohon relasional.

Peringatan: Untuk menghindari pembaruan berulang dengan mengikuti = Pengaturan yang benar, beban\ _ semua menyimpan satu set model yang dikunjungi dan tidak melakukan beban bersarang pada model yang dikunjungi.

1
2
3
4
5
6
Jadi, jika Anda memiliki jenis hubungan berlian atau lingkaran, Anda perlu melakukan beban secara manual.

```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
```

Metode juga menerima parameter pengecualian opsional, yang bekerja persis seperti metode Exlude Fields di QuerySet. Ini memungkinkan Anda untuk menghapus bidang dari model terkait yang sedang disegarkan atau melewatkan seluruh model terkait.

Metode melakukan kueri database dan karena itu lebih efisien daripada panggilan bersarang untuk memuat () dan semua () pada model terkait.

!!!Tip Untuk mempelajari lebih lanjut tentang pengecualian, baca kecuali\ _ fields

!!!Peringatan Semua hubungan dibersihkan pada beban\ _ semua (), jadi jika Anda mengecualikan beberapa model bersarang, mereka akan kosong setelah panggilan.

Simpan ()

Selamatkan () - > Diri sendiri

Anda dapat menggunakan metode QuerySet.make () atau menginisialisasi model sebagai model Pydantic normal dan kemudian memanggil metode save () untuk membuat model baru.

Simpan () juga dapat digunakan untuk menyimpan perubahan yang dibuat pada model, asalkan kunci utama tidak diatur atau model tidak ada dalam database.

Metode save () tidak memeriksa apakah model tersebut ada dalam database, jadi jika ada, Anda akan menerima kesalahan integritas dari backend database yang dipilih jika Anda mencoba menyimpan model dengan kunci utama yang ada.

1
2
3
4
5
Track = Track (nama = 'The Bird')
Await track.save () # akan tetap model dalam database

Track = menunggu Track.objeks.get (nama = 'Burung')
Await track.save () # akan meningkatkan kesalahan integritas karena pk berpenduduk

Pembaruan ()

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

Anda dapat memperbarui model menggunakan metode QuerySet.update () atau dengan memperbarui properti model (bidang) dan memanggil metode pembaruan ().

Jika Anda mencoba memperbarui model tanpa mengatur kunci utama, pengecualian ModelPersistenceError dilemparkan.

Untuk mempertahankan model yang baru dibuat, gunakan save () atau upsert (**Metode Kwargs).

1
2
Track = menunggu Track.objeks.get (nama = 'Burung')
Menunggu track.update (nama = 'Burung Menyerang Lagi')

Untuk memperbarui hanya kolom yang dipilih dalam model ke database, berikan daftar kolom yang diperbarui ke parameter\ _ kolom.

Dalam contoh:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Film Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 100, nullable = Salah, name = "title")
    Tahun: int = ormar. Integer ()
    Keuntungan: float = ormar. Mengambang ()

Terminator = await Movie (nama = 'Terminator', tahun = 1984, profit = 0.078).save ()

terminator.name = "Terminator 2"
Terminator.year = 1991
Terminator.profit = 0,520

# perbarui hanya nama
Tunggu terminator.update (_ kolom = ["nama"])

# perhatikan bahwa instance terminator tidak dimuat ulang jadi
Terminator.year yang ditegaskan = = 1991

# tetapi begitu Anda memuat data dari db, Anda melihatnya tidak diperbarui
Menunggu terminator.load ()
Terminator yang ditegaskan. Tahun = = 1984

Peringatan!!!Perhatikan bahwa pembaruan () tidak menyegarkan contoh model Anda, jadi jika Anda mengubah lebih banyak kolom daripada yang Anda lewati di daftar\ _ kolom, contoh model Anda akan memiliki nilai yang berbeda dari database!

Perbarui sisipan ()

Makanan penutup (**kwargs) - > diri sendiri

Ini adalah proxy untuk metode save () atau update (**kwargs) di atas.

Jika kunci utama disetel ke - >, metode pembaruan disebut.

Jika pk tidak diatur, metode save () disebut.

1
2
3
4
5
Track = Track (nama = 'The Bird')
Tunggu track.upsert () # akan memanggil save karena pk kosong

Track = menunggu Track.objeks.get (nama = 'Burung')
Menunggu track.upsert (nama = 'The Bird Strikes Again') # akan memanggil pembaruan karena pk sudah berpenduduk

Hapus ()

Anda dapat menggunakan metode QuerySet.delete () atau menggunakan model Anda dan memanggil metode hapus () untuk menghapus model.

1
2
Track = menunggu Track.objeks.get (nama = 'Burung')
Menunggu lacak. Hapus () # akan menghapus model dari database

!!!Harap dicatat bahwa objek jejak tetap tidak berubah, hanya catatan dalam database yang dihapus.

Simpan terkait ()

save_related(follow: bool = False, save_all: bool = False, exclude=Optional[Union[Set, Dict]]) -> None

Metode ini mengulangi semua hubungan model yang disebut metode dan menyebut metode upsert () pada setiap model yang belum disimpan.

Untuk mengetahui kapan model disimpan, periksa bagian Save Status di atas.

Secara default, metode save\ _ lated hanya menyimpan model yang berhubungan langsung (satu langkah lagi) dengan model yang disebut metode.

Tetapi Anda dapat menentukan mengikuti = Parameter sejati untuk mengulangi melalui model bersarang dan menyimpan semuanya di pohon relasional.

Secara default, save\ _ lated hanya menyimpan model yang tidak disimpan, yang berarti mereka dimodifikasi dalam lingkup saat ini.

Jika Anda ingin memaksa semua metode terkait untuk disimpan, gunakan save\ _ all = True flag, yang akan memperbarui semua model terkait, terlepas dari status simpanannya.

Jika Anda ingin melewatkan menyimpan hubungan tertentu, Anda dapat melewati parameter pengecualian.

Kecualikan dapat berupa seperangkat hubungan modelnya sendiri, atau kamus yang juga dapat berisi item bersarang.

!!!Perhatikan bahwa parameter pengecualian dalam save\ _ lated hanya menerima nama bidang relasional, jadi jika Anda melewati bidang lain, mereka akan tetap disimpan

!!!Catatan Untuk mempelajari lebih lanjut tentang struktur kemungkinan nilai yang diteruskan ke pengecualian, periksa dokumentasi metode Queryset.fields.

Peringatan: Untuk menghindari pembaruan berulang dengan mengikuti = Pengaturan yang benar, simpan\ _ lated simpan satu set model yang dikunjungi di setiap cabang pohon relasional dan tidak melakukan save\ _ lated bersarang pada model yang dikunjungi.

1
Jadi, jika Anda memiliki jenis hubungan melingkar, Anda perlu melakukan pembaruan secara manual.

Perhatikan bahwa dengan save\ _ all = Benar dan ikuti = Benar Anda dapat menggunakan save\ _ lated () untuk menyelamatkan seluruh pohon sekaligus.

Contoh:

 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
57
58
59
Departemen Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

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


Kursus Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

    Id: int = ormar. Integer (primary _ key = Benar)
    course _ name: str = ormar. String (max _ length = 100)
    Selesai: bool = ormar. Boolean ()
    Departemen: Opsional [Departemen] = ormar. ForeignKey (Departemen)


Siswa Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

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

untuk _ simpan = {
            "departemen _ nama": "Ormar,"
            "Kursus": [
                {"course _ name": "basic1,"
                 "Selesai": Benar,
                 "Siswa": [
                     {"name": "Jack"},
                     {"name": "Abi"}
                 ]},
                {"course _ name": "basic2,"
                 "Selesai": Benar,
                 "Siswa": [
                     {"name": "Kate"},
                     {"name": "Miranda"}
                 ]
                 },
            ],
        }
# menginisialisasi seluruh pohon
Departemen = Departemen (* * untuk _ simpan)

# simpan sekaligus (satu demi satu)
Aawait departemen save _ terkait (ikuti = Benar, simpan _ semua = Benar)

departemen _ periksa = tunggu Departemen. Objek. Pilih _ semua (ikuti = Benar).dapatkan ()

untuk _ tidak termasuk = {
    "Id":...,
    "Kursus": {
        "Id":...,
        "Siswa": {"id", "studentcourse"}
    }
}
# setelah mengecualikan id dan melalui model Anda mendapatkan muatan yang sama persis dengan yang digunakan untuk
# membangun seluruh pohon
Assert department _ check model _ dump (tidak termasuk = untuk _ tidak termasuk) = = untuk _ save

Peringatan menyimpan\ _ lated () mengulangi semua hubungan dan semua model dan memperbaruinya satu per satu, sehingga akan menyimpan semua model, tetapi mungkin tidak optimal dalam hal jumlah kueri database.