Die Modell-Methode

Die primäre Interaktion von!!!tip mit der Datenbank wird durch QuerySet-Objekte auf jedem Modell öffentlich gemacht, die als Model. objects, ähnlich wie django orm, öffentlich zugänglich sind.

Weitere Informationen über**quering, joining tables, excluding fields etc. visit [queries][queries] section.**

Jede Modellinstanz verfügt über eine Reihe von Methoden zum Speichern, Aktualisieren oder Laden von sich selbst.

Die verfügbaren Methoden sind im Folgenden beschrieben.

Pedantische Methoden.

Beachten Sie, dass jedes ormar. Model auch ein pydantic. BaseModel ist, daher können alle pydantischen Methoden auch mit dem Modell verwendet werden, insbesondere die Methoden model_dump () und model_dump_json (), die auch Ausschlüsse, Inklusionen und andere Parameter akzeptieren.

Um mehr zu erfahren, schauen Sie sich die pydantische Dokumentation an

construct_construct () Bearbeiten

Modell_construct ist das ursprüngliche Äquivalent der Methode__init__, die zum Konstruieren neuer Instanzen verwendet wird.

Der Unterschied ist, dass model_construct die Validierung überspringt, so dass Sie es verwenden sollten, wenn Sie wissen, dass die Daten korrekt und vertrauenswürdig sind Der Vorteil der Verwendung des Konstrukts besteht darin, dass die Ausführungsgeschwindigkeit durch Überspringen der Validierung erhöht wird.

!!!Beachten Sie, dass im Gegensatz zur Methode pydantic. model_construct-eine äquivalente Ormar-Methode auch mit verschachtelten verwandten Modellen arbeitet.

WARNUNG Denken Sie daran, dass die Erstellungsmethode aufgrund des Überspringens der Überprüfung keine Konvertierungen, Prüfungen usw. durchführt und Sie für die Bereitstellung gültiger und für die Datenbank verfügbarer Daten verantwortlich sind.

Die einzigen zwei Dinge, die noch immer funktionieren, sind:

*  Lieferung A `default` Werte für das Nicht-Festlegen von Feldern
*  Initialize nested ormar models, wenn Sie ein Dictionary oder einen Primärschlüsselwert überschreiten

Modellablagerung ()

model_dump ist eine Methode, die von pydantic erbt, aber ormar fügt seine eigenen Parameter hinzu und hat einige Nuancen, wenn es um die Verwendung von Standardwerten geht, also ist sie hier aus Gründen der Klarheit aufgeführt.

Model_dump exportiert Daten aus dem Modellbaum in das Wörterbuch.

Der Parameter model_dump zeigt:

Einfügen (oder Ändern)

include: Union[Set, Dict] = None

Der Satz von Feldnamen oder Dictionary, der in das zurückgegebene Wörterbuch aufgenommen werden soll.

Beachten Sie, dass pydantic ein seltenes Muster hat, das durch Indexieren von Feldern aus einer Inclusion/Exclusion Liste (wie auch bei verschachtelten Modellen) funktioniert Wenn Sie Felder aus allen Unterschlüsseln ausschließen möchten, müssen Sie den Schlüssel__all__an das Wörterbuch übergeben.

Sie können verschachtelte Modelle in Sets nicht von pydantic ausschließen, aber in ormar (indem Sie einen doppelten Unterstrich über den relationalen Namen hinzufügen, d. h. die Klassennamen der Bücher ausschließen, die Sie verwenden können) exclude={"book__category__name"} ）

Ormar unterstützt keine Indexausschlüsse/-einschlüsse und akzeptiert eine vereinfachte und benutzerfreundlichere Notation.

Um zu überprüfen, wie Felder (einschließlich verschachtelter Felder) einbezogen/ausgeschlossen werden können, sehen Sie sich den Abschnitt mit den Feldern an, der Erklärungen und eine große Anzahl von Beispielen enthält.

