Zum Inhalt

Das Model

Definitionsmodell

Durch die Definition von Ormar-Modellen erhalten Sie die entsprechenden Pydantik-Modelle kostenlos zusammen mit Sqlalchemy-Tabellen , die im Hintergrund verwaltet werden , und Sie müssen sie nicht selbst erstellen .

Die Modell-Kategorien

Um ein ormar-Modell zu erstellen , erben Sie einfach die ormar . Model-Klasse .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

Definition der Wörter

Weisen Sie dann ein oder mehrere Felder als Variablen auf Klassenebene zu .

Grundlegendes Wort Typ

Jede Tabelle muss über eine Primärschlüsselspalte verfügen , die Sie angeben können , indem Sie Primary \ _ key = True auf das ausgewählte Feld setzen .

Es ist nur eine Primärspalte zulässig .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!Warnung Die Nichtzuweisung einer Primary \ _ key-Spalte oder die Zuweisung mehrerer Spalten pro Modell führt zur ModelDefinitionError-Ausnahme .

Standardmäßig ist die Auto-Increment - Option auf true festgelegt , wenn ein Primärschlüssel einem Ganzzahlfeld zugewiesen ist .

Sie können es deaktivieren , indem Sie autoincrement = False übergeben .

1
id : int = ormar . Integer (primary _ key = true , autoincrement = false)

Nicht-Datenbank - Wörter

Beachten Sie , dass Sie , wenn Sie ein normales Pydantic-Feld in Ihrem Modell benötigen (zum Speichern von Werten oder zum Übergeben bestimmter Werte auf dem Modell) , ein Feld in Pydantic wie üblich definieren können .

Felder , die wie diese erstellt werden , werden dem Feld des pydantischen Modells hinzugefügt - > daher werden sie anhand des Feldtyps überprüft und erscheinen auch in den Ergebnissen von model _ dump () und model _ dump _ json () .

Der Unterschied besteht darin , dass diese Felder nicht in der Datenbank gespeichert werden , sodass sie nicht in den zugrunde liegenden sqlalchemy-Spalten oder Tabellenvariablen enthalten sind (überprüfen Sie die internen Abschnitte unten , um zu erfahren , wie Sie bei Bedarf darauf zugreifen können) .

Das Feld pydantic wird dann nicht in die Migration oder Datenbankoperationen (Speichern , Aktualisieren usw .) einbezogen .

Felder wie diese können an eine Nutzlast in einer Fastapi-Anfrage übergeben und werden in einer Fastapi-Antwort zurückgegeben (natürlich nur , wenn Sie ihren Wert irgendwo im Code festlegen , da dieser Wert nicht aus der Datenbank abgerufen wird Wenn Sie einen Wert in Fastapirequest übergeben und die gleiche Instanz zurückgeben , die Fastapi für Sie in der Anfrage \ _ model konstruiert hat , sollten Sie in der Antwort genau den gleichen Wert zurückgeben) .

!!! Das Feld warning pydantic muss immer optional sein und darf sich nicht ändern (andernfalls schlägt die Validierung beim Laden der Datenbank fehl) .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)
    non_db_field: str = pydantic.Field(max_length=100)

Wenn Sie das Feld pydantic mit den Standardparametern setzen und den tatsächlichen Wert nicht in der Anforderung übergeben , erhalten Sie immer den Standardwert , da es sich um eine Funktion handeln kann , können Sie default = setzen .datetime.datetime.nowSo erhalten Sie bei jedem Aufruf einen aktuellen Zeitstempel .

Nicht-Datenbank - Felder in Fastapi

Beachten Sie , dass die Felder pydantic und calculated \ _ fields sowohl in model \ _ dump () - als auch in fastapi-Antworten mit/aus und response \ _ model \ _ include/response \ model _ model \ _ exclude eingeschlossen/ausgeschlossen werden können .

 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
Ein Teil des relativen Codes wurde für die Klarstellung entfernt .
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle : (
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
    metadata = sqlalchemy . metadata () , oder
    . create _ engine = sqlalchemy (DATABASE _ URL) und
)


Klasse Benutzer (ormar . Model) :
    ormar _ config = base _ ormar _ config . copy (tablename = " users2 ") Bearbeiten

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    String (max _ length = 255 , nullable = False) : string = ormar . String (max _ length = 255 , nullable = False) (keine Angabe)
    Passwort : str = ormar . String (max _ length = 255)
    first _ name : str = ormar . String (max _ length = 255) [ string = ormar . string (max _ length = 255) ] (max _ length = 255) [ string = 255 ] (max _ length = 255)
    last _ name : str = ormar . String (max _ length = 255) string = ormar . string (max _ length = 255) ist ein
    String = ormar . String (max _ length = 255 , nullable = true)
    @data.de: data.de: data.de (
        default = nichtdatetime.datetime.now
    )

