Ga naar inhoud

model werkwijze

De belangrijkste interactie van de!!!-tip met de database wordt weergegeven door een QuerySet-object dat wordt weergegeven als Model.objects op elk model, vergelijkbaar met een django-orm.

1
Om meer te lezen over**quering, samenvoegen tabellen, exclusief velden etc. bezoek [queries][queries] section.**

Elk modelexemplaar heeft een set methoden om zichzelf op te slaan, bij te werken of te laden.

De beschikbare methoden zijn als volgt.

pedante methode

Merk op dat elke ormar. Model is ook een pydantic. BaseModel, dus alle pydantische methoden kunnen ook worden gebruikt op het model, met name de model\ _ dump () en model\ _ dump\ _ json () methoden, die ook uitsluitingen, insluitsels en andere parameters kunnen accepteren.

Bekijk de pydantische documentatie om meer te lezen

Model\ _ constructie ()

Model_construct is het oorspronkelijke equivalent van de__init_\ _ -methode die wordt gebruikt om een nieuwe instantie te construeren.

Het verschil is dat model\ _ construct validatie overslaat, dus je moet het gebruiken als je weet dat de gegevens correct en betrouwbaar zijn. Het voordeel van het gebruik van constructs is de snelheid van uitvoering als gevolg van het overslaan van validatie.

!!!Merk op dat, in tegenstelling tot de pydantic.model\ _ construct-methode, het ormar-equivalent ook geneste gerelateerde modellen aankan.

Waarschuwing, onthoud dat de constructor geen conversies, controles, etc. uitvoert omdat validatie wordt overgeslagen. Daarom is het uw verantwoordelijkheid om gegevens te verstrekken die geldig en bruikbaar zijn voor de database.

1
2
3
4
De enige twee dingen die construeren nog steeds presteert, zijn:

*  Een `default`-waarde opgeven voor het niet instellen van velden
*  Initialiseer geneste ormatiemodellen als u een woordenboek of een primaire sleutelwaarde doorgeeft

Modeldump ()

Model\ _ dump is een methode die is overgenomen van Pydantic, maar Ormar voegt zijn eigen parameters toe en heeft enkele nuances bij het gebruik van de standaardwaarden, dus het wordt hier voor de duidelijkheid vermeld.

Model\ _ dump exporteert gegevens van de modelboom naar het woordenboek.

Model\ _ dump parameter beschrijving:

Opnemen (of wijzigen)

include: Union[Set, Dict] = None

De set veldnamen of woordenboeken die in het geretourneerde woordenboek moet worden opgenomen.

Merk op dat pydantic een ongebruikelijk patroon heeft van het opnemen / uitsluiten van velden uit een lijst per index (net als het geneste model). Als u velden wilt uitsluiten van alle subitems, moet u de sleutel\ __all_\ _ doorgeven aan het woordenboek.

Je kunt geneste modellen niet uitsluiten in Sets in pydantic, maar wel in ormar (door een dubbele onderstrepingsteken toe te voegen aan de relationele naam, d.w.z. exclusief de categorienamen van boeken die je kunt gebruiken)exclude={"book__category__name"}).

Ormar ondersteunt geen indexuitsluiting / opname en accepteert een vereenvoudigde en gebruiksvriendelijkere notatie.

Bekijk de sectie Velden met uitleg en uitgebreide voorbeelden om te controleren hoe u velden, inclusief geneste velden, kunt opnemen / uitsluiten.

!!!Merk op dat u in ormar in feite geneste modellen in een verzameling kunt uitsluiten en u kunt uitsluiten van de hele modelboom als antwoord\ _ model\ _ exclude en respons\ _ model\ _ opnemen in fastapi!

Uitsluiten (of wijzigen)

exclude: Union[Set, Dict] = None

De verzameling of het woordenboek van veldnamen om uit te sluiten van het geretourneerde woordenboek.

Merk op dat pydantic een ongebruikelijk patroon heeft van het opnemen / uitsluiten van velden uit een lijst per index (net als het geneste model). Als u velden van alle subitems wilt uitsluiten, moet u de sleutel\ __all_\ _ doorgeven aan het woordenboek.

