Zum Inhalt

Das Erbe

Unter den verschiedenen Arten der ORM-Modell - Vererbung unterstützt ormar derzeit zwei davon :

  • einmischen ;
  • Spezifische Tabellenvererbung (parent auf abstract = true gesetzt)

Arten von Erbschaft

Eine kurze Zusammenfassung der verschiedenen Arten von Vererbung :

  • Mixins \ [ unterstützt \ ] - Unterklasse ormar . Model nicht , definieren Sie einfach die Felder , die später auf verschiedenen Modellen verwendet werden (z . B . created \ _ date und updated \ _ date auf jedem Modell) , erstellen Sie nur die Tabelle mit dem tatsächlichen Modell , fügen Sie aber die Felder in den Mixins hinzu
  • spezifische Tabellenvererbung \ [ SUPPORTED \ ] - bedeutet , dass die Elternebene als abstrakt markiert ist , wobei jedes Kind eine eigene Tabelle hat , die Spalten von den Elternebenen und eigene untergeordnete Spalten enthält , ähnlich wie Mixins , aber das Elternteil ist auch ein Modell .
  • Single-Table - Vererbung bedeutet , dass nur eine Tabelle erstellt wird , in der die Felder eine Kombination/Summe aus dem übergeordneten Modell und allen untergeordneten Modellen sind , aber das Untermodell nur eine Teilmenge der Spalten in der Datenbank verwendet (alle übergeordneten Modelle und eigenen Spalten , überspringen andere Untermodelle) .
  • Multi/Join Table Inheritance [ nicht unterstützt ] - bedeutet , dass ein Teil der Spalten auf dem übergeordneten Modell und ein Teil auf dem Untermodell gespeichert wird , sie werden durch eine Eins-zu - Eins-Beziehung miteinander verbunden und die beiden Modelle werden im Hintergrund betrieben sofort
  • Das Agentenmodell [ nicht unterstützt ] - bedeutet , dass nur die Elternebene über eine tatsächliche Tabelle verfügt und die Unterebene nur Methoden hinzufügt , Einstellungen ändert usw .

einmischen ;

Um Mixins zu verwenden , müssen Sie einfach eine Klasse definieren , die nicht von ormar . Model erbt , sondern ormar . Fields als Klassenvariable .

 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
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
    metadata = sqlalchemy . metadata () , oder
    . create _ engine = sqlalchemy (DATABASE _ URL) und
)


Ein Mixin definiert die Felder , ist aber eine normale Python-Klasse
Klasse AuditMixin :
    created _ by : str = ormar . String (max _ length = 100) erstellt von : str = ormar . String (max _ length = 100)
    updated _ by : str = ormar . String (max _ length = 100 , default = " Sam ")


Klasse DateFieldsMixins :
    created _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)
    updated _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)


Ein Modell kann von einem oder mehreren Mixern stammen
Kategorie (ormar. Model, DateFieldsMixins, AuditMixin):
    ormar_config = base_ormar_config. copy (tablename ="Kategorien")

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    String (max_length = 50, unique = true, index = true)(max_length = 50, unique = true, index = true)(max_length = 50, unique = true, index = true)
    Beispiel: int = ormar. Integer ()

!!!tip Beachten Sie, dass Mixin kein Modell ist, daher müssen Sie immer noch das ormar. Model erben und das Feld ormar_config im endgültigen Modell definieren.

Die Category Klasse oben hat vier zusätzliche Felder: created_date, updated_date, created_by und Updated_by.

Es wird nur eine Tabelle für das Modell Category (Kategorie) erstellt, in der das Feld Category mit allen Mixins-Feldern kombiniert wird.

Beachten Sie, dass das Mixin in den Klassennamen optional ist, dies ist jedoch eine gute Python-Praxis.

Tabelle vererbt.

Konzeptionell ist die spezifische Tabellenvererbung Mixins sehr ähnlich, verwendet jedoch die eigentlichen ormar. Models als Basisklasse.

!!!Warnung Beachten Sie, dass die Basisklasse Abstract = True im ormar_config-Objekt setzt und ein ModelDefinitionError ausgelöst wird, wenn Sie versuchen, von einer nicht abstrakten Markup-Klasse zu erben.