!!!Beachten Sie die Tatsache, dass Sie in ormar verschachtelte Modelle aus einer Sammlung ausschließen können, und Sie können aus dem gesamten Modellbaum in response_model_exclude und response_model_include in fastapi ausschließen!

Ausschluss (oder Änderung)

exclude: Union[Set, Dict] = None

Die Menge oder das Dictionary von Feldnamen, die im zurückgegebenen Wörterbuch ausgeschlossen werden sollen.

Beachten Sie, dass pydantic ein seltenes Muster hat, das Felder aus einer Liste durch Indizierung enthält/ausschließt (dasselbe gilt für verschachtelte Modelle), wenn Sie Felder aus allen Unterschlüsseln ausschließen möchten, müssen Sie_\hinzufügen._Alles_Der Schlüssel wird an das Wörterbuch übergeben.

Sie können verschachtelte Modelle in Sets nicht von pydantic ausschließen, aber in ormar (indem Sie dem relationalen Namen einen doppelten Unterstrich hinzufügen, d. h. den Klassennamen des verwendeten Buches ausschließen)exclude={"book__category__name"})

Ormar unterstützt keine Indexausschlüsse/-einschlüsse und akzeptiert eine vereinfachte und benutzerfreundlichere Notation.

Um zu überprüfen, wie Felder (einschließlich verschachtelter Felder) einbezogen/ausgeschlossen werden können, sehen Sie sich den Abschnitt mit den Feldern an, der Erklärungen und eine große Anzahl von Beispielen enthält.

!!!Beachten Sie die Tatsache, dass Sie in ormar verschachtelte Modelle aus einer Sammlung ausschließen können, und Sie können aus dem gesamten Modellbaum in response_model_exclude und response_model_include in fastapi ausschließen!

Ausgeschlossen-Abgesagt.

Ausschließen Nicht festgelegt: Boolean = False

Flag Gibt an, ob Felder, die beim Erstellen des Modells nicht explizit festgelegt wurden, aus dem zurückgegebenen Wörterbuch ausgeschlossen werden sollten.

!!!Warnung Beachten Sie, dass nach dem Speichern der Daten in der Datenbank jedes Feld einen eigenen Wert hat->, der von Ihnen angegeben werden kann, Standard oder nichts.

Dies bedeutet, dass, wenn Sie die Daten aus der Datenbank laden, **Alles** Fields are set, und diese Flagge stoppt grundsätzlich die Arbeit!


Klasse Kategorie (ormar. Modell):
    ormar_config = base_ormar_config. copy (tablename ="Kategorien")

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100, default ="Test")
    visibility: bool = ormar. boolean (default = true)(siehe auch: boolean = true)


Klasse Item (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)
    Preis: float = ormar. Float (default = 9.99)
    Kategorie: Liste [Kategorie]= ormar.

category = Category (name = " Test 2 ") Bearbeiten
model _ dump () = = Æ'id ' : None , ' items': [ ] , ' name': ' Test 2',
                           ' visibility': wahr}
Model _ dump (exclude _ unset = true) = = Ausrufezeichen {'items': [], 'name': 'Test 2'}

Await istcategory.save()
Kategorie 2 = await Kategorie . Objekt . get ()
assert category2.model_dump () = = Æ'id ' : 1 , ' items': [ ] , ' name': ' Test 2',
                            ' visibility': wahr}
Hinweis : Wie nach dem Loading alle Felder aus DB-Fields explizit gesetzt sind
Das ist es , was passiert , wenn man ein Modell populär macht .
assert category2.model_dump (exclude _ unset = True) = = ‰ ' id': 1 , ' items': [ ] ,
                                              ' name': ' Test2', ' visibility': True} [ Benutzername ]

Ausschließen von Bestätigungswerten

exclude_defaults: bool = False

Die Angabe eines Flags gleich seinem Standardwert (ob gesetzt oder nicht) sollte aus dem zurückgegebenen Wörterbuch ausgeschlossen werden

Klasse Kategorie (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 100 , default = " Test ")
    visibility : bool = ormar . boolean (default = true) (siehe auch : boolean = true)

