Ga naar inhoud

Model

Definieer het model

Door een ormar-model te definiëren, kunt u het bijbehorende Pydantic-model en de Sqlalchemy-tafel gratis krijgen. Ze worden op de achtergrond beheerd en u hoeft ze niet zelf te maken.

Model klasse

Om een ormar-model te bouwen, erf je gewoon de ormar. Modelklasse.

 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)

Veld definiëren

Vervolgens worden een of meer velden toegewezen als variabelen op klassenniveau.

Type basisveld

Elke tabel moet een primaire sleutelkolom hebben, die u kunt specificeren door Primary\ _ key = True in te stellen op het geselecteerde veld.

Er is slechts één primaire sleutelkolom toegestaan.

 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)

!!!Waarschuwing, het niet toewijzen van primaire\ _ sleutelkolommen of het toewijzen van meer dan één kolom per model zal ModelDefinitionError uitzondering opleveren.

Standaard is de optie voor automatisch verhogen ingesteld op true als de primaire sleutel is toegewezen aan een geheel getal.

U kunt dit uitschakelen door autoincrement = False door te geven.

1
Id: int = ormar. Integer (primaire _ sleutel = Waar, autoincrement = Onwaar)

niet-database veld

Houd er rekening mee dat als u een normaal Pydantisch veld in uw model nodig heeft (voor het opslaan van waarden op het model of het doorgeven van bepaalde waarden), u zoals gewoonlijk een veld in Pydantic kunt definiëren.

Velden die op deze manier zijn gemaakt, worden toegevoegd aan het veld pydantic model - > dus gevalideerd op basis van het veldtype en verschijnen ook in de resultaten van model\ _ dump () en model\ _ dump\ _ json ().

Het verschil is dat deze velden niet worden opgeslagen in de database. Ze zijn dus niet opgenomen in de onderliggende SQL Alchemy-kolom of tabelvariabelen (controleer de interne sectie hieronder om te leren hoe u deze kunt openen indien nodig).

Vervolgens wordt het Pydantic-veld niet opgenomen in de migratie of databasebewerkingen zoals opslaan, bijwerken, enz.

Velden zoals deze kunnen worden doorgegeven aan de payload in het FastAPI-verzoek en worden geretourneerd in het FastAPI-antwoord (natuurlijk alleen als u hun waarde ergens in de code instelt, omdat die waarde niet uit de database is opgehaald). Als u een waarde doorgeeft in een fastapirequest en dezelfde instantie retourneert die fastapi voor u heeft gemaakt in het request\ _ model, moet u exact dezelfde waarde retourneren in het antwoord.)

!!! Waarschuwing Het pydantische veld moet altijd optioneel zijn en kan niet worden gewijzigd (anders mislukt de validatie van de databaselading).

 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)

Als u het pydantische veld instelt met standaardparameters en de werkelijke waarde niet doorgeeft in het verzoek, krijgt u altijd de standaardwaarde. Omdat het een functie kan zijn, kunt u standaard = datetime.datetime.now instellen en de huidige tijdstempel krijgen elke keer dat u het eindpunt enz. Aanroept.

Niet-database velden in FastAPI

Merk op dat zowel de pydantische als berekende\ _ velden modificatievelden kunnen worden opgenomen / uitgesloten in de model\ _ dump () en fastapi-reacties, met bijbehorende opname / uitsluiting en respons\ _ model\ _ inclusive / response\ _ model\ _ exclude.

 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
# < = = deel van gerelateerde code verwijderd voor de duidelijkheid = = >
basis _ ormar _ config = ormar. OrmarConfig (
    Database = databanken. Database (DATABASE _ URL),
    Metadata = sqlalchemie. MetaData (),
    Engine = sqlalchemy.create _ engine (DATABASE _ URL);
)


Klasse Gebruiker (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "users2")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    E-mail: str = ormar. String (max _ length = 255, nullable = False)
    Wachtwoord: str = ormar. String (max _ length = 255)
    voornaam: str = ormar. String (max _ length = 255)
    achternaam: str = ormar. String (max _ length = 255)
    Categorie: str = ormar. String (max _ length = 255, nullable = Waar)
    Tijdstempel: datetime.datetime = pydantisch. Veld (
        Standaard = datetime.datetime.now
    )

# < = = deel van gerelateerde code verwijderd voor de duidelijkheid = = >
App = SnelAPI ()