Ein Teil des verknüpften Codes wurde für die Klarstellung entfernt .
Anwendung : FastAPI ()

@app.post(Benutzer/Benutzer)
async def create _ user (Benutzer : Benutzer) :
    return await Zurückuser.save()

Ein Teil des verknüpften Codes wurde für die Klarstellung entfernt .

def test _ excluding _ fields _ in _ endpoints ()
    client = Testclient (Anwendung)
    Mit dem Kunden als Kunde :
        timestamp = Zeitdatetime.datetime.now()

        Benutzer : {
            Deine E-Mail : >test@domain.com",
            ^*^ % A*DA * IAAA " , oder
            Vorname : " John " ,
            Letzter Name : „ Doe " ,
            " timestamp " : str (timestamp) ,
        }
        Antwort =client.post("/users/" , json = Benutzer)
        assert list (response . json () . keys ()) = [ Bearbeiten | Quelltext bearbeiten ]
            Die " ID " ,
            Die „ E-Mail " ,
            „ Erster Name " ,
            „ Letzter _ Name " ,
            Die Kategorie „ ,
            „ Zeitsprung " ,
        ]
        Returned ist der gleiche Zeitstempel
        replace (") . get (" timestamp ") = = str (timestamp) . replace (" " , " T ")


Ein Teil des verknüpften Codes wurde für die Klarstellung entfernt .

Name und Anschrift der

Standardmäßig wird der Feldname für das zugrunde liegende Pydantik-Modell und die sqlalchemy-Tabelle verwendet .

Wenn Sie aus irgendeinem Grund den Namen in der Datenbank ändern , aber den Namen im Modell behalten möchten , können Sie dies tun , indem Sie während der Felddeklaration den Namensparameter angeben .

Hier ist ein Beispielmodell , dessen Name geändert wurde .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

DATABASE_URl = "sqlite:///test.db"

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)

Beachten Sie , dass Sie auch den Namen einer Fremdschlüsselspalte ändern können

 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
from typing import Optional

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///test.db", force_rollback=True)
metadata = sqlalchemy.MetaData()


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="music_albums",
    )

    id: int = ormar.Integer(name="album_id", primary_key=True)
    name: str = ormar.String(name="album_name", max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist, name="artist_id")

Derzeit können Sie die Namen der ManyToMany-Spalten jedoch nicht ändern , da sie auf jeden Fall durch ein anderes Modell gehen .

 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
import databases
import ormar
import sqlalchemy

DATABASE_URl = "sqlite:///test.db"

database = databases.Database(DATABASE_URl, force_rollback=True)
metadata = sqlalchemy.MetaData()


class Child(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children",
    )

    id: int = ormar.Integer(name="child_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year_born", nullable=True)


class ArtistChildren(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="children_x_artists",
    )


class Artist(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        tablename="artists",
    )

    id: int = ormar.Integer(name="artist_id", primary_key=True)
    first_name: str = ormar.String(name="fname", max_length=100)
    last_name: str = ormar.String(name="lname", max_length=100)
    born_year: int = ormar.Integer(name="year")
    children = ormar.ManyToMany(Child, through=ArtistChildren)

Abdeckung der anerkannten Suchfunktion

Wenn Sie eine Abfrage anpassen möchten , die von ormar ausgeführt wird , können Sie Ihre eigene Abfragesammlerklasse in der Modellklasse definieren (mit der Erweiterung von ormar QuerySet) , die standardmäßig QuerySet ist .

Sie können eine neue Klasse als queryset _ class Parameter in ormar \ _ config einer Klasse angeben .

 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
Der Import von Ormar
from ormar. queryset. queryset import QuerySet (QuerySet importieren)
Import von HTTPException


class MyQuerySetClass (QuerySet):

    async def first_or_404 (self, * args, ** kwargs):
        entity = await self. get_or_none (* args, ** kwargs)[Bearbeiten | Quelltext bearbeiten]
        Wenn die Entität keine ist:
            In Fastapi oder Starlette
            HTTPException (404) Bearbeiten


Klasse Buch (ormar. model):
    Die Datei Datei Datei Datei: Config_Config_Config (
        queryset_class = MyQuerySetClass, oder
        tabName ="Buch"
    )

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


#Wenn das Buch nicht gefunden wird, raise `404` in your view.
book = await Book.objects.first_or_404 (name ="123")[Bearbeiten | Quelltext bearbeiten]