Klasse Item (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) [ Bearbeiten | Quelltext bearbeiten ]
    Preis : float = ormar . Float (default = 9.99)
    Kategorien : Liste [ Kategorie ] = ormar .

Category = Die ()
# note that Integer pk is by default autoincrement so optional ist
Beispiel : Model _ dump () = {'id': None, 'items': [], 'name': 'Test', 'visibility': True}
Model _ dump (exclude _ defaults = true) = = Ausschlussfehler = wahr {'items': []}

Speichern und Löschen der Daten
Await istcategory.save()
Kategorie 2 = await Kategorie . Objekt . get ()

assert category2.model_dump () = = Beschreibung {'id': 1, 'items': [], 'name': 'Test', 'visibility': True}
assert category2.model_dump (exclude _ defaults = true) = = geschlossen {'id': 1, 'items': []}

Ausgeschlossen - nichts .

Ausgeschlossen \ _ keine : boolean = false

Flag Gibt an , ob ein Feld gleich None aus dem zurückgegebenen Dictionary ausgeschlossen werden soll .

Klasse Kategorie (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    str = ormar . String (max _ length = 100 , default = " Test " , nullable = True)
    visibility : bool = ormar . boolean (default = true) (siehe auch : boolean = true)


Klasse Item (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)
    Preis : float = ormar . Float (default = 9.99)
    Kategorien : Liste [ Kategorie ] = ormar .


Kategorie = Kategorie (Vorname = None)
model _ dump () = = Æ'id ' : None , ' Items': [ ] , ' name': None , None , [ ]
                           ' visibility': wahr}
#
Model _ dump (exclude _ none = true) = = Ergebnis {'items': [], 'visibility': True}

Await istcategory.save()
Kategorie 2 = await Kategorie . Objekt . get ()
assert category2.model_dump () = = Æ'id ' : 1 , ' items': [ ] , ' name': None ,
                            ' visibility': wahr}
assert category2.model_dump (exclude _ none = True) = = ‰ ' id': 1 , ' items': [ ] ,
                                             ' visibility': wahr}

mit Ausnahme von \ _ primary \ _ keys (nur ormar)

exclude_primary_keys: bool = False

Wenn Sie die Kennzeichnung auf True festlegen , werden alle Primärschlüsselspalten in der Struktur ausgeschlossen , einschließlich verschachtelter Modelle .

Klasse Item (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) [ Bearbeiten | Quelltext bearbeiten ]

item1 = Item (id = 1 , name = " Testobjekt ")
assert item1.model_dump () = = Eingabetaste {"id": 1, "name": "Test Item"}
assert item1.model_dump (exclude _ primary _ keys = true) = = Siehe auch : {"name": "Test Item"}

except \ _ through \ _ models (nur Ormar)

exclude_through_models: bool = False

Passthrough-Modelle werden automatisch für jede polare Beziehung hinzugefügt , und sie speichern zusätzliche Parameter auf dem verknüpften Modell/der verknüpften Tabelle .

Die Einstellung except \ _ through \ _ models = True schließt alle Passthrough-Modelle aus , einschließlich der Passthrough-Modelle von Untermodellen .

Klasse Kategorie (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Kategorien ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 100) [ Bearbeiten | Quelltext bearbeiten ]


Klasse Item (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) [ Bearbeiten | Quelltext bearbeiten ]
    Kategorie : Liste [ Kategorie ] = ormar .

Der Baum definiert die Modelle
Das _ dict = {
            „ Name " : „ Test " ,
            " Kategorien " : [{"name": "test cat"},{"name": "test cat2"}] ,
        }
Retten Sie den Whole Tree
await Item (* * item _ dict) . save _ related (follow = true , save _ all = true) [ Bearbeiten | Quelltext bearbeiten ]

Ermitteln Sie die gespeicherten Werte .
Bedeutung = awaitItem.objects.select_ related (" Kategorien ") . get ()