Da dieses abstrakte Modell nie initialisiert wird, können Sie die Metadaten und die Datenbank in der ormar_config-Definition überspringen.

Aber wenn Sie es bereitstellen-es wird vererbt, so dass Sie nicht Metadaten und Datenbanken in der endgültigen/spezifischen Klasse angeben müssen

Beachten Sie, dass Sie es bei Bedarf immer in einer Kind-/spezifischen Klasse überschreiben können.

Noch wichtiger ist, dass mindestens eine Klasse in der Vererbungskette eine Datenbank und Metadaten bereitstellen muss-sonst wird ein Fehler ausgelöst.

 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
#Hinweis, dass die Basis Klassen haben abstrakt = true
Dieses Modell wird nie initialisiert werden, da Sie Skip-Metadaten und-Datenbanken verwenden können
Klasse AuditModel (ormar. Model):
    ormar_config = base_ormar_config. copy (abstract = true) Bearbeiten

    created_by: str = ormar. String (max_length = 100) erstellt von: string = ormar. String (max_length = 100)
    updated_by: str = ormar. String (max_length = 100, default ="Sam")


DRY (Don't repeat yourself) in action-aber wenn Sie es zulassen, wird es inherited sein
Klasse DateFieldsModel (ormar. Modell):
    Die Datei Datei Datei Datei: Config_Config_Config (
        abstrakt = wahr ,
        Metathek = Metathek ,
        Datenbank = db
    )

    created _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)
    updated _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)


# So können Sie nicht Metadaten und Datenbanken in Concrete-Klassen bereitstellen
Klasse (DateFieldsModel , AuditModel) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    String (max _ length = 50 , unique = true , index = true) (max _ length = 50 , unique = true , index = true) (max _ length = 50 , unique = true , index = true)
    Beispiel : int = ormar . Integer ()

Die Liste vererbter Optionen/Einstellungen ist wie folgt : Metadaten , Datenbanken und Einschränkungen .

Darüber hinaus werden natürlich alle Felder in der Basisklasse in einer spezifischen Tabelle des endgültigen Modells kombiniert und erstellt .

!!!tip Beachten Sie , dass Sie in der endgültigen Klasse nicht unbedingt abstarct = False angeben müssen - dies ist die Standardeinstellung , die nicht vererbt wird .

Neudefinition der Wörter in der Unterkategorie

Beachten Sie , dass Sie zuvor erstellte Felder wie eine normale Python-Klassenvererbung neu definieren können .

Jedes Mal , wenn Sie ein Feld mit demselben Namen und einer neuen Definition definieren , wird das zuvor definierte Feld vollständig ersetzt .

 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
# Klassenbasis
Klasse DateFieldsModel (ormar . Modell) :
    Die Datei " Config " (
        abstrakt = wahr ,
        Metathek = Metathek ,
        Datenbank = DB
        # Hinweis , dass UniqueColumns sqlalchemy db columns names nicht die Ormones brauchen
        constraints = [ ormar . UniqueColumns (" creation _ date " , " modification _ date ") ] [ ormar . UniqueColumns (" creation _ date " , " modification _ date ") ] (" Änderung _ Datum ")
    )

    Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " creation _ date " (erstellt)
    )
    Dateiname : Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " Änderungsdatum "
    )


Klasse RedefinedField (DateFieldsModel) :
    Die Datei " Config " (
        tabellenname = " Neudefinition "
        Metathek = Metathek ,
        Datenbank = db
    )

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    # Hier wird das created _ date durch das String Feld ersetzt
    created _ date : str = ormar . String (max _ length = 200 , name = " creation _ date ") Bearbeiten


Sie können bestätigen , dass das letzte Feld korrekt deklariert und geschaffen wurde .
changed _ field = RedefinedField . ormar _ config . model _ fields [ " created _ date " ] [ Bearbeiten ]
assert changed _ field . default ist None
assert changed _ field . alias = = " creation _ date " (Eingabedaten ändern)
assert any (x.name = = = " creation _ date " für x in RedefinedField . ormar _ config . table . columns)
Die Erblindung (
    RedefinedField . ormar _ config . table . columns [ " creation _ date " ] . type , (Zeichenfolge)
    sqlchemy . sqltypes . string , siehe auch
)