Typ Ansage

Beachten Sie, dass Sie für eine bessere IDE-Unterstützung und mypy-Prüfung Typhinweise angeben können.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

Beachten Sie, dass Typhinweise optional sind, so dass ein voll gültiger ormar-Code wie folgt aussehen kann:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id = ormar.Integer(primary_key=True)
    name = ormar.String(max_length=100)
    completed = ormar.Boolean(default=False)

!!!Warnung Auch wenn Sie Typhinweise verwenden, verwendet ormar diese nicht, um pydantische Felder zu konstruieren!

1
2
Typ-Hints gibt es nur zur Unterstützung statischer Checkers und Linting,
`ormar` construct annotations used by `pydantic` from own fields.`ormar` Nutzungshinweise von `pydantic` von eigenen Feldern.

Abhängigkeitsverhältnis

Da ormar für die Datenbankverbindung und die Tabellenerstellung auf die Datenbank und den sqlalchemy-core angewiesen ist, müssen Sie jedem Modell zwei spezielle Parameter zuweisen.

Datenbank sein

Eine Datenbankinstanz, die mit einer Datenbank-URL im Format sqlalchemy Connection String erstellt wurde.

Die Instance, die Sie erstellen, muss mit dem Objekt-Datenbankparameter ormar_config an jedes Modell übergeben werden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!Sie müssen nur einmal eine Datenbankinstanz erstellen und sie für alle Modelle verwenden Wenn Sie mit mehreren Datenbanken arbeiten möchten, können Sie mehrere Datenbanken erstellen.

Der Alleskönner

Die zweite Abhängigkeit ist die sqlalchemy MetaData-Instanz.

Die Instance, die Sie erstellen, muss mit den Metadatenparametern des Ormar_config-Objekts an jedes Modell übergeben werden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!Sie müssen nur einmal eine MetaData-Instanz erstellen und sie für alle Modelle verwenden Wenn Sie mit mehreren Datenbanken arbeiten möchten, können Sie mehrere Datenbanken erstellen.

Die Best Practices

Beachten Sie, dass ormar ein Feld mit dem Namen ormar_config benötigt, das eine Instanz der OrmarConfig-Klasse ist Um die Konfigurationsverwaltung zu vereinfachen, stellt die OrmarConfig-Klasse eine Replikationsmethode zur Verfügung Aus diesem Grund sollten Sie ein Basisobjekt erstellen und dessen Kopien in allen Modellen verwenden, anstatt immer wieder die gleichen Parameter für alle Modelle bereitzustellen.

 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
from typing import Optional

import databases
import ormar
import sqlalchemy

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL),
    metadata=sqlalchemy.MetaData(),
)


class Artist(ormar.Model):
    # note that tablename is optional
    # if not provided ormar will user class.__name__.lower()+'s'
    # -> artists in this example
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    first_name: str = ormar.String(max_length=100)
    last_name: str = ormar.String(max_length=100)
    born_year: int = ormar.Integer(name="year")


class Album(ormar.Model):
    ormar_config = ormar_base_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    artist: Optional[Artist] = ormar.ForeignKey(Artist)

Bezeichnung Tabelle

Standardmäßig werden die Tabellennamen basierend auf dem Modellklassennamen erstellt, d. h. dem Kleinbuchstaben mit einem "s".

Sie können diesen Parameter außer Kraft setzen, indem Sie einen Tabellennamenparameter für das ormar_config-Objekt angeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):

    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # if you omit this parameter it will be created automatically
        # as class.__name__.lower()+'s' -> "courses" in this example
        tablename="my_courses",
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

Bindende Bedingungen

Auf der Modellebene können Sie auch Einschränkungen für Modellaspekte für SQL-Spalten festlegen.

Derzeit werden nur IndexColumns-, UniqueColumns-und CheckColumns-Einschränkungen unterstützt.

!!!note Beachten Sie, dass Sie diese beiden Einschränkungen nur verwenden sollten, wenn Sie einen Namen für eine Einschränkung festlegen möchten oder wenn Sie Indizes für mehrere Spalten festlegen möchten, andernfalls werden Indizes und eindeutige Eigenschaften im ormar-Feld bevorzugt.

!!!tip Um mehr über Spalteneinschränkungen für Primärschlüssel, Unique, Fremdschlüssel usw. zu erfahren, besuchen Sie Felder.

Einzigartige Kolumne

