Lewati ke isi

warisan

Dari berbagai jenis pewarisan model ORM, Ormar saat ini mendukung dua di antaranya:

  • campur
  • Warisan tabel beton (set induk ke abstrak = Benar)

tipe warisan

Ringkasan singkat tentang berbagai jenis warisan:

  • Mixins\ [dukungan] - jangan subclass ormar. Model, cukup definisikan bidang yang akan digunakan nanti pada model yang berbeda (misalnya dibuat\ _ tanggal dan diperbarui\ _ tanggal pada setiap model), hanya model sebenarnya yang membuat tabel, tetapi tambahkan bidang dalam campuran Warisan tabel beton* \ [DUKUNGAN] - berarti bahwa orang tua ditandai sebagai abstrak, dan setiap anak memiliki tabel sendiri yang berisi kolom dari orang tua dan kolom anaknya sendiri, agak mirip dengan Mixins, tetapi orang tua juga merupakan model
  • Warisan tabel tunggal\ [tidak didukung] - berarti hanya satu tabel yang dibuat di mana bidang tersebut merupakan kombinasi / jumlah dari model induk dan semua model anak, tetapi model anak hanya menggunakan subset kolom dalam database (semua model induk dan kolomnya sendiri, melewatkan model anak lainnya)
  • Warisan tabel berganda / bergabung\ [tidak didukung] - berarti bahwa beberapa kolom disimpan pada model induk dan beberapa disimpan pada model anak, mereka terhubung satu sama lain dalam hubungan satu lawan satu, dan kedua model dioperasikan di latar belakang segera
  • Model proxy\ [tidak mendukung] - berarti hanya orang tua yang memiliki tabel yang sebenarnya, dan anak hanya menambahkan metode, memodifikasi pengaturan, dll.

campur

Untuk menggunakan Mixins, cukup definisikan kelas yang tidak mewarisi dari ormar. Model, tetapi mendefinisikan ormar. Bidang sebagai variabel kelas.

 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
base _ ormar _ config = ormar. OrmarConfig (
    Database = database. Database (DATABASE _ URL),
    Metadata = sqlalchemy. MetaData (),
    Mesin = sqlalchemy.create _ engine (DATABASE _ URL),
)


# a mixin mendefinisikan bidang tetapi merupakan kelas python normal
AuditMixin Kelas:
    dibuat _ oleh: str = ormar. String (max _ length = 100)
    diperbarui _ oleh: str = ormar. String (max _ length = 100, default = "Sam")


Kelas Tanggal FieldsMixins:
    Dibuat _ tanggal: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)
    Diperbarui _ date: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)


# model dapat mewarisi dari satu atau lebih campuran
Kategori Kelas (ormar. Model, DateFieldsMixins, AuditMixin):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50, unique = True, index = True)
    Kode: int = ormar. Integer ()

!!!Perhatikan bahwa Mixin bukan model, jadi Anda masih perlu mewarisi dari ormar. Model dan definisikan bidang konfigurasi ormar\ _ dalam model akhir.

Kelas Kategori di atas akan memiliki empat bidang tambahan: dibuat\ _ tanggal, diperbarui\ _ tanggal, dibuat\ _ oleh, dan Diperbarui\ _ oleh.

Hanya satu tabel yang akan dibuat untuk Kategori model, di mana bidang kelas Kategori digabungkan dengan semua bidang Mixins.

Harap dicatat bahwa Mixin dalam nama kelas adalah opsional, tetapi ini adalah latihan Python yang bagus.

pewaris meja beton

Secara konseptual, pewarisan meja beton sangat mirip dengan Mixins, tetapi menggunakan ormar yang sebenarnya. Model sebagai kelas dasar.

Peringatan!!!Perhatikan bahwa kelas dasar memiliki Abstrak = Benar diatur dalam objek konfigurasi ormar, yang melemparkan ModelDefinitionError jika Anda mencoba untuk mewarisi dari kelas markup non-abstrak.

Karena model abstrak ini tidak pernah diinisialisasi, Anda dapat melewatkan metadata dan database dalam definisi konfigurasi ormar\ _.

Tetapi jika Anda menyediakannya - itu akan diwariskan sehingga Anda tidak perlu menyediakan metadata dan database di kelas akhir / konkret

Harap dicatat bahwa Anda selalu dapat menimpanya di kelas anak / beton jika perlu.

Terlebih lagi, setidaknya satu kelas dalam rantai pewarisan harus menyediakan database dan metadata - jika tidak, kesalahan akan muncul.

 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