Durch die Voreinstellung können Sie die Modelle sehen (Itemcategory)
assert item . model _ dump () = = ‰ ' id': 1 , ' name': ' test',
                       Kategorien > Kategorien : [
                           stießen ' id ' : 1 , ' name': ' test cat',
                            für 'itemcategory':{'id': 1, 'category': None, 'item': None}},
                           stießen auf ' id ' : 2 , ' name': ' test cat2',
                            für ' itemcategory':{'id': 2, 'category': None, 'item': None}}
                       ]}

Sie können die Felder/Modelle ausblenden
Model _ dump (exclude _ through _ models = true) = = {
                       ' id': 1 , ' name': ' test', ' name': ' test',
                       Kategorien > Kategorien : [
                           {'id': 1, 'name': 'test cat'}, 
                           {'id': 2, 'name': 'test cat2'}
                       ]}

Beispiel : _ dump _ json ()

model_dump_json () hat genau die gleichen Parameter wie model_dump (), also überprüfen Sie das oben.

Natürlich ist das Endergebnis eine Zeichenfolge, die von json repräsentiert wird, und kein Wörterbuch.

Verwendung von_pydantic ()

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

Mit dieser Methode können Sie ein Pydantik-Modell aus einem Ormar-Modell erstellen, ohne alle Felder erneut eingeben zu müssen.

Beachten Sie, dass, wenn Sie ein verschachteltes Modell haben, wird es den gesamten pydantischen Modellbaum für Sie generieren!

Darüber hinaus können Sie Ausschlüsse und/oder Parameter einschließen, um nur die Felder beizubehalten, die Sie möchten, auch in einem verschachtelten Modell.

Das bedeutet, dass Sie ganz einfach Pydantic-Modelle für Anfragen und Antworten in der Fastapi erstellen können.

Hinweis Um mehr über mögliche Ausschlüsse/Einschlüsse zu lesen und wie man ein Ausschlusswörterbuch oder eine Einstellung erstellt, besuchen Sie bitte den Abschnitt Felder des Dokuments.

Das Ormar-Modell wird wie folgt angegeben:

Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    metadata = sqlalchemy. metadata (), oder
    database = databases. Database (DATABASE_URL, force_rollback = true) oder
)


Klasse (ormar. Modell):
    ormar_config = base_ormar_config. copy (tablename ="Kategorien")

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    name: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]