!!!Warnung Wenn Sie eine UniqueColumns-Einschränkung mit Spaltennamen deklarieren , muss das endgültige Modell eine Spalte mit demselben Namen deklarieren , andernfalls wird ein ModelDefinitionError ausgelöst .

1
2
3
4
5
6
So in Beispiel above if you do not provided `name` for `created_date` in `RedefinedField` model
Orban wird sich beschweren .

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

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

Erbschaftsbeziehung

Sie können Beziehungen in jedem Schritt der Vererbung deklarieren , ob in der übergeordneten oder der untergeordneten Klasse .

Wenn Sie eine Beziehung auf der Ebene des Untermodells definieren , überschreibt sie die Beziehung , die im übergeordneten Modell definiert ist (wenn Sie denselben Feldnamen verwenden) , oder wenn Sie eine neue Beziehung definieren , ist sie nur für dieses Untermodell zugänglich .

Beim Vererben von Beziehungen müssen Sie immer auf den Parameter related \ _ name achten , der im verknüpften Modell eindeutig sein muss , wenn Sie mehrere Unterklassen definieren , die dieselbe Beziehung erben .

Wenn Sie den Parameter related \ _ name nicht angeben , berechnet ormar dies für die Vererbung , da alle Untermodelle unterschiedliche Klassennamen haben müssen , die zum Berechnen des Standard-related \ _ name (class . name . lower () + 's') verwendet werden .

Wenn Sie jedoch related \ _ name angeben , kann dieser Name nicht in allen Untermodellen wiederverwendet werden , da sie sich gegenseitig auf der Modellseite überschreiben .

Sie haben also zwei Optionen :

  • Definieren Sie das relationale Feld im Untermodell neu und geben Sie manuell verschiedene related \ _ name-Parameter ein .
  • lässt Ormar behandeln - > Automatisch angepasste related \ _ name wie folgt : Original related _name + " _" + Name der Untermodelltabelle

Das mag kompliziert klingen , aber schauen wir uns die folgenden Beispiele an :

Außenbeziehungen

 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
Normales Modell in Beziehung setzen
Klasse Person (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy () (= Grundeinheit von ormar _ config . copy)

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 100)


Parent-Modell - Wir müssen abstrakt sein
Klasse Auto (ormar .
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 50) [ Bearbeiten ]
    Eigentümer : Person = ormar . ForeignKey (Person)
    # Hinweis , dass wir wieder auf das Modell der Person verweisen , so dass wir**auf**bezogen haben
    co _ owner : Person = ormar . ForeignKey (Person , related _ name = " coowned ")
    created _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)


