Zum Inhalt

Nur für Pydantische Felder

Ormar ermöglicht es Ihnen , normale pydantische Felder in ihren Modellen zu deklarieren , sodass Sie auf alle grundlegenden und benutzerdefinierten pydantischen Felder wie str , int , HttpUrl , PaymentCardNumber usw . zugreifen können .

Sie können sogar nur Felder zu verschachtelten pydantischen Modellen und nicht nur zu einzelnen Feldern deklarieren .

Da diese Felder nicht in der Datenbank gespeichert werden (und das ist der Sinn dieser Felder) , müssen Sie ihnen einen aussagekräftigen Wert geben , entweder durch Festlegen eines Standardwerts oder durch Bereitstellen eines Werts während der Initialisierung des Modells .

Wenn ormar den Wert eines pydantischen Felds nicht analysieren kann , schlägt das Laden der Daten aus der Datenbank fehl und der für das deklarierte pydantische Feld erforderliche Wert fehlt .

Im Folgenden werden die Optionen für die Bereitstellung von Werten beschrieben .

Natürlich können Sie einige oder alle von ihnen in einem Modell kombinieren .

Auswählen der Wörter

Wenn das Feld als optional festgelegt ist , wird es standardmäßig auf " Keine " gesetzt , wenn es nicht angegeben ist , und genau das geschieht beim Laden aus der Datenbank .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    metadata = sqlalchemy . metadata () , oder
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
)


Klasse Model-Test (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 = 200) [ Bearbeiten | Quelltext bearbeiten ]
    Nummer : Optional [ Zahlungskardnummer ]

test = Modelltest (name = " Test ")
Assert hinzufügentest.name= = " Prüfung "
Assert Test : Nummer ist None
test . number = " 123456789015 " für

Await sehentest.save()
test _ check = await ModelTest . objects . get () [ Bearbeiten | Quelltext bearbeiten ]

assert test _ check . name = " Test " (Prüfname = " Prüfung ")
Nach dem Laden ist es zurück zu keiner
assert test _ check . number is None (Anzahl ist keine)

Wörter mit einem anerkannten Wert

Durch Festlegen eines Standardwerts wird dieser Wert beim Initialisieren und Laden der Datenbank festgelegt Beachten Sie , dass das Festlegen des Standardwerts auf " Keine " dasselbe ist wie das Festlegen des Felds auf " optional " .

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


Klasse Modelltest (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 = 200) [ Bearbeiten | Quelltext bearbeiten ]
    url = " HttpUrl = " Benutzerhttps://www.example.com"

test = Modelltest (name = " Test ")
Assert hinzufügentest.name= = " Prüfung "
Test mit URL = = "https://www.example.com"

Die URL = "https://www.sdta.ada.pt"
Test mit URL = = "https://www.sdta.ada.pt"

Await sehentest.save()
test _ check = await ModelTest . objects . get () [ Bearbeiten | Quelltext bearbeiten ]

assert test _ check . name = " Test " (Prüfname = " Prüfung ")
Nach dem Laden ist es zurück zum Default
assert test _ check . url = = " Überprüfung .https://www.example.com"

Funktionen der Fabrik anerkennen .

Durch Festlegen der default \ _ factory-Funktion werden die Ergebnisse des Funktionsaufrufs bei der Initialisierung und bei jedem Laden der Datenbank festgelegt .

 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
from pydantic import field , Zahlungskardnummer
# ...


Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    metadata = sqlalchemy . metadata () , oder
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
)


Zitat von numbers = [
    "123456789007",
    "123456789015",
    "123456789023",
    "123456789031",
    "123456789049",
]


def get _ number () : Die Funktion
    return random . choice (CARD _ NUMBERS) Zurück


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

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 200) [ Bearbeiten | Quelltext bearbeiten ]
    # Hinweis : Sie rufen nicht die Funktion an , übergeben Sie einfach die Referenz
    PaymentCardNumber = Field (default _ factory = get _ number) (PaymentCardNumber = Feld (default _ factory = get _ number))

# Hinweis , dass Sie immer noch einen Wert liefern können
test = ModelTest2 (name = " Test2 " , number = " 400000000000000002 ")
Assert hinzufügentest.name= = " Test2 " oder
Testsieger : " 40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002 "

Await isttest.save()
test _ check = await ModelTest2.objects.get () [ Bearbeiten | Quelltext bearbeiten ]

assert test _ check . name = " Test2 " (Prüfname = " Test2 ")
Der Wert nach dem Laden ist gesetzt , um einer der CARD _ NUMBERS zu sein
assert test _ check . number in CARD _ NUMBERS (Überprüfung)
Test _ Check . number (Prüfnummer)

__Init natürlich._-

Sie können einen Wert für das Feld in der Methode \ _ _init _\ _ () vor dem Aufruf der Methode super () init 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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
von pydantic import basemodel
# ...


Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle (
    metadata = sqlalchemy . metadata () , oder
    Datenbank = Datenbank . Datenbank (DATABASE _ URL) ,
)


Klasse PydanticTest (BaseModel) :
    a : str
    von : int


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

    Bereitstellen der eigenen Init-Funktion
    def _ _ init _ _ (self , * * kwargs) :
        # add value for required field without default value (Hinzufügen eines Werts für ein erforderliches Feld ohne Standardwert)
        kwargs [ " pydantic _ test " ] = PydanticTest (aa = " random " , bb = 42)
        Denken Sie daran , Ormar anzurufen . Model Init !
        super () . _ _ init _ _ (* * kwargs) und

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

test = Test3 (name = " Test3 ") Bearbeiten
Assert hinzufügentest.name= = " Test3 " oder
Testsieger . pydantisch _test.bbGesamt = 42
test . pydantic . aa = " neuer Wert "
assert test . pydantic . aa = " Neuer Wert "

Await sehentest.save()
test _ check = await ModelTest3.objects.get () [ Bearbeiten | Quelltext bearbeiten ]

assert test _ check . name = " Prüfname " (Prüfname = " Prüfname ")
# after load it 's back to value provided in init (nach Laden des Wertes in Init)
assert test_check. pydantic_test. aa ="random"(auf Englisch)

!!!Warnung Wenn Sie keinen Wert auf eine der oben genannten Arten angeben, wird beim Laden aus der Datenbank ein ValidationError ausgelöst.