@app.post ("/ gebruikers /")
Async def create _ user (gebruiker: Gebruiker):
    Terug wachten user.save ()

# < = = deel van gerelateerde code verwijderd voor de duidelijkheid = = >

Def test _ exclusief _ velden _ in _ eindpunten ():
    Opdrachtgever = TestClient (app)
    Met cliënten als cliënten:
        Tijdstempel = datetime.datetime.now ()

        Gebruiker = {
            "E-mail": "test@domain.com",
            "Wachtwoord": "^*^% A*DA * IAAA",
            "voornaam": "John",
            "achternaam": "Doe",
            "Tijdstempel": str (tijdstempel),
        }
        Reactie = client.post ("/ users /", json = user)
        Bevestig lijst (response.json () .keys ()) = = [
            "Id",
            "e-mail",
            "voornaam",
            "achternaam",
            "Categorie",
            "Tijdstempel",
        ]
        # geretourneerd is hetzelfde tijdstempel
        Bevestig response.json () .get ("tijdstempel") = = str (tijdstempel) .vervang ("," "T")


# < = = deel van gerelateerde code verwijderd voor de duidelijkheid = = >

Veldnamen en kolomnamen

Standaardveldnamen worden gebruikt voor het onderliggende Pydantic-model en SQL Alchemy-tabellen.

Als u om een of andere reden de naam in de database wilt wijzigen maar de naam in het model wilt laten, kunt u dit doen door de naamparameter op te geven tijdens de velddeclaratie

Hier is een voorbeeld model met een veranderde naam

 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)

Houd er rekening mee dat u ook de naam van de kolom met een vreemde sleutel kunt wijzigen

 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")

Maar momenteel kunt u de ManyToMany-kolomnamen niet wijzigen omdat ze toch door andere modellen gaan.

 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)

Standaardqueryset overschrijven

Als u de query 's die Ormar uitvoert wilt aanpassen, kunt u uw eigen Query Set-klasse definiëren (met uitbreiding van Ormar QuerySet) in de Model-klasse, de standaard QuerySet.

U kunt een nieuwe klasse in de ormar\ _ config van de klasse opgeven als een queryset\ _ class-argument.

 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
Ormar importeren
Van ormar.queryset.queryset importeren QuerySet
HTTPException geïmporteerd uit fastAPI


Klasse MyQuerySetClass (QuerySet):

    Async def first _ or _ 404 (zelf, * args, * * kwargs):
        Entiteit = wacht op jezelf. get _ or _ none (* args, * * kwargs)
        Als entiteit Geen is:
            # bij fastapi of starlette
            HTTPException verhogen (404)


Klassenboek (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie (
        queryset _ class=MyQuerySetClass,
        Tablename = "boek",
    )

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


# wanneer boek niet gevonden, verhoog `404` in jouw ogen.
Boek = wacht op Book.objects.first _ or _ 404 (naam = "123")

Typ een hint

Houd er rekening mee dat u voor betere IDE-ondersteuning en mypy-controle typehints kunt geven.

 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)

Houd er rekening mee dat de typehint optioneel is, dus een volledig geldige ormatiecode kan er als volgt uitzien:

 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)

!!!Waarschuwing: zelfs als u typehints gebruikt, zal Ormar deze niet gebruiken om Pydantische velden te construeren!

1
2
Type hints zijn er alleen om statische checkers en linting te ondersteunen,
`ormar` construeert annotaties die door `pydantic` worden gebruikt vanuit eigen velden.

afhankelijkheid

Aangezien ormar vertrouwt op de database en sqlalchemistry-core voor database-join en het maken van tabellen, moet u aan elk model twee speciale parameters toewijzen.

databank

Een daarvan is een database-instantie die is gemaakt met behulp van een database-URL in sqlalchemy-verbindingsreeksindeling.

De gemaakte instantie moet ormar\ _ config-objectdatabaseparameters gebruiken die aan elk model zijn doorgegeven.

 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)

!!!Tip, u hoeft slechts één keer een database-instantie te maken en deze voor alle modellen te gebruiken. Als u meerdere databases wilt gebruiken, kunt u meerdere databases maken.

Alchemie

De tweede afhankelijkheid is de sqlalchemy MetaData-instantie.