# perhatikan bahwa kelas dasar memiliki abstrak = Benar
# karena model ini tidak akan pernah diinisialisasi, Anda dapat melewati metadata dan database
Kelas AuditModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    dibuat _ oleh: str = ormar. String (max _ length = 100)
    diperbarui _ oleh: str = ormar. String (max _ length = 100, default = "Sam")


# tetapi jika Anda menyediakannya, itu akan diwariskan - DRY (Jangan Ulangi Diri Anda) beraksi
Kelas DateFieldsModel (ormar. Model):
    ormar _ config = base _ ormar _ config copy (
        Abstrak = Benar,
        Metadata = metadata,
        Database = db,
    )

    Dibuat _ tanggal: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)
    Diperbarui _ date: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)


# dengan begitu Anda tidak perlu menyediakan metadata dan database di kelas konkret
Kategori Kelas (DateFieldsModel, AuditModel):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50, unique = True, index = True)
    Kode: int = ormar. Integer ()

Daftar opsi / pengaturan yang diwariskan adalah sebagai berikut: metadata, database, dan kendala.

Tentu saja, selain itu, semua bidang di kelas dasar digabungkan dan dibuat dalam tabel beton model akhir.

!!!Harap dicatat bahwa Anda tidak harus memberikan abstarct = Salah di kelas akhir - ini adalah pengaturan default yang tidak diwariskan.

Mendefinisikan ulang bidang di subkelas

Harap dicatat bahwa Anda dapat mendefinisikan kembali bidang yang dibuat sebelumnya seperti pewarisan kelas Python biasa.

Setiap kali Anda mendefinisikan bidang dengan nama yang sama dan definisi baru, itu sepenuhnya menggantikan bidang yang ditentukan sebelumnya.

 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
# kelas dasar
Kelas DateFieldsModel (ormar. Model):
    ormar _ config = OrmarConfig (
        Abstrak = Benar,
        Metadata = metadata,
        Database = db,
        # perhatikan bahwa UniqueColumns membutuhkan nama kolom db sqlalchemy bukan yang ormar
        Kendala = [ormar. UniqueColumns ("creation _ date," "modification _ date") ]
    )

    dibuat _ tanggal: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, name = "creation _ date"
    )
    Diperbarui _ date: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, nama = "modifikasi _ tanggal"
    )


Kelas Mendefinisikan Ulang Lapangan (DateFieldsModel):
    ormar _ config = OrmarConfig (
        Tablename = "mendefinisikan ulang,"
        Metadata = metadata,
        Database = db,
    )

    Id: int = ormar. Integer (primary _ key = Benar)
    # di sini _ date yang dibuat digantikan oleh bidang String
    dibuat _ date: str = ormar. String (max _ length = 200, name = "creation _ date")


# Anda dapat memverifikasi bahwa bidang akhir dinyatakan dan dibuat dengan benar
berubah _ field = Mendefinisikan Ulang Field.ormar _ config model _ fields ["dibuat _ tanggal"]
Tegaskan diubah _ field default adalah Tidak Ada
Penegasan diubah _ field alias = = "kreasi _ tanggal"
Menegaskan apa saja (x.name = = "penciptaan _ tanggal" untuk x di RedefinedField.ormar _ config table.columns)
Contoh pencuci mulut (
    Mendefinisikan Ulang Field ormar _ konfigurasi table.columns ["creation _ date"] .type,
    Sqlalchemy.sql.sqltypes. string,
)

!!!memperingatkan bahwa jika Anda menyatakan batasan UniqueColumns dengan nama kolom, model akhir harus menyatakan kolom dengan nama yang sama. Jika tidak, ModelDefinitionError dinaikkan.

1
2
3
4
5
6
Jadi contoh di atas jika Anda tidak memberikan `name` untuk `created_date` dalam model `RedefinedField`
Ormar akan mengeluh.

`created_date: str = ormar.String(max_length=200) # exception`

`created_date: str = ormar.String(max_length=200, name="creation_date2") # exception`

hubungan warisan

Anda dapat menyatakan hubungan di setiap langkah pewarisan, baik di kelas orang tua atau kelas anak.

Ketika Anda mendefinisikan hubungan di tingkat model anak, itu mengesampingkan hubungan yang didefinisikan dalam model orang tua (jika nama bidang yang sama digunakan), atau jika Anda mendefinisikan hubungan baru, itu hanya dapat diakses oleh model anak itu.

Saat mewarisi hubungan, Anda selalu perlu memperhatikan parameter\ _ nama terkait, yang harus unik dalam model yang relevan ketika Anda mendefinisikan beberapa subkelas yang mewarisi hubungan yang sama.