Fahrzeug (Klasse) :
    ormar _ config = base _ ormar _ config . copy () (= Grundeinheit von ormar _ config . copy)

    max_capacity: int = ormar. Integer ()(() ist eine


Klasse Bus (Fahrzeug):
    ormar_config = base_ormar_config. copy (tablename ="Buses")

    max_persons: int = ormar. Integer ()()() oder

Wenn Sie jetzt die Felder auf dem Person-Modell untersuchen, erhalten Sie:

1
2
3
4
5
6
7
8
9
Person. ormar_config. model_fields (Person. ormar_config. model_fields)
"""
'id':<class 'ormar.fields.model_fields.Integer'>, oder
'Name':<class 'ormar.fields.model_fields.String'>,
von<class 'ormar.fields.foreign_key.ForeignKey'>,
coowned_trucksBearbeiten <class 'ormar.fields.foreign_key.ForeignKey'>, 
'buss':<class 'ormar.fields.foreign_key.ForeignKey'>, oder
coowned_buses':<class 'ormar.fields.foreign_key.ForeignKey'>} Bearbeiten
"""

Beachten Sie, wie Sie die Felder für Lkw und Busse haben, die dazu führen, dass für die Kategorie Lkw und Busse, deren Eigentümer diese Person ist, kein related_name-Parameter vorhanden ist, und daher der Standardname verwendet wird.

Auch Miteigentümer-Autos müssen mit coowned_trucks und coowned_buses referenziert werden, indem Ormar die Endungen_trucks und_buses anfügt, die von den Namen der Submodelltabelle abgeleitet werden.

Sieht gut aus, aber der Standardname für den eigenen Truck ist gut (LKW), aber der Bus ist hässlich, also wie können wir ihn ändern?

Die Lösung ist einfach-definieren Sie einfach die Felder in der Bus-Klasse neu und geben Sie einen anderen related_name Parameter an.

1
2
3
4
5
6
7
Rest of the above example remains the same Zurück zum selben
Bus (Fahrzeug):
    ormar_config = base_ormar_config. copy (tablename ="Buses")

    #neues Feld, das den zugehörigen_Namen ändert
    Eigentümer: Person = ormar. ForeignKey (Person, related_name ="buses")
    max_persons: int = ormar. Integer ()()() oder

Die Säulen sehen jetzt besser aus.

1
2
3
4
5
6
7
8
9
Person. ormar_config. model_fields (Person. ormar_config. model_fields)
"""
obwohl obwohl:<class 'ormar.fields.model_fields.Integer'>,
'Name':<class 'ormar.fields.model_fields.String'>,
von<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned_trucks':<class 'ormar.fields.foreign_key.ForeignKey'>und
von<class 'ormar.fields.foreign_key.ForeignKey'>,
coowned_buses':<class 'ormar.fields.foreign_key.ForeignKey'>} und
"""

!!!Beachten Sie, dass Sie auch related_name für das Owner-Feld angeben können, wodurch das richtige Suffix hinzugefügt wird.

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

Und Modellfelder für Personen-eigene Autos könnten zu `owned_trucks` und `owned_buses` werden.

Mehr zu Beziehung.

In ähnlicher Weise können Sie von einem Modell erben, das eine ManyToMany-Beziehung deklariert, aber es gibt einen wesentlichen Unterschied-das Through-Modell.

Da das Through-Modell in der Lage wäre, zusätzliche Felder zu speichern, und jetzt nur zwei Tabellen verknüpft (von und zu einer), muss jedes Kind, das ein m2m-relationales Feld erbt, ein separates Through-Modell haben.

Natürlich können Sie die Beziehungen in jedem Untermodell überschreiben, aber dies erfordert zusätzlichen Code und untergräbt die Bedeutung der gesamten Vererbung Ormar kümmert sich um das Problem für Sie, wenn Sie der Standard-Namenskonvention zustimmen, und Sie können diese Konvention jederzeit manuell in einem Unterelement überschreiben, wenn Sie dies wünschen.

Schauen wir uns noch einmal die Beispiele an, um Konzepte leichter zu erfassen.

Wir werden das oben beschriebene Beispiel modifizieren, um die m2m-Beziehung von co_owners zu verwenden.

 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
Remain the same as above (Gleichgesinnte als Übermenschen)
Klasse Person (ormar. model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100)

Neue Modelle zwischen Person und Car2
Klasse Personenwagen (ormar. Modell):
    ormar_config = base_ormar_config. copy (tablename ="cars_x_persons")

Wie Co_Owners jetzt eine Beziehung haben
Klasse Car2 (ormar. Modell):
    ormar_config = base_ormar_config. copy (abstract = true) Bearbeiten

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name : str = ormar . String (max _ length = 50) [ Bearbeiten ]
    # name _ name - es ist notwendig , eine einzigartige Person zu sein
    Modell , ohne Frage , wie viele verschiedene Modelle führen , um eine Person
    Eigentümer : Person = ormar . ForeignKey (Person , related _ name = " owned ")
    Seite 1 -
        Person , through = PersonsCar , related _ name = " coowned " (Person , durch = Personenauto , related _ name = " coowned ")
    )
    created _ date : datetime . datetime = ormar . DateTime (default = Dateizeit)datetime.datetime.now)