Klasse Item (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, default ="test")(string = ormar. String (max_length = 100, default ="Test")(max_length = 100, default ="Test")
    Kategorie: Optional [Category]= ormar. ForeignKey (Category, nullable = True)

Sie können ein Pydantic-Modell mit einem einfachen Aufruf erstellen.

PydanticCategory = Category. get_pydantic (include ={"id", "name"})[Bearbeiten | Quelltext bearbeiten]

Dadurch wird ein Modell generiert, das dem folgenden entspricht:

Klasse (Base-Modell):
    id : Optional [ Eingestellt von ]
    name : Optional [ str ] = " Prüfung "

Es ist keine gute Gewohnheit , mehrere Klassen mit dem gleichen Namen in einem Modul zu haben , und es verdirbt die fastapi-Dokumentation , weshalb ormar zufällige 3 Großbuchstaben zu den Klassennamen hinzufügt Im obigen Beispiel bedeutet dies , dass die Klasse tatsächlich Category \ _ XIP (BaseModel) heißt .

Zum Ausschließen oder Einschließen verschachtelter Felder können Sie entweder ein Wörterbuch oder einen doppelten Unterstrich verwenden .

Beide Kühe sind gleich
PyanticCategory = Category . get _ pydantic (include ={"id", "items__id"}) [ Bearbeiten | Quelltext bearbeiten ]
PyanticCategory = Category . get _ pydantic (include = {" id " : ... , " items " :{"id"}}) (include = {" id " : ... , " Elemente " :{"id"}})

Die entstandene Struktur ist wie folgt :

Klasse Item (BaseModel)
    id : Optional [ Eingestellt von ]

Klasse (Base-Modell) :
    id : Optional [ Eingestellt von ]
    items : Optional [ Liste ] [ Einzelteil ]

Natürlich können Sie auch eine tief verschachtelte Struktur verwenden , deren pydantisches Äquivalent Ormar für Sie generiert (so , dass Schleifen ausgeschlossen werden) .

Beachten Sie , dass das obige Item-Modell keinen Bezug zu Category hat , obwohl die Beziehung in ormar bidirektional ist (und ormar . Item ein categories-Feld hat) .

Beachten Sie , dass das generierte pydantische Modell alle Feldvalidatoren vom ursprünglichen ormar-Modell erbt , einschließlich des ormar-Selection - Validators und der mit dem pydantic . validator definierten Validatoren .

Da alle Root-Validatoren gleichzeitig auf `ormar`-Modellen vorhanden sind , wird**NOT**auf das generierte pydantische Modell kopiert .
Wenn erforderlich , müssen Sie diese manuell kopieren , um das pydantische Modell zu generieren .

überladen ()

Wenn Sie eine Tabelle abfragen , ohne das zugehörige Modell vorab zu übernehmen , erstellt ormar Ihre zugehörigen Modelle standardmäßig noch , füllt sie jedoch nur mit pk-Werten aus , Sie können die zugehörigen Modelle laden , indem Sie die load () - Methode aufrufen .

load () kann auch verwendet werden , um ein Modell aus der Datenbank zu aktualisieren , wenn es von einem anderen Prozess geändert wurde .

track = await Track . objects . get (name ='The Bird') [ Bearbeiten | Quelltext bearbeiten ]
track.album.pk # will return balibu album pk (1) [ Bearbeiten | Quelltext bearbeiten ]
track.album.name # will return keine

# Sie müssen die Daten zuerst laden
Auf dem Weg zum Album . load ()
track.album.name Zurück zu " Malibu "

Alles löschen ()

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

Eine Methode funktioniert ähnlich wie load () , durchläuft aber auch alle Beziehungen des Modells , das die Methode aufruft , und lädt sie aus der Datenbank neu .

Standardmäßig lädt die load \ _ all-Methode nur das Modell , das direkt (in einem Schritt) mit dem Modell verknüpft ist , das die Methode aufruft .

Sie können jedoch den Parameter follow = true angeben , um das verschachtelte Modell zu durchlaufen und alle in den relationalen Baum zu laden .

Warnung Um eine wiederkehrende Aktualisierung mit der Einstellung follow = true zu vermeiden , speichert load \ _ all eine Gruppe von bereits besuchten Modellen und führt keine verschachtelten Ladevorgänge für bereits besuchte Modelle durch .

Wenn Sie also über einen bestimmten Typ oder eine Art Zirkularität verfügen , müssen Sie die Logos auf manuelle Weise ausführen .

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

Die Methode akzeptiert auch optionale Ausschlussparameter , die genau so funktionieren wie die Ausschlussfeldmethode in QuerySet , sodass Sie Felder aus dem verknüpften Modell löschen oder das gesamte zugehörige Modell überspringen können .

Eine Methode führt eine Datenbankabfrage aus und ist daher effizienter als verschachtelte Aufrufe von load () und all () im relationalen Modell .

!!!tip Um mehr über den Ausschluss zu erfahren , lesen Sie except \ _ fields

!!!Warnung Alle Beziehungen werden auf load \ _ all () gelöscht , so dass , wenn bestimmte verschachtelte Modelle ausgeschlossen werden , sie nach dem Aufruf leer bleiben .

Einsparungen ()

save () - > Selbsthilfe

Sie können ein neues Modell erstellen , indem Sie die QuerySet . create () - Methode verwenden oder das Modell als normales pydantisches Modell initialisieren und dann die save () - Methode aufrufen .

Mit save () können auch Änderungen am Modell gespeichert werden , sofern kein Primärschlüssel festgelegt ist oder das Modell nicht in der Datenbank vorhanden ist .

Die save () - Methode prüft nicht , ob das Modell in der Datenbank vorhanden ist , wenn also ein vorhandenes Modell mit einem bereits vorhandenen Primärschlüssel gespeichert werden soll , erhalten Sie einen Integritätsfehler vom ausgewählten Datenbank-Backend .

Track = Track (name ='The Bird') (Deutsche Übersetzung)
Await sehentrack.save(*) # # wird das Modell in der Datenbank erfassen

track = await Track . objects . get (name ='The Bird') [ Bearbeiten | Quelltext bearbeiten ]
Await sehentrack.saveFehler : Integritätsfehler wird als PK verbreitet gemeldet

aktualisiert ()

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

Sie können das Modell mit der Methode QuerySet . update () aktualisieren oder die Modelleigenschaften (Felder) aktualisieren und die Methode update () aufrufen .

Wenn Sie versuchen , ein Modell zu aktualisieren , ohne einen Primärschlüssel festzulegen , wird eine ModelPersistenceError-Ausnahme ausgelöst .

Um ein neu erstelltes Modell dauerhaft zu speichern, verwenden Sie save () oder upsert ().**Die Kwars-Methode.

track = await Track . objects . get (name ='The Bird') [ Bearbeiten | Quelltext bearbeiten ]
Update (Name = ' The Bird Strikes Again ') Bearbeiten

Um nur die ausgewählten Spalten im Modell in der Datenbank zu aktualisieren , geben Sie eine Liste der Spalten an , die mit dem Parameter \ _ columns aktualisiert werden sollen .

In den Beispielen :

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

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    String (max _ length = 100 , nullable = False , name = " title ") (max _ length = 100 , nullable = False , name = " title ")
    Jahr : int = Ormar . Integer ()
    Ergebnis : float = ormar . float ()

terminator = await Movie (name ='Terminator ' , Jahr = 1984 , Gewinn = 0.078) . save ()

terminator.name für Terminator 2
terminator . jahr = 1991
terminator . Gewinn = 0,520

Update nur für Namen
await terminator . update (_ columns = [ " name " ]) [ Bearbeiten | Quelltext bearbeiten ]

Hinweis : Die Terminatorinstanz wurde nicht neu geladen .
assert terminator . jahr = 1991

# Aber sobald Sie die Daten aus der DB geladen haben , sehen Sie , dass sie nicht aktualisiert wurden
await terminator . load () ausführen
assert terminator . jahr = 1984

!!!warnt davor , dass update () keine Instanz des Modells aktualisiert , wenn Sie also mehr Spalten ändern , als in der Liste " _ _ columns " eingegeben werden , weist Ihre Modelinstanz einen anderen Wert auf als die Datenbank !

Aktualisierung der Einfügungen ()

upsert (**kwargs) - > Selbstständig

Dies ist ein Proxy für die oben genannte save () oder update (**kwargs) Methode .

Wenn der Primärschlüssel auf-> gesetzt ist, wird die Aktualisierungsmethode aufgerufen.

Wenn pk nicht gesetzt ist, wird die save ()-Methode aufgerufen.

Track = Track (name ='The Bird')(Deutsche Übersetzung)
#will call save as the pk is empty ()#will call save as die PK ist leer

track = await track. objects. get (name ='The Bird')[Bearbeiten | Quelltext bearbeiten]
await track. upsert (name ='The Bird Strikes Again ')#will call update as pk is already populated

Streichen ()

Sie können ein Modell löschen, indem Sie die QuerySet. delete ()-Methode verwenden oder Ihr Modell verwenden und die delete ()-Methode aufrufen.

track = await track. objects. get (name ='The Bird')[Bearbeiten | Quelltext bearbeiten]
await track. delete ()#wird das Modell von der Datenbank löschen

!!!Beachten Sie, dass das Tracking-Objekt unverändert bleibt und nur die Datensätze in der Datenbank gelöscht werden.

Erhaltung relevant)

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