Je kunt geneste modellen niet uitsluiten in Sets in pydantic, maar wel in ormar (door een dubbele underscore toe te voegen aan de relationele naam, d.w.z. exclusief de categorienaam van het boek dat je gebruikt)exclude={"book__category__name"}).

Ormar ondersteunt geen indexuitsluiting / opname en accepteert een vereenvoudigde en gebruiksvriendelijkere notatie.

Bekijk de sectie Velden met uitleg en uitgebreide voorbeelden om te controleren hoe u velden, inclusief geneste velden, kunt opnemen / uitsluiten.

!!!Merk op dat u in ormar in feite geneste modellen in een verzameling kunt uitsluiten en u kunt uitsluiten van de hele modelboom als reactie\ _ model\ _ exclude en respons\ _ model\ _ opnemen in fastapi!

Uitsluiten\ _ Instellingen annuleren

Uitsluiten Niet ingesteld: Booleaans = Onwaar

Vlag geeft aan of velden die niet expliciet waren ingesteld toen het model werd gemaakt, moeten worden uitgesloten van het geretourneerde woordenboek.

!!!Waarschuwing, houd er rekening mee dat na het opslaan van gegevens in de database, elk veld zijn eigen waarde heeft - >, die door u kan worden verstrekt, een standaardwaarde of geen.

 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
Dat betekent dat wanneer u de gegevens uit de database laadt,**alle**-velden zijn ingesteld en dat deze vlag in feite niet meer werkt!


Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100, standaard = "Test")
    Zichtbaarheid: bool = ormar. Booleaans (standaard = Waar)


Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Prijs: float = ormar. Float (standaard = 9.99)
    Categorieën: Lijst [Categorie] = ormar. ManyToMany (Categorie)

Categorie = Categorie (naam = "Test 2")
Bevestig categorie model _ dump () = = {'id': None, 'items': [], 'name': 'Test 2',
                           'Zichtbaarheid': Waar}
Categorie bewerken. model _ dump (uitsluiten _ uitschakelen = Waar) = = {'items': [], 'name': 'Test 2'}

category.save ()
Categorie2 = afwachten Categorie.objects.get ()
Bevestig categorie2. model _ dump () = = {'id': 1, 'items': [], 'naam': 'Test 2',
                            'Zichtbaarheid': Waar}
# LET OP hoe na het laden vanuit db alle velden expliciet worden ingesteld
# aangezien dit is wat er gebeurt als je een model van db vult
Bevestig categorymodel _ dump (exclude _ unset = True) = = {'id': 1, 'items': [],
                                              'Naam': 'Test 2', 'zichtbaarheid': Waar}

Standaardwaarden uitsluiten

exclude_defaults: bool = False

De vlag die aangeeft dat deze gelijk is aan de standaardwaarde (al dan niet ingesteld), moet worden uitgesloten van het geretourneerde woordenboek

 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
Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100, standaard = "Test")
    Zichtbaarheid: bool = ormar. Booleaans (standaard = Waar)

Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Prijs: float = ormar. Float (standaard = 9.99)
    Categorieën: Lijst [Categorie] = ormar. ManyToMany (Categorie)