Kindermodelle definieren nur zusätzliche Felder
Klasse Truck2 (Car2) Bearbeiten
    ormar _ config = base _ ormar _ config . copy (tablename = " trucks2 ") Bearbeiten

    max _ capacity : int = ormar . Integer () (() ist eine


Busclass 2 (Car2) kaufen
    ormar _ config = base _ ormar _ config . copy (tablename = " buses2 ") (siehe auch : ormar _ config = base _ ormar _ config . copy)

    max _ persons : int = ormar . Integer () () () oder

Ormar ändert automatisch related \ _ name eines Felds , um den Standardnamen des Untermodells als den ursprünglichen Tabellennamen related _name + ' _' + einzuschließen .

In der Truck2 - Klasse wird die Beziehung , die durch owner: Person = ormar.ForeignKey(Person, related_name="owned") definiert wird , zu owned_ trucks2 .

Sie können den Namen überprüfen , indem Sie die Liste der Felder überprüfen , die im Personenmodell vorhanden sind .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Person . ormar _ config . model _ fields (Person . ormar _ config . model _ fields)
{
Wie alle relation fields müssen einzigartig auf person sein .
Es ist regardless , wenn automatisch oder manuell überschrieben .
mit<class 'ormar.fields.model_fields.Integer'>,
' name ' :<class 'ormar.fields.model_fields.String'>,
Ein Beispiel : So viele " alte " Felder befinden sich hier
mit<class 'ormar.fields.foreign_key.ForeignKey'>,
coowned _ trucks':<class 'ormar.fields.foreign_key.ForeignKey'>, oder
mit "buses':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned_buses':<class 'ormar.fields.foreign_key.ForeignKey'>, oder
#neu definierte Felder
'owned_trucks2':<class 'ormar.fields.foreign_key.ForeignKey'>, oder
coowned_trucks2':<class 'abc.ManyToMany'>, oder
'owned_buses2':<class 'ormar.fields.foreign_key.ForeignKey'>, oder
coowned_buses2': oder <class 'abc.ManyToMany'>
}

Aber das ist noch nicht alles, es ist die interne Struktur von ormar, aber es wirkt sich auf die Datenstruktur in der Datenbank aus, also schauen wir uns das Passthrough-Modell von Bus2 und Truck2 an.

1
2
3
4
5
6
7
8
9
Bus2.ormar_config.model_fields Wintergarten 'co_owners']. durch
<class 'abc.PersonsCarBus2'>
Bus2.ormar_config.model_fields VINGITORIA 'co_owners']. through. ormar_config. tablename [Bearbeiten | Quelltext bearbeiten]
'cars_x_persons_buses2' und 'cars_x_persons_buses2'

Startseite » 260 Mitarbeiter bei Nokian Tyres von Freistellungen betroffen 260 Mitarbeiter bei Nokian Tyres von Freistellungen betroffen
<class 'abc.PersonsCarTruck2'>
Truck2.ormar_config.model_fields VARCHITIA 'co_owners']. through. ormar_config. tablename
cars_x_persons_trucks2 oder cars_x_persons_trucks3

Wie Sie oben sehen können, klont ormar das Through Modell für jede Unterklasse und fügt am Ende den Namen der Unterklasse hinzu, während der Tabellenname des Klonfeldes geändert wird, wobei der Tabellenname der Unterklasse verwendet wird.

Beachten Sie, dass nicht nur das Originalmodell nicht verwendet wird, sondern auch die Tabellen dieses Modells aus den Metadaten entfernt werden:

1
2
3
Bus2.ormar_config.metadata.tables.keys ()(oder neuer)
dict_keys (test_date_models','categories',' subjects','persons',' trucks','buses',[Einstellungen])
           'cars_x_persons_trucks2',' trucks2','cars_x_persons_buses2',' buses2'] und 'cars2'.

Beachten Sie daher, dass, wenn Sie Vererbung einführen und das Modell in ein abstraktes Elternmodell umwandeln, Sie möglicherweise Daten in der Tabelle verlieren, wenn Sie nicht aufpassen.

!!!Beachten Sie, dass der ursprüngliche Tabellenname und der Modellname eines Through Modells nie verwendet wurden, um nur geklonte Modelltabellen zu erstellen und zu verwenden.

