Ga naar inhoud

erfenis

Van de verschillende soorten ORM-modelovererving ondersteunt Ormar er momenteel twee:

  • mengen in
  • Concrete tafel overerving (ouder ingesteld op abstract = Waar)

type erfenis

Een korte samenvatting van de verschillende soorten erfenis:

  • Mixins\ [support] - subklasse ormar niet. Model, definieer gewoon velden die later op verschillende modellen moeten worden gebruikt (bijv. aangemaakte\ _ datum en bijgewerkte\ _ datum op elk model), alleen het daadwerkelijke model maakt de tabel, maar voeg velden toe in mixins
  • concrete tabelovererving\ [SUPPORTED] - betekent dat de ouder als abstract is gemarkeerd en dat elk kind zijn eigen tabel heeft met kolommen van de ouder en zijn eigen onderliggende kolommen, enigszins vergelijkbaar met Mixins, maar de ouder is ook een model
  • overerving van een enkele tabel\ [niet ondersteund] - betekent dat slechts één tabel wordt gemaakt waarbij de velden de combinatie / som zijn van het bovenliggende model en alle onderliggende modellen, maar het onderliggende model gebruikt alleen een subset van de kolommen in de database (alle bovenliggende modellen en hun eigen kolommen, andere onderliggende modellen overslaan) (van)
  • multi / join table inheritance\ [niet ondersteund] - betekent dat een deel van de kolom wordt opgeslagen op het bovenliggende model en een deel wordt opgeslagen op het onderliggende model, ze zijn met elkaar verbonden via een één-op-één relatie en de twee modellen worden onmiddellijk op de achtergrond bediend
  • Het proxymodel\ [ondersteunt geen] - betekent dat alleen de ouder een daadwerkelijke tabel heeft en dat het kind alleen methoden toevoegt, instellingen wijzigt, enz.

mengen in

Om Mixins te gebruiken, definieert u eenvoudig een klasse die niet van ormar erft. Model, maar definieert ormar. Velden als een klassevariabele.

 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
basis _ ormar _ config = ormar. OrmarConfig (
    Database = databanken. Database (DATABASE _ URL),
    Metadata = sqlalchemie. MetaData (),
    Engine = sqlalchemy.create _ engine (DATABASE _ URL);
)


# een mixin definieert de velden, maar is een normale python-klasse
Klasse AuditMixin:
    aangemaakt door: str = ormar. String (max _ length = 100)
    bijgewerkt _ door: str = ormar. String (max _ length = 100, default = "Sam")


Klasse DatumFieldsMixins:
    aangemaakte _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)
    bijgewerkt _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)


# a modellen kunnen erven van een of meer mengsels
Klasse categorieën (ormar. Model, DateFieldsMixins, AuditMixin):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50, uniek = Waar, index = Waar)
    Code: int = ormar. Geheel getal ()

!!!Merk op dat Mixin geen model is, dus je moet nog steeds van ormar erven. Modelleer en definieer het ormar\ _ config-veld in het uiteindelijke model.

De bovenstaande categorieklasse heeft vier extra velden: aangemaakt\ _ datum, bijgewerkt\ _ datum, aangemaakt\ _ door en bijgewerkt\ _ door.

Er wordt slechts één tabel gemaakt voor de modelcategorie, waarbij het veld Categorieklasse wordt gecombineerd met alle Mixins-velden.

Houd er rekening mee dat Mixin in de klassenaam optioneel is, maar het is een goede Python-oefening.

betonnen tafel overerving

Conceptueel lijkt de overerving van betonnen tafels erg op Mixins, maar met de eigenlijke ormar. Modellen als basisklasse.

!!!-waarschuwing Merk op dat de basisklasse Abstract = True heeft ingesteld in het ormar\ _ config-object, dat ModelDefinitionError gooit als u probeert over te nemen van een niet-abstracte opmaakklasse.

Aangezien dit abstracte model nooit wordt geïnitialiseerd, kunt u de metagegevens en database overslaan in de ormar\ _ config-definitie.

Maar als u het opgeeft, wordt het overgeërfd, zodat u geen metadata en database hoeft op te geven in de uiteindelijke / concrete klasse

Houd er rekening mee dat u het indien nodig altijd kunt overschrijven in een kind / concrete klas.

Bovendien moet ten minste één klasse in de overervingsketen de database en metagegevens verstrekken, anders wordt er een fout opgetreden.

 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