Eine Methode durchläuft alle Beziehungen des Modells, das die Methode aufruft, und ruft die upsert ()-Methode für jedes nicht gespeicherte Modell auf.

Um zu erfahren, wann das Modell gespeichert wird, sehen Sie sich den Abschnitt Speicherstatus oben an.

Standardmäßig speichert die save_lated-Methode nur das Modell, das direkt (einen Schritt entfernt) mit dem Modell verknüpft ist, das die Methode aufgerufen hat.

Sie können jedoch den Parameter follow = true angeben, um das verschachtelte Modell zu durchlaufen und alle in der relationalen Struktur zu speichern.

Standardmäßig speichert save_lated nur Modelle in einem nicht gespeicherten Zustand, was bedeutet, dass sie im aktuellen Umfang geändert wurden.

Wenn Sie das Speichern aller relevanten Methoden erzwingen möchten, verwenden Sie das Flag save_all = True, mit dem die Updates unabhängig von ihrem Speicherstatus in alle zugehörigen Modelle eingefügt werden.

Wenn Sie das Speichern bestimmter Beziehungen überspringen möchten, können Sie einen Ausschlussparameter übergeben.

Exclude kann entweder eine eigene Gruppe von Modellbeziehungen oder ein Wörterbuch sein, das verschachtelte Elemente enthalten kann.