!!!warnt, dass jede unterklasse des modells, das eine manytomany-beziehung definiert, ein neues through-modell generiert, was auch eine neue datenbanktabelle bedeutet.

1
2
Dies bedeutet, dass Sie jedes Mal ein Kindermodell definieren, das Sie für beide manuell erstellen müssen.
Die Tabelle in der Datenbank oder eine Migration (mit einem Algorithmus).

Vater Wort ausschließen

Ormar ermöglicht Ihnen das Überspringen bestimmter Felder aus dem übergeordneten Modell im geerbten Modell .

!!!Beachten Sie , dass das gleiche Verhalten erreicht werden kann , indem das Modell in abstraktere Modelle und Mixin aufgeteilt wird - was normalerweise der bevorzugte Weg ist .

Um einige Felder in einem Untermodell zu überspringen , listen Sie alle Felder auf , die Sie überspringen möchten model.ormar_config.exclude_parent_fields Parameter wie folgt :

 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
Die Datei ist in der Datei " _ (
    Metadata = sa . metadaten () , und
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
)


KlassenauditModel (ormar . model) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    created _ by : str = ormar . String (max _ length = 100) erstellt von : string = ormar . String (max _ length = 100)
    updated _ by : str = ormar . String (max _ length = 100 , default = " Sam ")


Klasse DateFieldsModel (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " creation _ date " (erstellt)
    )
    Dateiname : Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " Änderungsdatum "
    )


Klasse (DateFieldsModel , AuditModel) :
    Die Datei Datei Datei Datei : Config _ Config _ Config (
        tablename = " Kategorien " ,
        Stellen Sie Felder ein , die skipped sein sollten
        exclude _ parent _ fields = [ " updated _ by " , " updated _ date " ] und
    )

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    String (max _ length = 50 , unique = true , index = true) (max _ length = 50 , unique = true , index = true) (max _ length = 50 , unique = true , index = true)
    Beispiel : int = ormar . Integer ()

# Note that now the update fields in category are gone in all places - > Ormar fields , pydantische fields und sqlachemy table columns
So volle Liste der verfügbaren Felder in der Kategorie ist : [ " created _ by " , " created _ date " , " id " , " name " , " code " ]

Beachten Sie , dass Sie einfach einen Feldnamen angeben müssen , der das übergeordnete Feld ausschließt , unabhängig davon , aus welchem übergeordneten Modell das Feld stammt .

!!!Beachten Sie , dass Sie , wenn Sie ein Feld im Untermodell überschreiben möchten , es nicht ausschließen müssen , sondern einfach die Felddeklaration im Untermodell mit demselben Feldnamen überschreiben müssen .

Seien Sie gewarnt , dass dieses Verhalten den mypy - und den statischen Typprücker verwirren kann , aber der Zugriff auf nicht vorhandene Felder schlägt zur Laufzeit fehl , weshalb die Basisklasse bevorzugt aufgeteilt wird .

Der gleiche Effekt kann erreicht werden , indem man die Basisklasse aufteilt , zum Beispiel :

 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
Die Datei ist in der Datei " _ (
    Metadata = sa . metadaten () , und
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
)


Klasse AuditCreateModel (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    created _ by : str = ormar . String (max _ length = 100) erstellt von : string = ormar . String (max _ length = 100)


class AuditUpdateModel (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

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

CreateFieldDateFieldsModel (ormar . Model) (Beispiel) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " creation _ date " (erstellt)
    )

class UpdateDateFieldsModel (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy (abstract = true) Bearbeiten

    Dateiname : Dateiname : Dateiname : Dateiname (
        default = nichtdatetime.datetime.now, name = " Änderungsdatum "
    )


class Category (CreateDateFieldsModel , AuditCreateModel) : Klasse (CreateDateFieldsModel , AuditCreateModel)
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    String (max_length = 50, unique = true, index = true)(max_length = 50, unique = true, index = true)(max_length = 50, unique = true, index = true)
    Beispiel: int = ormar. Integer ()

Auf diese Weise können Sie bei Bedarf von Klassen erben, die erstellt und aktualisiert werden, oder Sie können nur von einer dieser Klassen erben.