# merk op dat basisklassen abstract = Waar hebben
# aangezien dit model nooit geïnitialiseerd zal worden kun je metadata en databases overslaan
Klasse AuditModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    aangemaakt door: str = ormar. String (max _ length = 100)
    bijgewerkt _ door: str = ormar. String (max _ length = 100, default = "Sam")


# maar als je het verstrekt, wordt het geërfd - DRY (Don 't Repeat Yourself) in actie
Class DateFieldsModel (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie (
        Abstract = Waar,
        metagegevens = metagegevens;
        Databank = db,
    )

    aangemaakte _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)
    bijgewerkt _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)


# op die manier hoef je geen metadata en databases in concrete klassen aan te
Klasse Categorie (DatumFieldsModel, AuditModel):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50, uniek = Waar, index = Waar)
    Code: int = ormar. Geheel getal ()

De lijst met overgeërfde opties / instellingen is als volgt: metagegevens, database en beperkingen.

Natuurlijk worden daarnaast alle velden in de basisklasse gecombineerd en gemaakt in de betonnen tafels van het uiteindelijke model.

!!!Houd er rekening mee dat u abstarct = False niet hoeft op te geven in de laatste klasse - dit is de standaardinstelling die niet is overgenomen.

Velden in subklassen opnieuw definiëren

Houd er rekening mee dat u eerder gemaakte velden opnieuw kunt definiëren, net als de normale overerving van de Python-klasse.

Elke keer dat u een veld met dezelfde naam en een nieuwe definitie definieert, vervangt het het eerder gedefinieerde veld volledig.

 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
# basisklasse
Class DateFieldsModel (ormar. Model):
    ormar _ config = OrmarConfig (
        Abstract = Waar,
        metagegevens = metagegevens;
        Databank = db,
        # Merk op dat UniqueColumns sqlalchemy db-kolomnamen nodig heeft, niet de ormar-namen
        Beperkingen = [ormar. UniqueColumns ("aanmaakdatum", "wijzigingsdatum")]
    )

    aangemaakte _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, naam = "aanmaakdatum"
    )
    bijgewerkt _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, name = "modification _ date"
    )


Klasse opnieuw gedefinieerd veld (DateFieldsModel):
    ormar _ config = OrmarConfig (
        Tablename = "herdefinieert",
        metagegevens = metagegevens;
        Databank = db,
    )

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    # hier wordt de aangemaakte _ datum vervangen door het veld String
    aangemaakte _ datum: str = ormar. String (max _ length = 200, name = "creatie _ date")


# u kunt controleren of het uiteindelijke veld correct is gedeclareerd en aangemaakt
change _ field = RedefinedField.ormar _ config model _ fields ["aangemaakte _ datum"]
Beweren veranderd _ veld standaard is Geen
Veranderd _ veld alias = = "aanmaakdatum"
Bevestig elke (x.name = = "creatie _ date" voor x in RedefinedField.ormar _ config table.columns)
Beweren isinstantie (
    Opnieuw gedefinieerd veld ormar _ config table.columns ["creatie _ datum"] .type,
    Sqlalchemy.sql.sqltypes. tekenreeks,
)

!!!waarschuwt dat als u UniqueColumns-beperkingen declareert met kolomnamen, het uiteindelijke model kolommen met dezelfde naam moet declareren. Anders wordt ModelDefinitionError verhoogd.

1
2
3
4
5
6
Dus in het bovenstaande voorbeeld als u `name` niet verstrekt voor `created_date` in het `RedefinedField`-model
Ormar zou klagen.

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

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

erfenis relatie

U kunt relaties verklaren bij elke stap van overerving, of het nu in een ouderklas of een kinderklas is.

Wanneer u een relatie definieert op het niveau van het onderliggende model, heeft dit voorrang op de relatie die is gedefinieerd in het bovenliggende model (als dezelfde veldnaam wordt gebruikt), of als u een nieuwe relatie definieert, is deze alleen toegankelijk voor dat onderliggende model.

Bij het erven van relaties moet u altijd letten op de gerelateerde\ _ name-parameter, die uniek moet zijn in het relevante model wanneer u meerdere subklassen definieert die dezelfde relatie erven.

Als u geen gerelateerd\ _ name-argument opgeeft, zal ormar het voor u berekenen. Dit geldt voor overerving, aangezien alle submodellen verschillende klassenamen moeten hebben, die worden gebruikt om de standaard gerelateerde\ _ naam (class.name () + 's ') te berekenen.