De gemaakte instantie moet aan elk model worden doorgegeven met behulp van de metadataparameter ormar\ _ config-object.

 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)

!!!Tip, u hoeft slechts één keer een MetaData-instantie te maken en deze voor alle modellen te gebruiken. Als u meerdere databases wilt gebruiken, kunt u meerdere databases maken.

beste praktijken

Merk op dat ormar een veld vereist met de naam ormar\ _ config, wat een instantie is van de OrmarConfig-klasse. Om configuratiebeheer te vereenvoudigen, biedt de OrmarConfig-klasse replicatiemethoden. Daarom moet u een basisobject maken en er kopieën van gebruiken voor alle modellen, in plaats van steeds dezelfde parameters aan alle modellen te verstrekken.

 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)

tabel naam

Standaard worden tabelnamen gemaakt op basis van de modelklassenaam, dat wil zeggen kleine letters plus "s".

U kunt deze parameter overschrijven door de parameter tabelnaam op te geven voor het ormar\ _ config-object.

 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)

beperking

Op modelniveau kunt u ook modelgewijze beperkingen instellen voor SQL-kolommen.

Momenteel worden alleen IndexColumns, UniqueColumns en CheckColumns beperkingen ondersteund.

!!!Merk op dat u beide beperkingen alleen moet gebruiken als u een naam op een beperking wilt instellen of als u een index op meerdere kolommen wilt instellen, anders hebben de index en unieke eigenschappen op het ormaveld de voorkeur.

!!!Tip Ga naar Velden voor meer informatie over kolombeperkingen voor primaire sleutels, unieke sleutels, buitenlandse sleutels en meer.

Unieke zuil

U kunt deze parameter instellen door de parameter ormar\ _ config-objectbeperking op te geven.

 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)

!!!Merk op dat beperkingen gelden voor combinaties van kolommen die uniek moeten zijn. Om een kolom uniek te maken, gebruikt u de unieke gemeenschappelijke parameter. Natuurlijk kunt u veel kolommen uniek maken met deze parameter, maar elke kolom wordt afzonderlijk gecontroleerd.

index kolom

U kunt deze parameter instellen door de parameter ormar\ _ config-objectbeperking op te geven.

 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)

!!!Merk op dat beperkingen gelden voor de combinatie van kolommen die in de index moeten worden opgenomen. Om een index met één kolom in te stellen, gebruikt u een unieke openbare parameter. Natuurlijk kunt u deze parameter gebruiken om veel kolommen als indexen in te stellen, maar elke kolom is een afzonderlijke index.

kolom controleren

U kunt deze parameter instellen door de parameter ormar\ _ config-objectbeperking op te geven.

 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()

!!!Merk op dat sommige databases controlebeperkingen niet actief ondersteunen (bijv. MySQL).

cantilever structuur

Aangezien elke ormar. Model is ook een pydantisch model, moet u mogelijk de instellingen van uw pydantische configuratie aanpassen.

De manier om dit in pydantic te doen, is door de instellingen aan te passen in het model\ _ config-woordenboek dat aan het model wordt geleverd, wat op precies dezelfde manier w**oor ormar-modellen.

Dus om uw eigen voorkeuren in te stellen, moet u het model niet alleen met de ormar\ _ config-klasse leveren, maar ook met de klasse model\ _ config = ConfigDict ().

!!!Opmerking Ga naar de configuratiepagina van Pydantic voor meer informatie over de beschikbare instellingen.

Houd er rekening mee dat als u uw eigen configuratie niet opgeeft, ormar dit voor u zal doen. De standaard configuratie is als volgt:

1
model _ config = ConfigDict (valideren _ toewijzing = Waar, ser _ json _ bytes = "base64")

Zie er daarom als volgt uit om de instellingen te overschrijven of uw eigen voorbeeldmodel te geven:

 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)

Aanvullende velden in het model

Ormar verbiedt u standaard om extra velden door te geven aan het model.

Als u dit probeert te doen, wordt er een ModelError weergegeven.

Aangezien aanvullende velden niet in de database kunnen worden opgeslagen, lijkt het standaard uitschakelen van dergelijke velden een haalbare optie.

In plaats daarvan is in pydantic de standaardoptie om dergelijke extra velden te negeren, dus ormar biedt de ormar\ _ config extra instelling om op dezelfde manier te werken.