!!!note Beachten Sie, dass Ausschlussparameter in save_lated nur relationale Feldnamen akzeptieren, also wenn Sie andere Felder übergeben, werden sie auf jeden Fall gespeichert

!!!Hinweis Um mehr über die Struktur zu erfahren, die an mögliche Werte für Ausschlüsse übergeben wird, lesen Sie die Dokumentation der Queryset. fields-Methode.

Warnung Um eine wiederkehrende Aktualisierung mit der Einstellung follow = true zu vermeiden, speichert save_lated eine Gruppe von besuchten Modellen auf jedem Zweig der relationalen Struktur und verschachtelt save_lated nicht auf bereits besuchten Modellen.

Wenn Sie also bestimmte Typen von Beziehungen haben, müssen Sie die Aktualisierungen manuell durchführen.

Beachten Sie, dass Sie mit save_all = true und follow = true die Funktion save_lated () verwenden können, um den gesamten Beziehungsbaum auf einmal zu speichern.

Beispiele:

Klassenverwaltung (Ormar Model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

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


Klasse Kurs (ormar. model):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von Ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    course_name: str = ormar. String (max_length = 100)
    completed: bool = boolean () oder boolean ()
    department: Optional [Abteilung]= ormar. ForeignKey (Abteilung)


Klasse Schüler (ormar.
    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)[Bearbeiten | Quelltext bearbeiten]
    ManyToMany (natürlich)

mit_save ={
            "department_name":"Ormar", oder
            Der „ Kurs ":[
                ==== Grundsteinlegung 1 ===
                 "vollständig": true,
                 Für Studenten: [
                     {"name": "Jack"},
                     {"name": "Abi"}
                 ]},
                ==== Grundlegender Name ===
                 "vollständig": true,
                 Die Schüler:[
                     {"name": "Kate"},
                     {"name": "Miranda"}
                 ]
                 },
            ],
        }
Initialisierung eines Whole Tree
department = Abteilung (* * to _ save) .

Save all at once (one after another) (Rettung aller auf einmal (einer nach dem anderen))
Await istdepartment.saverelated (follow = true , save _ all = true) (folgt = true und speichert alle = true)

department _ check = ÜberprüfungDepartment.objects.select_ all (folgt = true) . get ()

to _ exclude = {Übersetzung}
    Mit „ id " :
    natürlich :)
        Mit „ id " :
        „ Studenten " aus : {"id", "studentcourse"}
    }
}
# Nach der Prüfung der Anzahl der Personen und durch die Modelle , die Sie erhalten die gleichen Anweisungen wie die Payload verwendet werden
Der Construct Whole Tree
Model _ dump (exclude = to _ exclude) = = to _ save (Hinzufügen)

Die Warnung save _ lated () durchläuft alle Beziehungen und alle Modelle einzeln und aktualisiert sie , so dass es alle Modelle speichert , aber in Bezug auf die Anzahl der Datenbankabfragen möglicherweise nicht optimal ist .