Als u echter een gerelateerde\ _ naam opgeeft, kan de naam niet voor alle submodellen worden hergebruikt omdat ze elkaar aan de gerelateerde modelzijde overschrijven.

Daarom heb je twee opties:

  • Herdefinieer relationele velden in submodellen en geef handmatig verschillende gerelateerde\ _ naamparameters op
  • laat ormar afhandelen - > auto-aanpassen gerelateerde\ _ naam als: originele gerelateerde_naam + "_" + submodel tabelnaam

Dit klinkt misschien ingewikkeld, maar laten we eens kijken naar het volgende voorbeeld:

buitenlandse sleutel relatie

 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
# normaal model gebruikt in relatie
Klasse Persoon (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)


# oudermodel - moet abstract zijn
Klasse Auto (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50)
    Eigenaar: Persoon = ormar. ForeignKey (Persoon)
    # merk op dat we opnieuw verwijzen naar het persoonsmodel, dus we**moeten**gerelateerde _ naam opgeven
    mede-eigenaar: Persoon = ormar. ForeignKey (Persoon, gerelateerde _ naam = "coowned")
    aangemaakte _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)


Klasse Vrachtwagen (Auto):
    ormar _ config = basis _ ormar _ config kopie ()

    max _ capaciteit: int = ormar. Geheel getal ()


Klasse Bus (Auto):
    ormar _ config = basis _ ormar _ config (tabelnaam = "bussen")

    max _ personen: int = ormar. Geheel ()

Wanneer u nu de velden op het model Persoon controleert, krijgt u:

1
2
3
4
5
6
7
8
9
Persoon ormar _ config model _ velden
"""
{'Id':<class 'ormar.fields.model_fields.Integer'>,
'Naam':<class 'ormar.fields.model_fields.String'>,
'Vrachtwagens':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ trucks':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Buss':<class 'ormar.fields.foreign_key.ForeignKey'>,
coowned _ bussen ':<class 'ormar.fields.foreign_key.ForeignKey'>}
"""

Merk op hoe u eigenaar bent van de vrachtwagen- en busvelden, die leiden naar de vrachtwagen- en buscategorie die deze persoon bezit. Er is geen gerelateerde\ _ naamparameter, dus de standaardnaam wordt gebruikt.

Auto 's die mede-eigendom zijn, moeten worden gerefereerd door coowned\ _ trucks en coowned\ _ bussen. Ormar voegt de achtervoegsels\ _ trucks en\ _ bussen toe die zijn overgenomen uit de submodel-tabelnamen.

Het ziet er goed uit, maar de standaardnaam van de eigen vrachtwagen is OK (vrachtwagen), maar de bus is lelijk, dus hoe veranderen we deze?

De oplossing is heel eenvoudig: herdefinieer gewoon de velden in de Bus-klasse en geef verschillende gerelateerde\ _ naamparameters op.

1
2
3
4
5
6
7
De rest van bovenstaand voorbeeld blijft hetzelfde
Klasse Bus (Auto):
    ormar _ config = basis _ ormar _ config (tabelnaam = "bussen")

    # nieuw veld dat de gerelateerde _ naam verandert
    Eigenaar: Persoon = ormar. ForeignKey (Persoon, gerelateerde _ naam = "bussen")
    max _ personen: int = ormar. Geheel ()

De kolom ziet er nu veel beter uit.

1
2
3
4
5
6
7
8
9
Persoon ormar _ config model _ velden
"""
{'Id':<class 'ormar.fields.model_fields.Integer'>,
'Naam':<class 'ormar.fields.model_fields.String'>,
'Vrachtwagens':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ trucks':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Bussen':<class 'ormar.fields.foreign_key.ForeignKey'>,
coowned _ bussen ':<class 'ormar.fields.foreign_key.ForeignKey'>}
"""

!!!Merk op dat u ook een gerelateerde\ _ naam kunt opgeven voor het eigenaarveld, dat het juiste achtervoegsel toevoegt.

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

En modelvelden voor auto 's die eigendom zijn van een persoon zouden `owned_trucks` en `owned_buses` worden.

veel-op-veel relatie

Evenzo kunt u erven van een model dat een ManyToMany-relatie verklaart, maar met één substantieel verschil: het Through-model.

Aangezien het Through-model andere velden kan bevatten en nu slechts twee tabellen (van en naar één tabel) met elkaar verbindt, moet elk kind dat een M2M-relationeel veld erft, een apart Through-model hebben.