Categorie = Categorie ()
# Merk op dat Integer pk standaard autoincrement is, dus optioneel
Categorie bewerken. model _ dump () = = {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
Categorie bewerken. model _ dump (uitsluiten _ standaard = Waar) = = {'items': []}

# opslaan en herladen van de gegevens
category.save ()
Categorie2 = afwachten Categorie.objects.get ()

Categorie bewerken2. model _ dump () = = {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
Categorie bewerken2. model _ dump (uitsluiten _ standaard = Waar) = = {'id': 1, 'items': []}

Uitsluiten\ _ Geen

Uitsluiten\ _ Geen: Booleaans = Onwaar

Vlag geeft aan of velden gelijk aan Geen moeten worden uitgesloten van het geretourneerde woordenboek.

 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
Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. Tekenreeks (max _ length = 100, default = "Test", nullable = True)
    Zichtbaarheid: bool = ormar. Booleaans (standaard = Waar)


Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Prijs: float = ormar. Float (standaard = 9.99)
    Categorieën: Lijst [Categorie] = ormar. ManyToMany (Categorie)


Categorie = Categorie (naam = Geen)
Bevestig categorie model _ dump () = = {'id': Geen, 'items': [], 'naam': Geen,
                           'Zichtbaarheid': Waar}
# let op het id is nog niet ingesteld dus Geen en uitgesloten
Categorie bewerken. model _ dump (uitsluiten _ none = Waar) = = {'items': [], 'visibility': True}

category.save ()
Categorie2 = afwachten Categorie.objects.get ()
Bevestig categorie2. model _ dump () = = {'id': 1, 'items': [], 'naam': Geen,
                            'Zichtbaarheid': Waar}
Stel categorymodel _ dump (uitsluiten _ none = Waar) = = {'id': 1, 'items': [],
                                             'Zichtbaarheid': Waar}

Behalve\ _ primaire\ _ toetsen (alleen ormar)

exclude_primary_keys: bool = False

Als u de vlag op Waar instelt, worden alle primaire sleutelkolommen in de boom uitgesloten, inclusief geneste modellen.

1
2
3
4
5
6
7
8
9
Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

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

Item1 = Item (id = 1, naam = "Testitem")
Bevestig item1. model _ dump () = = {"id": 1, "name": "Test Item"}
Bevestig item1.model _ dump (uitsluiten _ primaire _ sleutels = Waar) = = {"name": "Test Item"}

Behalve\ _ tot en met\ _ modellen (alleen ormar)

exclude_through_models: bool = False

Pass-through-modellen worden automatisch toegevoegd voor elke veel-op-veel-relatie en ze bevatten aanvullende parameters op het gekoppelde model / de tabel.

Instelling behalve\ _ through\ _ models = True sluit alle passthrough-modellen uit, inclusief passthrough-modellen voor submodellen.

 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
Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

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


Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    Categorieën: Lijst [Categorie] = ormar. ManyToMany (Categorie)

# bomen die de modellen definiëren
item _ dict = {
            "Naam": "proef",
            "Categorieën": [{"name": "test cat"},{"name": "test cat2"}],
        }
# red de hele boom
Wacht op Item (* * item _ dict). opslaan _ gerelateerd (volg = Waar, opslaan _ alles = Waar)

# krijg de opgeslagen waarden
Item = await Item.objects.select _ gerelateerd ("categorieën") .get ()

# standaard zie je de doorlopende modellen (itemcategorie)
Bevestig item. model _ dump () = = {'id': 1, 'name': 'test',
                       'Categorieën': [
                           {'Id': 1, 'naam': 'testkat',
                            'ItemCategory':{'id': 1, 'category': None, 'item': None}},
                           {'Id': 2, 'naam': 'proefkat2',
                            'ItemCategorie':{'id': 2, 'category': None, 'item': None}}
                       ]}

# u kunt deze velden / modellen uitsluiten
Bevestig item. model _ dump (uitsluiten _ door _ modellen = Waar) = = {
                       'Id': 1, 'naam': 'proef',
                       'Categorieën': [
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

Modellen\ _ dump\ _ json ()

Model\ _ dump\ _ json () heeft exact dezelfde parameters als model\ _ dump (), dus controleer het bovenstaande.

Het eindresultaat is natuurlijk een string die wordt weergegeven door JSON, geen woordenboek.

Krijg\ _ pydantic ()

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

Met deze methode kunt u Pydantische modellen van Ormar-modellen genereren zonder dat u alle velden opnieuw hoeft in te voeren.

Houd er rekening mee dat als u geneste modellen heeft, deze de volledige Pydantic-modelboom voor u zal genereren! Maar op een manier die circulaire referentieproblemen voorkomt.

Bovendien kunt u uitsluitingen doorgeven en / of parameters opnemen om alleen de gewenste velden te behouden, ook in het geneste model.

Dit betekent dat u eenvoudig Pydantic-modellen kunt maken voor verzoeken en reacties in FastAPI.

!!! Opmerking Ga naar de sectie Velden van de documentatie om meer te lezen over mogelijke uitsluitingen / insluitsels en hoe u een uitsluitingswoordenboek of instellingen kunt bouwen

Het gegeven voorbeeld ormar model is als volgt:

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


Klasse Categorie (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "categorieën")

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


Klasse-item (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100, default = "test")
    Categorie: Optioneel [Categorie] = ormar. ForeignKey (Categorie, nullable = Waar)

U kunt met een simpele aanroep een Pydantisch model genereren.

1
PydanticCategory = Categorie. get _ pydantic (inclusief ={"id", "name"})

Dit genereert een model dat gelijk is aan het volgende:

1
2
3
Klasse Categorie (BaseModel):
    ID: Facultatief [int]
    Naam: Optioneel [str] = "test"

!!! Waarschuwing, het is geen goede gewoonte om meerdere klassen met dezelfde naam in een module te hebben, en het zal de fastapi-documentatie breken. Daarom voegt ormar willekeurige 3 hoofdletters toe aan klasnamen. In het bovenstaande voorbeeld betekent dit dat de klasse daadwerkelijk de naam Category\ _ XIP (BaseModel) krijgt.

Om geneste velden uit te sluiten of op te nemen, kunt u een woordenboek of dubbel onderstrepingsteken gebruiken.

1
2
3
# beide oproepen zijn gelijkwaardig
PydanticCategory = Categorie. get _ pydantic (inclusief ={"id", "items__id"})
PydanticCategory = Category. get _ pydantic (inclusief = {"id":..., "artikelen":{"id"}})

De resulterende structuur is als volgt:

1
2
3
4
5
6
Klasse Punt (BaseModel):
    ID: Facultatief [int]

Klasse Categorie (BaseModel):
    ID: Facultatief [int]
    Punten: Facultatief [Lijst [Item]]

Natuurlijk kun je ook een diep geneste structuur gebruiken, en Ormar zal zijn Pydantische equivalent voor je genereren (op een manier die lussen uitsluit).

Merk op dat het bovenstaande itemmodel geen verwijzing heeft naar categorie, ook al is de relatie in ormar bidirectioneel (en ormar. Item heeft categorievelden).

Waarschuwing: het resulterende Pydantic-model erft alle veldvalidators van het originele Ormar-model, inclusief de Ormar-selectievalidator en validators die zijn gedefinieerd met de Pydantic.validator-decorator.

1
Maar tegelijkertijd zullen alle root-validators die aanwezig zijn op `ormar`-modellen**NOT**worden gekopieerd naar het gegenereerde pydantische model.

Aangezien rootvalidators op alle velden kunnen werken en een gebruiker sommige velden kan uitsluiten tijdens het genereren van pydantische modellen, is het niet veilig om die validators te kopiëren. Indien nodig moet u ze opnieuw definiëren / handmatig kopiëren om pydantische modellen te genereren.

Laden ()

Standaard, wanneer u een tabel opvraagt zonder gerelateerde modellen vooraf op te halen, zal Ormar nog steeds uw gerelateerde modellen construeren, maar deze alleen vullen met pk-waarden. U kunt gerelateerde modellen laden door de load () -methode aan te roepen.

Load () kan ook worden gebruikt om het model uit de database te vernieuwen als het door een ander proces is gewijzigd.

1
2
3
4
5
6
7
Track = await Track.objects.get (naam = 'De Vogel')
track.album.pk # geeft malibu album pk terug (1)
track.album.name # geeft Geen terug

# u moet de gegevens eerst daadwerkelijk laden
In afwachting van track.album.load ()
track.album.name # geeft 'Malibus' terug

Alles laden ()

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

De methode werkt op dezelfde manier om te laden (), maar herhaalt ook alle relaties van het model dat de methode heeft aangeroepen en laadt ze opnieuw uit de database.

Standaard laadt de load\ _ all-methode alleen modellen die direct gerelateerd zijn (één stap verwijderd) aan het model dat de methode aanroept.

U kunt echter de parameter follow = True specificeren om door de geneste modellen te herhalen en ze allemaal in de relationele boom te laden.

Waarschuwing: om terugkerende updates met de instelling follow = True te voorkomen, houdt load\ _ all een set bezochte modellen bij en voert geen geneste belastingen uit op bezochte modellen.

1
2
3
4
5
6
Dus als u een type diamant of cirkelvormige relaties heeft, moet u de belastingen handmatig uitvoeren.

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

Methoden accepteren ook optionele uitsluitingsparameters, die precies werken zoals de Exclude Fields-methode in QuerySet. Hiermee kunt u velden verwijderen uit het gerelateerde model dat wordt vernieuwd of het hele gerelateerde model overslaan.

Methoden voeren een databasequery uit en zijn daarom efficiënter dan geneste aanroepen om () en alle () op gerelateerde modellen te laden.

!!!Tip Lees voor meer informatie over uitsluitingen, behalve\ _ velden

!!!Waarschuwing Alle relaties worden gewist bij load\ _ all (), dus als u sommige geneste modellen uitsluit, zijn ze leeg na het gesprek.

Opslaan ()

Opslaan () - > Zelf

U kunt de methode QuerySet.create () gebruiken of het model initialiseren als een normaal Pydantisch model en vervolgens de methode save () aanroepen om een nieuw model te maken.

Opslaan () kan ook worden gebruikt om wijzigingen in een model op te slaan, op voorwaarde dat de primaire sleutel niet is ingesteld of het model niet in de database bestaat.

De save () methode controleert niet of het model in de database bestaat, dus als dit wel het geval is, ontvangt u een integriteitsfout van de geselecteerde database-backend als u probeert het model op te slaan met een bestaande primaire sleutel.

1
2
3
4
5
Track = Track (naam = 'De Vogel')
Wacht track.save () # blijft het model in de database

Track = await Track.objects.get (naam = 'De Vogel')
Wacht track.save () # zal een integriteitsfout veroorzaken als pk wordt ingevuld

Bijwerken ()

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

U kunt het model bijwerken met de methode QuerySet.update () of door de modeleigenschappen (velden) bij te werken en de update () -methode aan te roepen.

Als u probeert het model bij te werken zonder de primaire sleutel in te stellen, wordt ModelPersistenceError uitzondering gegenereerd.

Gebruik de methoden opslaan () of upsert (**kwargs) om het nieuw gemaakte model te behouden.

1
2
Track = await Track.objects.get (naam = 'De Vogel')
In afwachting van track.update (naam = 'The Birds Strikes Again')

Als u alleen de geselecteerde kolommen in het model naar de database wilt bijwerken, geeft u een lijst met kolommen die zijn bijgewerkt naar de parameter\ _ columns.

In het voorbeeld:

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

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100, nullable = False, naam = "titel")
    Jaar: int = ormar. Geheel ()
    Winst: zweven = ormar. Zweven ()

Terminator = await Movie (naam = 'Terminator', bouwjaar = 1984, winst = 0,078) .save ()

terminator.name = "Terminator 2"
Terminator.jaar = 1991
Terminator.winst = 0.520

# update alleen naam
Wacht op terminator.update (_ columns = ["naam"])

# Merk op dat de terminator-instantie niet opnieuw is geladen
Bevestigd terminator.year = = 1991

# maar zodra je de gegevens van db hebt geladen, zie je dat deze niet is bijgewerkt
In afwachting van terminator.load ()
Bevestigd terminator.year = = 1984

!!!Waarschuwing Let op: update () vernieuwt geen exemplaren van uw model, dus als u meer kolommen wijzigt dan u doorgeeft in de\ _ columns-lijst, heeft uw modelinstantie een andere waarde dan de database!

Bijwerken tussenvoegsel ()

Upsert (**kwargs) - > zelf

Het is een proxy voor de bovenstaande save () of update (**kwargs) methoden.

Als de primaire sleutel is ingesteld op - >, wordt de updatemethode aangeroepen.

Als pk niet is ingesteld, wordt de methode save () aangeroepen.

1
2
3
4
5
Track = Track (naam = 'De Vogel')
Await track.upsert () # zal opslaan aanroepen als de pk leeg is

Track = await Track.objects.get (naam = 'De Vogel')
In afwachting van track.upsert (name = 'The Bird Strikes Again') # zal update aanroepen omdat pk al is ingevuld

Verwijderen ()

U kunt de methode QuerySet.delete () gebruiken of uw model gebruiken en de methode delete () aanroepen om een model te verwijderen.

1
2
Track = await Track.objects.get (naam = 'De Vogel')
In afwachting van track.delete () # wordt het model uit de database verwijderd

!!!Houd er rekening mee dat het traceerobject ongewijzigd blijft, alleen de records in de database worden verwijderd.

Gerelateerd opslaan ()

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

De methode herhaalt alle relaties van het model dat de methode heeft aangeroepen en roept de upsert () -methode aan op elk niet-opgeslagen model.

Raadpleeg de sectie Status opslaan hierboven om erachter te komen wanneer het model is opgeslagen.

Standaard slaat de methode opslaan\ _ lated alleen modellen op die direct gerelateerd zijn (één stap verwijderd) aan het model dat de methode heeft aangeroepen.

Maar u kunt de parameter follow = True specificeren om door de geneste modellen te herhalen en ze allemaal op te slaan in de relationele boom.

Standaard slaat save\ _ lated alleen modellen op die niet zijn opgeslagen, wat betekent dat ze zijn gewijzigd in het huidige bereik.

Als u wilt dat alle gerelateerde methoden worden opgeslagen, gebruikt u de vlag save\ _ all = True, die alle gerelateerde modellen zal bijwerken, ongeacht hun opslagstatus.

Als u het opslaan van bepaalde relaties wilt overslaan, kunt u de uitsluitingsparameter doorgeven.

Uitsluiten kan een set van zijn eigen modelrelaties zijn, of een woordenboek dat ook geneste items kan bevatten.

!!!Merk op dat de uitsluitingsparameter in save\ _ lated alleen relationele veldnamen accepteert, dus als u andere velden doorgeeft, worden ze toch opgeslagen

!!!Opmerking Raadpleeg de documentatie van de Queryset.fields-methode voor meer informatie over de structuur van mogelijke waarden die aan uitsluitingen zijn doorgegeven.

Waarschuwing: om terugkerende updates met de instelling follow = True te voorkomen, bewaart save\ _ lated een set bezochte modellen op elke tak van de relationele boom en voert het geen geneste save\ _ lated uit op bezochte modellen.

1
Dus als u typen circulaire relaties heeft, moet u de updates handmatig uitvoeren.

Merk op dat met save\ _ all = True en follow = True je save\ _ lated () kunt gebruiken om de hele boom in één keer op te slaan.

Voorbeeld:

 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
Klasse Afdeling (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

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


Klasse Cursus (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    cursus _ naam: str = ormar. String (max _ length = 100)
    Voltooid: bool = ormar. Booleaans ()
    Afdeling: Facultatief [Afdeling] = ormar. ForeignKey (Afdeling)


Klassestudent (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

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

_ opslaan = {
            "afdeling _ naam": "Ormar",
            "Cursussen": [
                {"cursus _ naam": "basic1",
                 "Voltooid": Waar,
                 "Studenten": [
                     {"name": "Jack"},
                     {"name": "Abi"}
                 ]},
                {"cursus _ naam": "basic2",
                 "Voltooid": Waar,
                 "Studenten": [
                     {"name": "Kate"},
                     {"name": "Miranda"}
                 ]
                 },
            ],
        }
# hele boom initialiseren
Afdeling = Afdeling (* * om op te slaan)

# allemaal tegelijk opslaan (achter elkaar)
Wacht op afdeling opslaan _ gerelateerd (volg = Waar, opslaan _ alles = Waar)

afdeling _ check = afwachten Afdeling.objects.select _ all (volgen = Waar) .krijgen ()

uitsluiten = {
    "Id":...,
    "Cursussen": {
        "Id":...,
        "Studenten": {"id", "studentcourse"}
    }
}
# na het uitsluiten van ID 's en via modellen krijg je exact hetzelfde laadvermogen als vroeger
# hele boom bouwen
Afdeling _ controleer model _ dump (uitsluiten = uitsluiten) = = opslaan

Waarschuwing save\ _ lated () herhaalt alle relaties en alle modellen en werkt ze één voor één bij, zodat het alle modellen zal opslaan, maar mogelijk niet optimaal is in termen van het aantal databasequery 's.