Jika Anda tidak memberikan argumen\ _ nama terkait, ormar akan menghitungnya untuk Anda. Ini berlaku untuk warisan, karena semua submodel harus memiliki nama kelas yang berbeda, yang digunakan untuk menghitung default terkait\ _ nama (class.name () + 's ').

Namun, jika Anda memberikan\ _ nama terkait, nama tersebut tidak dapat digunakan kembali di semua submodel karena mereka saling mengesampingkan di sisi model terkait.

Oleh karena itu, Anda memiliki dua opsi:

  • Mendefinisikan ulang bidang relasional dalam submodel dan secara manual memberikan parameter\ _ nama terkait yang berbeda
  • membiarkan ormar menangani - > auto-menyesuaikan terkait\ _ nama sebagai: asli terkait_nama + "_" + nama tabel submodel

Ini mungkin terdengar rumit, tetapi mari kita lihat contoh berikut:

hubungan 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
# model normal yang digunakan dalam hubungan
Kelas Orang (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

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


# model induk - harus abstrak
Mobil Kelas (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50)
    Pemilik: Person = ormar. ForeignKey (Orang)
    # perhatikan bahwa kami merujuk ke model Person lagi sehingga kami**harus**memberikan nama _ terkait
    co _ owner: Person = ormar. ForeignKey (Person, terkait _ name = "coowned")
    Dibuat _ tanggal: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)


Truk Kelas (Mobil):
    ormar _ config = base _ ormar _ config copy ()

    max _ kapasitas: int = ormar. Integer ()


Bus Kelas (Mobil):
    ormar _ config = base _ ormar _ config (tablename = "bus")

    max _ person: int = ormar. Integer ()

Sekarang, ketika Anda memeriksa bidang pada model Person, Anda akan mendapatkan:

1
2
3
4
5
6
7
8
9
Orang ormar _ config model _ fields
"""
{'Id':<class 'ormar.fields.model_fields.Integer'>,
'Nama':<class 'ormar.fields.model_fields.String'>,
'Truk':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coown _ truck':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Buss':<class 'ormar.fields.foreign_key.ForeignKey'>,
coownx _ bus ':<class 'ormar.fields.foreign_key.ForeignKey'>}
"""

Perhatikan bagaimana Anda memiliki ladang truk dan bus, yang mengarah ke kategori truk dan bus yang dimiliki orang ini. Tidak ada parameter\ _ nama terkait, sehingga nama default digunakan.

Mobil milik bersama perlu dirujuk oleh truk\ _ dan bus milik bersama. Ormar menambahkan sufiks\ _ truk dan\ _ bus yang diambil dari nama tabel submodel.

Kelihatannya bagus, tapi nama default truk yang dimiliki OK (truk), tapi busnya jelek, jadi bagaimana kita mengubahnya?

Solusinya sangat sederhana - cukup definisikan ulang bidang di kelas Bus dan berikan parameter\ _ nama terkait yang berbeda.

1
2
3
4
5
6
7
Contoh lainnya di atas tetap sama
Bus Kelas (Mobil):
    ormar _ config = base _ ormar _ config (tablename = "bus")

    # bidang baru yang mengubah nama _ terkait
    Pemilik: Person = ormar. ForeignKey (Orang, terkait _ name = "bus")
    max _ person: int = ormar. Integer ()

Kolom terlihat jauh lebih baik sekarang.

1
2
3
4
5
6
7
8
9
Orang ormar _ config model _ fields
"""
{'Id':<class 'ormar.fields.model_fields.Integer'>,
'Nama':<class 'ormar.fields.model_fields.String'>,
'Truk':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coown _ truck':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Bus':<class 'ormar.fields.foreign_key.ForeignKey'>,
coown _ bus ':<class 'ormar.fields.foreign_key.ForeignKey'>}
"""

!!!Perhatikan bahwa Anda juga dapat memberikan\ _ nama terkait untuk bidang pemilik, yang menambahkan akhiran yang benar.

1
2
3
`owner: Person = ormar.ForeignKey(Person, related_name="owned")`

Dan bidang model untuk mobil milik Person akan menjadi `owned_trucks` dan `owned_buses`.

hubungan banyak-ke-banyak

Demikian pula, Anda dapat mewarisi dari model yang menyatakan hubungan ManyToMany, tetapi dengan satu perbedaan substansial - model Through.

Karena model Melalui akan dapat memegang bidang lain, dan sekarang hanya menghubungkan dua tabel (dari dan ke satu meja), setiap anak yang mewarisi bidang relasional M2M harus memiliki model Melalui yang terpisah.