Natuurlijk kunt u relaties in elk submodel overschrijven, maar dat vereist extra code en vernietigt de betekenis van overerving als geheel. Ormar zal dit voor u afhandelen als u akkoord gaat met de standaard naamgevingsconventie, en u kunt die conventie altijd handmatig overschrijven in submodellen indien nodig.

Laten we nogmaals een voorbeeld bekijken om het concept gemakkelijker te begrijpen.

We zullen het vorige hierboven beschreven voorbeeld wijzigen om de m2m-relatie van mede-eigenaren te gebruiken.

 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
# persoon blijft hetzelfde als hierboven
Klasse Persoon (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)

# nieuw door model tussen Persoon en Car2
Klasse PersonenAuto (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "auto 's _ x _ personen")

# merk op hoe mede-eigenaren nu ManyToMany-relatie zijn
Klasse Car2 (ormatisch model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50)
    # let op de gerelateerde _ naam - moet uniek zijn voor de hele persoon
    # modelleren, ongeacht hoeveel verschillende modellen leidt tot Persoon
    Eigenaar: Persoon = ormar. ForeignKey (Persoon, gerelateerde _ naam = "eigendom")
    mede-eigenaren: Lijst [Persoon] = ormar. ManyToMany (
        Persoon, via = PersonsCar, gerelateerde _ naam = "coowned"
    )
    aangemaakte _ datum: datetime.datetime = ormar. DateTime (standaard = datetime.datetime.now)


# child-modellen definiëren alleen aanvullende velden
Klasse Truck2 (Car2):
    ormar _ config = basis _ ormar _ config (tabelnaam = "trucks2")

    max _ capaciteit: int = ormar. Geheel getal ()


Klasse Bus2 (Car2):
    ormar _ config = basis _ ormar _ config (tabelnaam = "buses2")

    max _ personen: int = ormar. Geheel ()

Ormar wijzigt automatisch de gerelateerde\ _ naam van een veld om de tabelnaam van het submodel op te nemen. De standaardnaam is de originele gerelateerde_-naam + '_' + subtabelnaam.

Dus voor de Truck2-klasse wordt de gedefinieerde relatie owner: Person = ormar.ForeignKey(Person, related_name="owned") eigendom\ _ trucks2

U kunt de naam verifiëren door de lijst met velden in het persoonsmodel te controleren.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Persoon ormar _ config model _ velden
{
# let op hoe alle relatievelden uniek moeten zijn op Persoon
# ongeacht of automatisch gegenereerd of handmatig overschreven
'ID':<class 'ormar.fields.model_fields.Integer'>,
'Naam':<class 'ormar.fields.model_fields.String'>,
# Merk op dat we op eerdere voorbeelden hebben uitgebreid, zodat alle 'oude' velden hier zijn
'Vrachtwagens':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ trucks':<class 'ormar.fields.foreign_key.ForeignKey'>,
'Bussen':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ bussen':<class 'ormar.fields.foreign_key.ForeignKey'>,
# nieuw gedefinieerde gerelateerde velden
eigendom _ trucks2 ':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ trucks2':<class 'abc.ManyToMany'>,
eigendom _ buses2 ':<class 'ormar.fields.foreign_key.ForeignKey'>,
'coowned _ buses2': <class 'abc.ManyToMany'>
}

Maar dat is niet alles. Het is de interne structuur van ormar, maar het beïnvloedt de gegevensstructuur in de database, dus laten we het pass-through-model voor Bus2- en Truck2-modellen bekijken.

1
2
3
4
5
6
7
8
9
Bus2.ormar _ config model _ fields ['mede-eigenaren'] .door
<class 'abc.PersonsCarBus2'>
Bus2. ormar _ config model _ fields ['mede-eigenaren']. ormar _ config. tabelnaam
'auto 's _ x _ personen _ bussen2'

Truck2. ormar _ config model _ fields ['mede _ eigenaren']. door
<class 'abc.PersonsCarTruck2'>
Truck2. ormar _ config model _ fields ['mede-eigenaren']. ormar _ config tabelnaam
'auto 's _ x _ personen _ vrachtwagen2'

Zoals u hierboven kunt zien, kloont Ormar het Through-model voor elke subklasse, voegt de naam van de subklasse aan het einde toe en verandert de tabelnaam van het gekloonde veld om de tabelnaam van het kind te gebruiken.

Houd er rekening mee dat niet alleen het originele model niet wordt gebruikt, maar dat de tabellen voor dat model ook uit de metadata worden verwijderd.