Sie können diesen Parameter setzen, indem Sie den Integritätsparameter des ormar_config-Objekts angeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have to be unique in db
        constraints=[ormar.UniqueColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!note Beachten Sie, dass Einschränkungen für Kombinationen von Spalten gelten, die eindeutig sein sollen Um eine Spalte als einzigartig zu setzen, verwenden Sie einen eindeutigen generischen Parameter Natürlich können Sie mit diesem Parameter viele Spalten als eindeutig festlegen, aber jede Spalte wird einzeln geprüft.

Indexierung.

Sie können diesen Parameter setzen, indem Sie den Integritätsparameter des ormar_config-Objekts angeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a compound index in the db
        constraints=[ormar.IndexColumns("name", "completed")],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

!!!note Beachten Sie, dass eine Einschränkung für die Kombination von Spalten, die in einem Index enthalten sein sollten Um eine Spalte zu indexieren, verwenden Sie einen eindeutigen öffentlichen Parameter Natürlich können Sie diesen Parameter verwenden, um viele Spalten als Index festzulegen, aber jede Spalte wird ein eigener Index sein.

Prüfe meinen

Sie können diesen Parameter setzen, indem Sie den Integritätsparameter des ormar_config-Objekts angeben.

 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
import datetime

import databases
import ormar
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
        # define your constraints in OrmarConfig of the model
        # it's a list that can contain multiple constraints
        # hera a combination of name and column will have a level check in the db
        constraints=[
            ormar.CheckColumns("start_time < end_time", name="date_check"),
        ],
    )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    start_date: datetime.date = ormar.Date()
    end_date: datetime.date = ormar.Date()

!!!Beachten Sie, dass einige Datenbanken Prüfeinschränkungen nicht aktiv unterstützen (z. B. MySQL).

Die Struktur der Arme

Da jedes ormar. Model auch ein pydantisches Modell ist, müssen Sie möglicherweise die Einstellungen der pydantischen Konfiguration ändern.

Die Möglichkeit, dies in pydantic zu tun, besteht darin, die Einstellungen des modellierten_config-Dictionaries anzupassen, das für ein ormar-Modell genau gleich funktioniert.

Um also Ihre eigenen Voreinstellungen festzulegen, müssen Sie dem Modell nicht nur die Klasse ormar_config, sondern auch die Klasse model_config = ConfigDict () zur Verfügung stellen.

!!!note Um mehr über die verfügbaren Einstellungen zu erfahren, besuchen Sie die Konfigurationsseite von pydantic.

Beachten Sie, dass Ormar, wenn Sie keine eigene Konfiguration angeben, die Standardkonfiguration wie folgt für Sie erledigt:

1
model_config = ConfigDict (validate_assignment = true, ser_json_bytes ="base64")(Siehe auch: configDict = true, ser_json_bytes ="base64")

Um also die Einstellung zu überschreiben oder ein eigenes Beispielmodell bereitzustellen, gehen Sie wie folgt vor:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import databases
import ormar
import pydantic
import sqlalchemy

database = databases.Database("sqlite:///db.sqlite")
metadata = sqlalchemy.MetaData()


class Course(ormar.Model):
    ormar_config = ormar.OrmarConfig(
        database=database,
        metadata=metadata,
    )

    model_config = pydantic.ConfigDict(frozen=True)

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)

Zusätzliche Punkte im Modell

Standardmäßig verhindert ormar, dass Sie zusätzliche Felder an das Modell übergeben.

Wenn Sie dies versuchen, wird ein Modelerror ausgelöst.

Da die zusätzlichen Felder nicht in der Datenbank gespeichert werden können, scheint das Standardverbot solcher Felder eine praktikable Option zu sein.

Im Gegensatz dazu ist in pydantic die Standardoption, zusätzliche Felder wie diese zu ignorieren, sodass ormar die Einstellung ormar_config. extra bereitstellt, die auf die gleiche Weise ausgeführt wird.

Um zusätzliche Felder zu ignorieren, die an ormar übergeben werden, setzen Sie diese Einstellung auf Extra. ignore und nicht auf "Extra. forbid".

Bitte beachten Sie, dass ormar keine zusätzlichen Felder akzeptiert, Sie können sie nur ignorieren oder verbieten (oder eine Ausnahme auslösen, wenn sie vorhanden ist).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from ormar import Extra, OrmarConfig (englisch)

Klasse Kind (ormar. -Modell):
    Die Datei "Config"(
        tablename ="Kinder"
        extra = Extra. ignore #set zusätzliche Einstellung, um Ausnahmen in einer zusätzlichen Fields-Präsenz zu verhindern
    )

    id: int = ormar. Integer (name ="child_id", primary_key = true) oder
    first_name: str = ormar. String (name ="fname", max_length = 100)(Vorname)
    last_name: str = ormar. String (name ="lname", max_length = 100)(letzter_name: str = ormar. String (name ="lname", max_length = 100))