Tentu saja, Anda dapat mengesampingkan hubungan di setiap submodel, tetapi itu membutuhkan kode tambahan dan menghancurkan arti pewarisan secara keseluruhan. Ormar akan menangani ini untuk Anda jika Anda menyetujui konvensi penamaan default, dan Anda selalu dapat mengesampingkan konvensi itu secara manual di submodel jika diperlukan.

Sekali lagi, mari kita lihat contoh untuk memahami konsep dengan lebih mudah.

Kami akan mengubah contoh sebelumnya yang dijelaskan di atas untuk menggunakan hubungan m2m dari co\ _ owner.

 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
# orang tetap sama seperti di atas
Kelas Orang (ormar. Model):
    ormar _ config = base _ ormar _ config copy ()

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

# baru melalui model antara Person dan Car2
Kelas PersonsCar (ormar. Model):
    ormar _ config = base _ ormar _ config (tablename = "car _ x _ person")

# perhatikan bagaimana rekan _ pemilik sekarang hubungan ManyToMany
Kelas Car2 (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50)
    # perhatikan _ nama yang terkait - harus unik di seluruh Orang
    # pemodelan, terlepas dari berapa banyak model berbeda yang mengarah ke Person
    Pemilik: Person = ormar. ForeignKey (Person, terkait _ name = "dimiliki")
    co _ owners: List [Person] = ormar. Banyak (
        Orang, melalui = PersonalMobil, terkait _ name = "dimiliki bersama"
    )
    Dibuat _ tanggal: datetime.datetime = ormar. DateTime (default = datetime.datetime.now)


# model anak hanya mendefinisikan Bidang tambahan
Truk Kelas2 (Mobil 2):
    ormar _ config = base _ ormar _ config (tablename = "truk s2")

    max _ kapasitas: int = ormar. Integer ()


Kelas Bus2 (Car2):
    ormar _ config = base _ ormar _ config (tablename = "buses2")

    max _ person: int = ormar. Integer ()

Ormar secara otomatis memodifikasi\ _ nama bidang terkait untuk menyertakan nama tabel submodel. Nama default adalah nama asli terkait_+ '_' + nama subtabel.

Jadi untuk kelas Truck2, hubungan yang ditentukan owner: Person = ormar.ForeignKey(Person, related_name="owned") menjadi milik\ _ trucks2

Anda dapat memverifikasi nama dengan memeriksa daftar bidang yang ada pada model orang tersebut.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Orang ormar _ config model _ fields
{
# perhatikan bagaimana semua bidang hubungan harus unik pada Person
# terlepas dari apakah dibuat sendiri atau ditimpa secara manual
'Id':<class 'ormar.fields.model_fields.Integer'>,
'Nama':<class 'ormar.fields.model_fields.String'>,
# perhatikan bahwa kami memperluas contoh sebelumnya sehingga semua bidang 'lama' ada di sini
'Truk':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coown _ truck':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Bus':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coown _ bus':<class 'ormar.fields.foreign_key.ForeignKey'>,
# bidang terkait yang baru didefinisikan
milik _ trucks2 ':<class 'ormar.fields.foreign_key.ForeignKey'>,
'rekan _ trucks2':<class 'abc.ManyToMany'>,
milik _ buses2 ':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ buses2': <class 'abc.ManyToMany'>
}

Tapi bukan itu saja. Ini adalah struktur internal ormar, tetapi mempengaruhi struktur data dalam database, jadi mari kita periksa model pass-through untuk model Bus2 dan Truck2.

1
2
3
4
5
6
7
8
9
Bus2.ormar _ config model _ fields ['co _ owner'] .through
<class 'abc.PersonsCarBus2'>
Bus2. ormar _ config model _ fields ['co _ owner']. ormar _ config. tablename
'mobil _ x _ person _ buses2'

Truck2. ormar _ config model _ fields ['co _ owner']. melalui
<class 'abc.PersonsCarTruck2'>
Truck2. ormar _ config model _ fields ['co _ owner']. ormar _ config tablename
'mobil _ x _ person _ trucks2'

Seperti yang Anda lihat di atas, Ormar mengkloning model Melalui untuk setiap subkelas, menambahkan nama subkelas di bagian akhir, dan mengubah nama tabel bidang kloning untuk menggunakan nama meja anak.

Harap dicatat bahwa tidak hanya model asli yang tidak digunakan, tetapi tabel untuk model itu juga dihapus dari metadata.