1
2
3
Bus2.ormar _ config metado.tables.keys () [bewerken]
dict _ keys (['test _ date _ models', 'categorieën', 'onderwerpen', 'personen', 'vrachtwagens', 'bussen',
           cars _ x _ personen _ trucks2 ',' trucks2 ',' cars _ x _ personen _ buses2 ',' buses2 '])

Houd er daarom rekening mee dat als u onderweg overerving introduceert en het model omzet in een abstract oudermodel, u mogelijk gegevens in de tabel verliest als u niet oppast.

!!!Opmerking Merk op dat de originele tabelnaam en modelnaam van het Through-model nooit worden gebruikt. Er worden alleen gekloonde modeltabellen gemaakt en gebruikt.

!!!Waarschuwing: merk op dat elke subklasse van het model dat de ManyToMany-relatie definieert, een nieuw Through-model genereert, wat ook een nieuwe database en tabel betekent.

1
2
Dat betekent dat elke keer dat u een Child-model definieert, u handmatig moet maken
De tabel in de database of voer een migratie uit (met alembic).

Ouderveld uitsluiten

Met Ormar kunt u bepaalde velden van het bovenliggende model overslaan in een overgeërfd model.

!!!Merk op dat hetzelfde gedrag kan worden bereikt door het model op te splitsen in meer abstracte modellen en mixins - dit is de voorkeursbenadering onder normale omstandigheden.

Als u bepaalde velden in een submodel wilt overslaan, geeft u een lijst van alle velden die u wilt overslaan model.ormar_config.exclude_parent_fields De parameters zijn als volgt:

 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
basis _ ormar _ config = OrmarConfig (
    Metadata = zoals MetaData (),
    Database = databanken. Database (DATABASE _ URL),
)


Klasse AuditModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    aangemaakt door: str = ormar. String (max _ length = 100)
    bijgewerkt _ door: str = ormar. String (max _ length = 100, default = "Sam")


Class DateFieldsModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    aangemaakte _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, naam = "aanmaakdatum"
    )
    bijgewerkt _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, name = "modification _ date"
    )


Klasse Categorie (DatumFieldsModel, AuditModel):
    ormar _ config = basis _ ormar _ config kopie (
        Tablename = "categorieën",
        # velden instellen die overgeslagen moeten worden
        uitsluiten _ ouder _ velden = ["bijgewerkt _ door", "bijgewerkt _ datum"],
    )

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50, uniek = Waar, index = Waar)
    Code: int = ormar. Geheel getal ()

# Merk op dat nu de bijgewerkte velden in Categorieën zijn verdwenen in alle plaatsen - > ormar velden, pydantische velden en sqlachemy tabel kolommen
# dus de volledige lijst van beschikbare velden in Categorie is: ["aangemaakt _ door", "aangemaakt _ datum", "id", "naam", "code"]

Houd er rekening mee dat u alleen de veldnaam hoeft op te geven, die het bovenliggende veld uitsluit, ongeacht uit welk bovenliggend model het veld afkomstig is.

!!!Merk op dat als u een veld in een submodel wilt overschrijven, u dit niet hoeft uit te sluiten, maar alleen de veldverklaring in het submodel met dezelfde veldnaam overschrijft.

Waarschuwing: Dit gedrag kan controleurs van het type mypy en statisch verwarren, maar toegang tot niet-bestaande velden mislukt tijdens runtime. Dit is de reden waarom het splitsen van de basisklasse de voorkeur heeft.

Hetzelfde effect kan worden bereikt door de basisklasse te splitsen, bijvoorbeeld:

 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
basis _ ormar _ config = OrmarConfig (
    Metadata = zoals MetaData (),
    Database = databanken. Database (DATABASE _ URL),
)


Klasse AuditCreateModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    aangemaakt door: str = ormar. String (max _ length = 100)


Klasse AuditUpdateModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

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

Klasse CreateDateFieldsModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    aangemaakte _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, naam = "aanmaakdatum"
    )

Klasse UpdateDateFieldsModel (ormar. Model):
    ormar _ config = basis _ ormar _ config (abstract = Waar)

    bijgewerkt _ datum: datetime.datetime = ormar. DateTime (
        Standaard = datetime.datetime.now, name = "modification _ date"
    )


Klasse Categorie (CreateDateFieldsModel, AuditCreateModel):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 50, uniek = Waar, index = Waar)
    Code: int = ormar. Geheel getal ()

Op deze manier kunt u, indien nodig, overerven van de gemaakte klasse en de bijgewerkte klasse, anders kan slechts één van de klassen worden overgeërfd.