Om extra velden die aan ormar zijn doorgegeven te negeren, stelt u deze instelling in op Extra.ignore in plaats van de standaard Extra.forbid.

Houd er rekening mee dat ormar niet toestaat dat aanvullende velden worden geaccepteerd. U kunt ze alleen negeren of uitschakelen (gooi een uitzondering indien aanwezig).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Extra invoer uit ormar, OrmarConfig

Klasse Kind (ormar. Model):
    ormar _ config = OrmarConfig (
        Tablename = "kinderen",
        Extra = Extra.ignore # stel extra instellingen in om uitzonderingen op extra velden aanwezigheid te voorkomen
    )

    Id: int = ormar. Geheel getal (naam = "child _ id", primaire _ sleutel = Waar)
    voornaam: str = ormar. String (naam = "fname", max _ length = 100)
    achternaam: str = ormar. String (naam = "lname", max _ length = 100)

Controleer de best practices en basis\ _ ormar\ _ config-concepten om dezelfde instellingen voor alle modellen in te stellen.

Model sorteren

Bij het bevragen van een database met een bepaald model worden de modellen standaard in oplopende volgorde gesorteerd op primaire\ _ sleutelkolommen. Als u het standaardgedrag wilt wijzigen, kunt u dit doen door de orders\ _ per parameter aan het model of het mar\ _ config-object te leveren.

Standaard sorteervoorbeeld (niet gespecificeerd - dus gespecificeerd door primaire sleutel):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
basis _ ormar _ config = ormar. OrmarConfig (
    Database = databanken. Database (DATABASE _ URL),
    Metadata = sqlalchemie. MetaData (),
)


# standaard sorteren op kolom-id oplopend
Klasse Auteur (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie (
        Tablename = "auteurs",
    )

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

gewijzigd

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
basis _ ormar _ config = ormar. OrmarConfig (
    Database = databanken. Database (DATABASE _ URL),
    Metadata = sqlalchemie. MetaData (),
)

# nu standaard sorteren op naam aflopend
Klasse Auteur (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie (
        orders _ by = ["-naam"],
        Tablename = "auteurs",
    )

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

model initialisatie

Er zijn twee manieren om modelinstanties in de database te maken en op te slaan.

Als u van plan bent de instantie later te wijzigen wanneer het programma wordt uitgevoerd, kunt u het model starten als een normale klasse en wachten op de save () -aanroep.

 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())

Als u het model wilt starten en tegelijkertijd in de database wilt opslaan, gebruikt u de QuerySet methode create ().

Als u meerdere objecten tegelijk wilt maken, gebruikt u de methode bulk\ _ create () QuerySet.

Elk model heeft een set query 's die zijn geïnitialiseerd als objectparameters

 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 Ga naar Query 's voor meer informatie over querysets (inclusief bulkbewerkingen) en beschikbare methoden

model opslaan staat

Elk modelexemplaar is een afzonderlijk Python-object dat niets van elkaar weet.

1
2
3
4
5
6
7
8
Track1 = afwachten Track.objects.get (naam = 'De Vogel')
Track2 = afwachten Track.objects.get (naam = 'De Vogel')
Track1 bevestigen = = Track2 # Waar

track1.name = 'De Vogel2'
track1.save ()
Beweren track1.name = = track2.name # Onwaar
# track2 update niet en weet niks van track1

Het object zelf heeft een opgeslagen status, als volgt ingesteld:

  • Sla het model op na het opslaan / bijwerken / laden / bijwerken van de invoegmethode op het model
  • -model opgeslagen na create/get/first/all/get_or_create/update_or_create-methode
  • Modellen worden opgeslagen wanneer ze worden doorgegeven aan bulk\ _ update en bulk\ _ create
  • Sla het model op na het toevoegen / verwijderen van ManyToMany-gerelateerde objecten (automatisch opslaan / verwijderen via de modelinstantie)
  • Het model wordt niet opgeslagen na het wijzigen van een van zijn eigen velden (inclusief pk als Model.pk alias)
  • Model niet opgeslagen na het toevoegen / verwijderen van ForeignKey-gerelateerde objecten (fk-kolom niet opgeslagen)
  • gebruikt\ __init_\ _ slaat het model niet op na instantiatie (zonder QuerySet.create te gebruiken of voordat u save aanroept)

U kunt de eigenschap ModelInstant.save gebruiken om te controleren of het model is opgeslagen