1
2
3
Bus2.ormar _ konfigurasi metado.tables.keys ()
dict _ keys (['test _ date _ model', 'kategori', 'subjek', 'orang', 'truk', 'bus',
           car _ x _ person _ trucks2 ',' trucks2 ',' car _ x _ person _ buses2 ',' buses2 '])

Oleh karena itu, harap dicatat bahwa jika Anda memasukkan warisan di sepanjang jalan dan mengubah model menjadi model induk abstrak, Anda mungkin kehilangan data dalam tabel jika Anda tidak hati-hati.

!!!Perhatikan bahwa nama tabel asli dan nama model model Melalui tidak pernah digunakan. Hanya tabel model kloning yang dibuat dan digunakan.

!!!Peringatan: Perhatikan bahwa setiap subkelas model yang mendefinisikan hubungan ManyToMany menghasilkan model Through baru, yang juga berarti database & tabel baru.

1
2
Itu berarti bahwa setiap kali Anda mendefinisikan model Anak, Anda perlu membuat secara manual
Tabel dalam database, atau menjalankan migrasi (dengan alembik).

Tidak termasuk bidang induk

Ormar memungkinkan Anda untuk melewatkan bidang tertentu dari model induk dalam model warisan.

!!!Perhatikan bahwa perilaku yang sama dapat dicapai dengan membagi model menjadi model dan campuran yang lebih abstrak - ini adalah pendekatan yang disukai dalam keadaan normal.

Untuk melewati bidang tertentu di submodel, daftarkan semua bidang yang ingin Anda lewati model.ormar_config.exclude_parent_fields Parameter tersebut adalah sebagai berikut:

 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
base _ ormar _ config = OrmarConfig (
    Metadata = sa. MetaData (),
    Database = database. Database (DATABASE _ URL),
)


Kelas AuditModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    dibuat _ oleh: str = ormar. String (max _ length = 100)
    diperbarui _ oleh: str = ormar. String (max _ length = 100, default = "Sam")


Kelas DateFieldsModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    dibuat _ tanggal: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, name = "creation _ date"
    )
    Diperbarui _ date: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, nama = "modifikasi _ tanggal"
    )


Kategori Kelas (DateFieldsModel, AuditModel):
    ormar _ config = base _ ormar _ config copy (
        Nama tabel = "kategori,"
        # set bidang yang harus dilewati
        tidak termasuk _ parent _ fields = ["diperbarui _ oleh," "diperbarui _ date"],
    )

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50, unique = True, index = True)
    Kode: int = ormar. Integer ()

# Perhatikan bahwa sekarang bidang yang diperbarui dalam Kategori hilang di semua tempat - > bidang ormar, bidang pydantic, dan kolom tabel sqlachemy
# jadi daftar lengkap bidang yang tersedia dalam Kategori adalah: ["dibuat _ oleh," "dibuat _ tanggal," "id," "nama," "kode"]

Harap dicatat bahwa Anda hanya perlu memberikan nama bidang, yang tidak termasuk bidang induk, terlepas dari model induk mana bidang tersebut berasal.

!!!Perhatikan bahwa jika Anda ingin menimpa bidang dalam submodel, Anda tidak perlu mengecualikannya, cukup timpa deklarasi bidang di submodel dengan nama bidang yang sama.

Peringatan: Perilaku ini dapat membingungkan mypy dan tipe checker statis, tetapi mengakses bidang yang tidak ada akan gagal saat runtime. Inilah sebabnya mengapa membagi kelas dasar lebih disukai.

Efek yang sama dapat dicapai dengan membagi kelas dasar, misalnya:

 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
base _ ormar _ config = OrmarConfig (
    Metadata = sa. MetaData (),
    Database = database. Database (DATABASE _ URL),
)


Kelas AuditCreateModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    dibuat _ oleh: str = ormar. String (max _ length = 100)


Kelas AuditUpdateModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    diperbarui _ oleh: str = ormar. String (max _ length = 100, default = "Sam")

Kelas CreateDateFieldsModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    dibuat _ tanggal: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, name = "creation _ date"
    )

Kelas UpdateDateFieldsModel (ormar. Model):
    ormar _ config = base _ ormar _ config (abstrak = Benar)

    Diperbarui _ date: datetime.datetime = ormar. Waktu Tanggal (
        Default = datetime.datetime.now, nama = "modifikasi _ tanggal"
    )


Kategori Kelas (CreateDateFieldsModel, AuditCreateModel):
    ormar _ config = base _ ormar _ config (tablename = "kategori")

    Id: int = ormar. Integer (primary _ key = Benar)
    Nama: str = ormar. String (max _ length = 50, unique = True, index = True)
    Kode: int = ormar. Integer ()

Dengan cara ini, jika perlu, Anda dapat mewarisi dari kelas yang dibuat dan kelas yang diperbarui, jika tidak, hanya satu kelas yang dapat diwarisi.