Um die gleichen Einstellungen für alle Modelle festzulegen, überprüfen Sie die Best Practices und das Konzept base_ormar_config.

Modellordnung.

Wenn Sie eine Datenbank mit einem bestimmten Modell abfragen, wird das Modell standardmäßig nach der Spalte Primary_key sortiert, wenn Sie das Standardverhalten ändern möchten, indem Sie dem Modell oder dem mar_config-Objekt den Parameter orders_by bereitstellen.

Beispiel für die Standardsortierung (nicht angegeben-daher durch den Primärschlüssel angegeben):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    Datenbank = Datenbank. Datenbank (DATABASE_URL),
    metadata = sqlalchemy. metadata (), oder
)


#default sort by column id ascending (Standardeinstellung für den Versand durch column id ascending)
Klasse Autor (ormar. Modell):
    Die Datei Datei Datei Datei: Config_Config_Config (
        tabName ="Autor" oder
    )

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

Geändert wurde

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    Datenbank = Datenbank. Datenbank (DATABASE_URL),
    metadata = sqlalchemy. metadata (), oder
)

#Jetzt default sort by name descending
Klasse Autor (ormar. Modell):
    Die Datei Datei Datei Datei: Config_Config_Config (
        orders_by =["Vorname"],
        tabName ="Autor" oder
    )

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

Modell Initialisierung

Es gibt zwei Möglichkeiten zum Erstellen und Speichern von Modellinstanzen in einer Datenbank .

Wenn Sie die Instance ändern möchten , während das Programm später ausgeführt wird , können Sie das Modell als normale Klasse starten und auf den Aufruf von save () warten .

 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
import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

Wenn Sie das Modell starten und gleichzeitig in der Datenbank speichern möchten , verwenden Sie die QuerySet-Methode create () .

Um mehrere Objekte gleichzeitig zu erstellen , können Sie die QuerySet-Methode bulk _ create () verwenden .

Jedes Modell verfügt über eine Reihe von Abfragen , die als Objektparameter initialisiert sind

 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
import asyncio

import databases
import ormar
import sqlalchemy
from examples import create_drop_database

DATABASE_URL = "sqlite:///test.db"

ormar_base_config = ormar.OrmarConfig(
    database=databases.Database(DATABASE_URL), metadata=sqlalchemy.MetaData()
)


class Course(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="courses")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    completed: bool = ormar.Boolean(default=False)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    course = Course(name="Painting for dummies", completed=False)
    await course.save()

    await Course.objects.create(name="Painting for dummies", completed=False)


asyncio.run(run_query())

!!!info Um mehr über Abfragesätze (einschließlich Stapeloperationen) und verfügbare Methoden zu erfahren , besuchen Sie Abfragen

Modell erhalten .

Jede Modellinstanz ist ein separates Python-Objekt , das nichts über einander weiß .

1
2
3
4
5
6
7
8
track1 = await Track . objects . get (name ='The Bird') [ Bearbeiten | Quelltext bearbeiten ]
track2 = await Track . objects . get (name ='The Bird') [ Bearbeiten | Quelltext bearbeiten ]
assert track1 = = = track2 # true und

track1.name Das „ Bird2 "
Await isttrack1.save()
Assert hinzufügentrack1.name == track2.name# false
Track2 wird nicht aktualisiert und weiß nichts über Track1

Das Objekt selbst hat einen Speicherzustand , der wie folgt gesetzt wird :

  • Speichern/Aktualisieren/Laden/Aktualisieren der Einfügemethode nach dem Speichern des Modells
  • -Modell nach create/get/first/all/get_or_create/update_or_create-Methode gespeichert
  • Das Modell wird gespeichert , wenn es an bulk _ update und bulk _ create übergeben wird .
  • Speichern von Modellen nach Hinzufügen/Entfernen von mit ManyToMany verknüpften Objekten (automatisch speichern/löschen über Modellinstanzen)
  • Das Modell wird nicht gespeichert , nachdem Sie eines Ihrer eigenen Felder geändert haben (einschließlich alsModel.pkPK genannt) .
  • Das Modell wurde nach dem Hinzufügen/Entfernen von ForeignKey-Objekten nicht gespeichert (fk-Spalte nicht gespeichert)
  • speichert das Modell nicht , nachdem es mit \ _ _init _\ _ instanziiert wurde (ohne Verwendung von QuerySet . create oder vor dem Aufruf von save)

Sie können mit der Eigenschaft ModelInstance . saved überprüfen , ob ein Modell gespeichert wurde .