Ormar

[! Pypi versie ] (https://pypi.org/project/ormar) ! [Dekking] ] (https://codecov.io/gh/collerek/ormar)! [CodeFactor] ] (https://www.codefactor.io/repository/github/collerek/ormar)

overzicht

Het Ormar-pakket is een asynchrone ORM voor Python die Postgres, MySQL en SQLite ondersteunt.

De belangrijkste voordelen van het gebruik van ormar zijn:

• Koop een asynchrone ORM die kan worden gebruikt met asynchrone frameworks (fastapi, starlette, etc.)
• hoeft maar één model te onderhouden - u hoeft geen pydantische en andere orm-modellen te onderhouden (sqlalchemy, peewee, gino, etc.)

Het doel is om een eenvoudige ORM te maken die rechtstreeks kan worden gebruikt met op Pydantic gebaseerde FastAPI voor gegevensvalidatie (als verzoek- en antwoordmodel).

Ormar - afgezien van de voor de hand liggende "ORM" in zijn naam - ontleent zijn naam aan de Zweedse ormar, wat slang betekent, en de Kroatische ormar (e), wat kabinet betekent.

Wat is voor Python ORM een betere naam dan Snakes Cabinet?

Als je van ormar houdt, vergeet dan niet om de repository in GitHub te spelen!

Hoe groter de community die we bouwen, hoe gemakkelijker het zal zijn om bugs op te sporen en bijdragers aan te trekken.

Document

Raadpleeg de documentatie voor details.

Houd er rekening mee dat kortheidshalve de meeste documentatiefragmenten het aanmaken van de database en het uitvoeren van de geplande asynchrone actieve functies weglaten.

Als u meer praktijkvoorbeelden wilt dan in de documentatie, kunt u de testmappen bekijken omdat ze in de meeste tests daadwerkelijk moeten worden gemaakt en verbonden met de database.

Maar houd er rekening mee dat dit slechts tests zijn en dat niet alle oplossingen geschikt zijn voor real-life gebruik.

Onderdeel van het FastAPI ecosysteem

Als onderdeel van het FastAPI-ecosysteem wordt Ormar ondersteund in geselecteerde bibliotheken die op de een of andere manier met databases werken.

Ormar is nog steeds agnostisch voor SQL-dialect - dus alleen kolommen die in alle ondersteunde backends werken, worden geïmplementeerd.

Als uitbreiding van ormar is het relatief eenvoudig om kolommen voor specifieke dialecten te implementeren.

Postgres kolomspecifieke implementatie: ormar-postgres-extensions

Als u een andere bibliotheek onderhoudt of gebruikt en wilt dat deze ormar ondersteunt, laat ons dan weten hoe we u kunnen helpen.

afhankelijkheid

De bouw van Ormar is:

• De SQL Alchemy core voor het bouwen van queries.
• Database voor asynchrone ondersteuning tussen databases.
• Pydantic wordt gebruikt voor gegevensvalidatie.

licentie

Ormar is gebouwd als open-source software en blijft volledig gratis (onder de MIT-licentie).

Wanneer ik open-sourcecode schrijf om alledaagse problemen op het werk op te lossen of om een sterke Python-gemeenschap te promoten en op te bouwen, kun je me bedanken en een kopje koffie of een maandelijkse beurs kopen om ervoor te zorgen dat mijn werk gratis en onderhouden blijft.

sponsor

Migratie vanuit sqlalchemie en bestaande databases

Als u momenteel sqlalchemy gebruikt en wilt overschakelen naar ormar, bekijk dan de automatische vertaaltool, die u kan helpen bij het vertalen van bestaande sqlalchemy orm-modellen, zodat u dit niet handmatig hoeft te doen.

Bètaversies zijn te vinden op github: sqlalchemistry-to-ormar of gewoon pip install sqlalchemy-to-ormar

Sqlalchemy-to-ormar kan worden gebruikt met sqlacodegen om automatisch ormar-modellen uit bestaande databases in kaart te brengen / genereren, zelfs als uw project geen sqlalchemy gebruikt.

Migratie en database aanmaken

Omdat ormar is gebouwd op SQL Alchemy-kern, kunt u alembic gebruiken om databasemigratie te bieden (wat u eigenlijk zou moeten doen voor productiecode).

Voor testen en basistoepassingen is sqlalchemie voldoende.

# opmerking dit is slechts een gedeeltelijk fragment volledig werkend voorbeeld hieronder
# 1. Invoer
Sqlalchemie invoeren
Databanken importeren
Ormar importeren

# 2. Initialisatie
DATABASE _ URL = "deel: / / db.sqlite"
basis _ ormar _ config = ormar. OrmarConfig (
    Metadata = sqlalchemie. MetaData (),
    Database = databanken. Database (DATABASE _ URL),
    Engine = sqlalchemy.create _ engine (DATABASE _ URL);
)

Definieer hier modellen

# 3. Database aanmaken en tabellen aanmaken
basis _ ormar _ config metagegevens create _ all (engine)

Ga naar de sectie migratiedocumentatie voor voorbeeldconfiguratie van alembic en meer informatie over migratie en het maken van databases.

verpakte versie

Ormar is nog in ontwikkeling: we raden aan om eventuele afhankelijkheden te repareren (d.w.z. ormar ~ = 0.9.1)

Ormar volgt ook de releasenummering, d.w.z. grote wijzigingen verhogen het grote versienummer, terwijl andere wijzigingen en fixes het kleine versienummer verhogen, dus voor de laatste moet u veilig zijn om te updaten, maar zorg ervoor dat u eerst de releasedocumentatie leest.example: (0.5.2 -> 0.6.0 - breaking, 0.5.2 -> 0.5.3 - non breaking).

Asynchrone Python

Houd er rekening mee dat ormar een asynchrone ORM is, wat betekent dat u moet wachten op een aanroep van een methode die is gepland om uit te voeren in de gebeurtenislus. Python heeft een ingebouwde module, asyncio, waarmee u dit kunt doen.

Houd er rekening mee dat de meeste "normale" Python-tolken niet toestaan dat wachten buiten een functie wordt uitgevoerd (omdat u deze functie eigenlijk plant om de uitvoering uit te stellen en geen onmiddellijk resultaat krijgt).

In moderne webframeworks zoals FastAPI zal het framework dit voor u afhandelen, maar als u van plan bent dit zelf te doen, moet u dit handmatig doen, zoals beschreven in de quickstart hieronder.

Snel aan de slag

Houd er rekening mee dat je hetzelfde script kunt vinden in de voorbeeldmap op GitHub.

Optioneel importeren vanuit typen

Databanken importeren

Ormar importeren
Sqlalchemie invoeren

DATABASE _ URL = "deel: / / db.sqlite"
basis _ ormar _ config = ormar. OrmarConfig (
    Metadata = sqlalchemie. MetaData (),
    Database = databanken. Database (DATABASE _ URL),
    Engine = sqlalchemy.create _ engine (DATABASE _ URL);
)

# let op dat deze stap optioneel is - > alle ormar cares is een veld met naam
# ormar _ config # en de juiste parameters, maar op deze manier hoef je niet te herhalen
# dezelfde parameters als u slechts één database gebruikt
#
# Merk op dat alle typehints optioneel zijn
# hieronder is een perfect geldige modelverklaring
# klasse Auteur (ormar. Model):
# ormar _ config = base _ ormar _ config (tabelnaam = "auteurs")
#
# id = ormar. Integer (primary _ key = True) # < = geen tice geen veldtypen
# naam = ormar. String (max _ lengte = 100)


Klasse Auteur (ormar. Model):
    ormar _ config = base _ ormar _ config (tabelnaam = "auteurs")

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


Klassenboek (ormar. Model):
    ormar _ config = basis _ ormar _ config (tabelnaam = "boeken")

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Auteur: Optioneel [Auteur] = ormar. ForeignKey (Auteur)
    Titel: str = ormar. String (max _ length = 100)
    Jaar: int = ormar. Geheel (nullable = Waar)


# database aanmaken
# let op dat je in productie migraties moet gebruiken
# Merk op dat dit niet vereist is als u verbinding maakt met een bestaande database
# voor de zekerheid hebben we de db eerder gewist
basis _ ormar _ config metadata drop _ all (motor)
basis _ ormar _ config metagegevens create _ all (engine)


# alle onderstaande functies zijn onderverdeeld in functiecategorieën
# let op hoe alle functies zijn gedefinieerd met asynchroon - vandaar kan gebruiken wachten EN moet
# worden alleen verwacht
Aync maakt ():
    # Maak enkele records om mee te werken via de QuerySet.create-methode.
    # Merk op dat de queryset wordt weergegeven in de klasse van elk model als objecten
    Tolkien = await Author.objects.create (naam = "J.R.R. Tolkien")
    In afwachting van Book.objects.create (auteur = tolkien, title = "The Hobbit", jaar = 1937)
    In afwachting van Book.objects.create (auteur = tolkien, title = "De Heer van de Ringen", jaar = 1955)
    In afwachting van Book.objects.create (auteur = tolkien, title = "De Silmarillion", jaar = 1977)

    # alternatieve creatie van objecten verdeeld in 2 stappen
    Sapkowski = Auteur (naam = "Andrzej Sapkowski")
    # doe wat dingen
    sapkowski.save ()

    # of opslaan () na initialisatie
    In afwachting van boek (auteur = sapkowski, title = "The Witcher", jaar = 1990). save ()
    Await Book (auteur = sapkowski, title = "De toren van dwazen", jaar = 2002). save ()

    # om meer te lezen over het invoegen van gegevens in de database
    # bezoek: https://collerek.github.io/ormar/queries/create/


Aync zeker gelezen ():
    # Haal een instantie op, zonder er een relatie met een vreemde sleutel op te laden.
    # Django-stijl
    Boek = afwachten Book.objects.get (title = "De Hobbit")
    # of python-stijl
    Boek = wacht op Book.objects.get (Book.title = = "De Hobbit")
    Book2 = wacht op Book.objects.first ()

    # first () haalt de instantie op met een lagere primaire sleutelwaarde
    Assert boek = = boek2

    # u heeft toegang tot alle velden op geladen modellen
    Bevestig boek.title = = "De Hobbit"
    Beweren boek.jaar = = 1937

    # wanneer er geen voorwaarde is vervuld om te krijgen ()
    # het gedraagt zich als laatste () op basis van de primaire sleutelkolom
    Book3 = wacht op Book.objects.get ()
    Bewerend boek3.title = = "De toren van dwazen"

    # Als je een relatie hebt, definieert ormar altijd een gerelateerd model voor jou
    # zelfs als alles wat je hebt geladen een buitenlandse sleutelwaarde is, zoals in dit voorbeeld
    Beweren isinstance (book.author, Auteur)
    # primaire sleutel wordt ingevuld vanuit buitenlandse sleutel opgeslagen in boekentabel
    Beweren book.author.pk = = 1
    # aangezien het gerelateerde model niet is geladen, zijn alle andere velden Geen
    Beweren book.author.name is Geen

    # Laad de relatie uit de database als je het gerelateerde model al hebt
    # alternatief zie de join sectie hieronder
    book.author ()
    book.author.name = = "J.R.R. Tolkien"

    # krijg alle rijen voor gegeven model
    Auteurs = wachten Auteur.objects.all ()
    Assert len (auteurs) = = 2

    # om meer te lezen over het lezen van gegevens uit de database
    # bezoek: https://collerek.github.io/ormar/queries/read/


Aync def update ():
    # bestaande rijen uit db lezen
    Tolkien = await Auteur.objects.get (naam = "J.R.R. Tolkien")
    tolkien.name = = "J.R.R. Tolkien"
    tolkien _ id = tolkien.id

    # de geselecteerde eigenschappen wijzigen
    tolkien.name = "John Ronald Reuel Tolkien"
    # oproepupdate op een modelinstantie
    In afwachting van tolkien.update ()

    # bevestigen dat het object is bijgewerkt
    Tolkien = await Auteur.objects.get (naam = "John Ronald Reuel Tolkien")
    tolkien.name = = "John Ronald Reuel Tolkien"
    Beweren tolkien.id = = tolkien _ id

    # als alternatief gegevens bijwerken zonder te laden
    Await Author.objects.filter (naam _ _ bevat = "Tolkien") .update (naam = "J.R.R. Tolkien")

    # om meer te lezen over het bijwerken van gegevens in de database
    # bezoek: https://collerek.github.io/ormar/queries/update/


Aync verwijderen ():
    Silmarillion = afwachten Book.objects.get (jaar = 1977)
    # call delete () op instantie
    In afwachting van silmarillion verwijderen ()

    # alternatief verwijderen zonder te laden
    In afwachting van Book.objects.delete (title = "De toren van dwazen")

    # Merk op dat wanneer er geen record ormar verhoogt NoMatch uitzondering
    Probeer:
        In afwachting van Book.objects.get (jaar = 1977)
    Behalve ormar.
        Print ("Geen boek uit 1977!")

    # om meer te lezen over het verwijderen van gegevens uit de database
    # bezoek: https://collerek.github.io/ormar/queries/delete/

    # merk op dat ondanks het feit dat record niet meer bestaat in database
    # het bovenstaande object is nog steeds toegankelijk en je kunt het (en i.e.save ()) opnieuw gebruiken.
    Tolkien = silmarillion.author
    In afwachting van Book.objects.create (auteur = tolkien, title = "De Silmarillion", jaar = 1977)


Async def sluit zich aan bij:
    # Doe mee met twee modellen en gebruik select _ gerelateerd

    # Django-stijl
    Boek = afwachten Book.objects.select _ gerelateerd ("auteur") .get (title = "The Hobbit")
    # Python-stijl
    Boek = wacht op Book.objects.select _ gerelateerd (Book.author) .get (
        Book.title = = "De Hobbit"
    )

    # nu is de auteur al prefetched
    book.author.name = = "J.R.R. Tolkien"

    # Standaard krijg je ook een tweede kant van de relatie
    # geconstrueerd als kleine letters bronmodel name + 's '(boeken in dit geval)
    # u kunt ook een aangepaste naam opgeven met parametergerelateerde _ naam

    # Django-stijl
    Auteur = await Auteur.objects.select _ gerelateerd ("boeken") .all (naam = "J.R.R. Tolkien")
    # Python-stijl
    Auteur = await Auteur.objects.select _ gerelateerd (Auteur.books) .all (
        Author.name = = "J.R.R. Tolkien"
    )
    Stel len (auteur [0] .books) = = 3

    # voor reverse en veel tot veel relaties kun je ook prefetch _ gerelateerd
    # dat een afzonderlijke query uitvoert voor elk van de gerelateerde modellen

    # Django-stijl
    Auteur = await Auteur.objects.prefetch _ gerelateerd ("boeken") .get (naam = "J.R.R. Tolkien")
    # Python-stijl
    Auteur = await Auteur.objects.prefetch _ gerelateerd (Auteur.books) .get (
        Author.name = = "J.R.R. Tolkien"
    )
    Stel len (auteurboeken) = = 3

    # om meer te lezen over relaties
    # bezoek: https://collerek.github.io/ormar/relations/

    # om meer te lezen over join en subqueries
    # bezoek: https://collerek.github.io/ormar/queries/joins-and-subqueries/


Async def filter _ en _ sorteren ():
    # om de query te filteren kun je filter () gebruiken of key-value pars doorgeven aan
    # krijgen (), alle () enz.
    # om speciale methoden te gebruiken of toegang te krijgen tot gerelateerde modelvelden met behulp van dubbele
    # onderstrepingsteken filteren op de naam van de auteur gebruikte auteur _ _ naam
    # Django-stijl
    Boeken = wacht op Book.objects.all (auteur _ _ name = "J.R.R. Tolkien")
    # python-stijl
    Boeken = wacht op Book.objects.all (Book.author.name = = "J.R.R. Tolkien")
    Assert len (boeken) = = 3

    # filters kunnen speciale methoden accepteren, ook gescheiden met dubbele onderstrepingstekens
    # sql query ` where authors.name like "%tolkien%"` uitgeven die niet
    # hoofdlettergevoelig (vandaar kleine t in Tolkien)
    # Django-stijl
    Boeken = wachten op Book.objects.filter (auteur _ _ naam _ _ icontains = "tolkien") .all ()
    # python-stijl
    Boeken = wacht op Book.objects.filter (Book.author.name icontains ("tolkien")) .all ()
    Assert len (boeken) = = 3

    # sorteren gebruik order _ by () functie van queryset
    # aflopend sorteren met koppelteken voor de veldnaam
    # hetzelfde als met filter kunt u dubbele onderstrepingstekens gebruiken om toegang te krijgen tot gerelateerde velden
    # Django-stijl
    Boeken = (
        Await Book.objects.filter (auteur _ _ naam _ _ icontains = "tolkien")
        . order _ by ("-jaar")
        . Alle ()
    )
    # python-stijl
    Boeken = (
        Await Book.objects.filter (Book.author.name icontains ("tolkien"))
        bestellen _ door (Book.year.desc ())
        . Alle ()
    )
    Assert len (boeken) = = 3
    Beweerde boeken [0]. title = = "De Silmarillion"
    Beweerde boeken [2]. title = = "De Hobbit"

    # om meer te lezen over filteren en bestellen
    # bezoek: https://collerek.github.io/ormar/queries/filter-and-sort/


Async def subset _ of _ columns ():
    # om het laden van sommige kolommen uit te sluiten bij het opvragen van de database
    # je kunt fileds () methode gebruiken
    Hobbit = afwachten Book.objects.fields (["title"]) .get (title = "De Hobbit")
    # Merk op dat velden die niet in velden zijn opgenomen leeg zijn (instellen op Geen)
    Assert hobbit. jaar is Geen
    Beweren hobbit.author is Geen

    # geselecteerde veld staat er
    Bevestig hobbit.title = = "De Hobbit"

    # als alternatief kunt u kolommen opgeven die u wilt uitsluiten
    Hobbit = afwachten Book.objects.exclude _ fields (["jaar"]) .get (title = "De Hobbit")
    # Het jaar staat nog steeds niet vast
    Assert hobbit. jaar is Geen
    # maar de auteur is terug
    Beweren hobbit.author is geen Geen

    # ook kunt u de primaire sleutelkolom niet uitsluiten - deze is er altijd
    # ook al sluit je het EXPLICIET uit het komt er te staan

    # merk op dat elk model een snelkoppeling heeft voor de primaire _ sleutelkolom die pk is
    # en u kunt de waarden filteren / openen / instellen met deze alias zoals hieronder
    Beweren hobbit.pk is geen Geen

    # let op dat u velden die niet nullable zijn niet kunt uitsluiten
    # (verplicht) in modeldefinitie
    Probeer:
        wacht op Book.objects.exclude _ fields (["title"]) .get (title = "De Hobbit")
    Behalve pydantisch. ValidatieFout:
        Afdrukken ("Kan niet-vernietigbare veldtitels niet uitsluiten")

    # om meer te lezen over het selecteren van subsets van kolommen
    # bezoek: https://collerek.github.io/ormar/queries/select-columns/


Async def paginering ():
    # om het aantal geretourneerde rijen te beperken gebruik limiet ()
    Boeken = afwachten Book.objects.limit (1) .all ()
    Assert len (boeken) = = 1
    Beweerde boeken [0]. title = = "De Hobbit"

    # om het aantal geretourneerde rijen te compenseren, gebruik offset ()
    Boeken = wachten op Book.objects.limit (1) .offset (1) .all ()
    Assert len (boeken) = = 1
    Beweerde boeken [0]. title = = "De Heer van de Ringen"

    # of gebruik paginaat dat beide combineert
    Boeken = wacht op Book.objects.paginate (pagina = 2, pagina _ size = 2) .all ()
    Assert len (boeken) = = 2
    # merk op dat we een boek van Sapkowski hebben verwijderd in delete ()
    # en The Silmarillion opnieuw gemaakt - standaard als er geen order _ by is ingesteld
    # sorteren op primaire _ sleutelkolom
    Beweerde boeken [0]. title = = "De Witcher"
    Beweerde boeken [1]. titel = = "De Silmarillion"

    # om meer te lezen over paginering en aantal rijen
    # bezoek: https://collerek.github.io/ormar/queries/pagination-and-rows-number/


Async-def-aggregaties ():
    # tellen:
    Beweren 2 = = wachten Auteur.object.count ()

    # bestaat
    Assert wacht op Book.objects.filter (title = "The Hobbit"). bestaat ()

    # maximaal
    Assert 1990 = = wacht op Book.objects.max (columns = ["jaar"])

    # minimaal
    Assert 1937 = = wacht op Book.objects.min (columns = ["jaar"])

    # gemiddeld
    Assert 1964.75 = = wacht op Book.objects.avg (columns = ["jaar"])

    # som
    Assert 7859 = = wacht op Book.objects.sum (columns = ["jaar"])

    # om meer te lezen over geaggregeerde functies
    # bezoek: https://collerek.github.io/ormar/queries/aggregations/


Async def ruwe _ data ():
    # ruwe gegevens extraheren in de vorm van dicten of tuples
    # let op dat dit de validatie overslaat (!) zoals modellen zijn
    # niet gemaakt op basis van geparseerde gegevens

    # lijst met objecten als dicts ophalen
    Wacht op Book.objects.value () = = [
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937},
        {"id": 2, "author": 1, "title": "The Lord of the Rings", "year": 1955},
        {"id": 4, "author": 2, "title": "The Witcher", "year": 1990},
        {"id": 5, "author": 1, "title": "The Silmarillion", "year": 1977},
    ]

    # lijst met objecten als tuples ophalen
    Wacht op Book.objects.value _ list () = = [
        (1, 1, "De Hobbit", 1937),
        (2, 1, "De Heer der Ringen", 1955),
        (4, 2, "De Witcher", 1990),
        (5, 1, "Het silmariljoen", 1977),
    ]

    # filterdata - let op hoe je altijd een lijst krijgt
    Wacht op Book.objects.filter (title = "De Hobbit") .waarden () = = [
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937}
    ]

    # selecteer alleen gewenste velden
    Wacht op Book.objects.filter (title = "The Hobbit") .waarden (["id", "title"]) = = [
        {"id": 1, "title": "The Hobbit"}
    ]

    # als u slechts één kolom selecteert, kunt u deze afvlakken met waarden _ lijst
    Wacht op Book.objects.value _ list ("titel", plat = Waar) = = [
        "De Hobbit",
        "De Heer van de Ringen",
        "De Witcher",
        "Het Silmariljoen",
    ]

    # om meer te lezen over het extraheren van ruwe waarden
    # bezoek: https://collerek.github.io/ormar/queries/aggregations/


Async def met _ connect (functie):
    # let op dat je voor elke andere backend dan sqlite eigenlijk
    # verbinding maken met de database om db-bewerkingen uit te voeren
    Async met database:
        Wacht functie ()

    # let op dat als je frameworks gebruikt zoals `fastapi` je geen verbinding moet maken
    # in uw endpoints maar hebben een globale verbindingspool
    # check https://collerek.github.io/ormar/fastapi/and met db aansluiting


# alle functies verzamelen en uitvoeren
# opmerking - normaal gesproken moet de invoer aan het begin van het bestand
Asyncio importeren

# Merk op dat u normaal gesproken de collect () -functie gebruikt om verschillende functies uit te voeren
# gelijktijdig, maar we wijzigen de gegevens en we vertrouwen op de volgorde van functies
Voor func in [
    Maken,
    Lezen,
    Bijwerken,
    Verwijderen,
    Voegt zich bij,
    filter _ en _ sorteren,
    subset _ van _ kolommen,
    Paginatie,
    Aggregaties,
    ruwe _ gegevens,
]:
    Afdrukken (f "Uitvoeren:{func.__name__}")
    asyncio.run (met _ connect (func))

# laat de databasetabellen vallen
drop _ all (motor)

Omar Specificaties

Query Set Methode

• creatie (**kwargs): - > model
• get(*args, **kwargs): -> Model
• get_or_none(*args, **kwargs): -> Optional[Model]
• get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]
• first(*args, **kwargs): -> Model
• update(each: bool = False, **kwargs) -> int
• update_or_create(**kwargs) -> Model
• bulk_create(objects: List[Model]) -> None
• bulk_update(objects: List[Model], columns: List[str] = None) -> None
• delete(*args, each: bool = False, **kwargs) -> int
• all(*args, **kwargs) -> List[Optional[Model]]
• iterate(*args, **kwargs) -> AsyncGenerator[Model]
• filter(*args, **kwargs) -> QuerySet
• exclude(*args, **kwargs) -> QuerySet
• select_related(related: Union[List, str]) -> QuerySet
• prefetch_related(related: Union[List, str]) -> QuerySet
• limit(limit_count: int) -> QuerySet
• offset(offset: int) -> QuerySet
• count(distinct: bool = True) -> int
• Bestaan () - > Booleaans
• max(columns: List[str]) -> Any
• min(columns: List[str]) -> Any
• avg(columns: List[str]) -> Any
• sum(columns: List[str]) -> Any
• fields(columns: Union[List, str, set, dict]) -> QuerySet
• exclude_fields(columns: Union[List, str, set, dict]) -> QuerySet
• order_by(columns:Union[List, str]) -> QuerySet
• values(fields: Union[List, str, Set, Dict])
• values_list(fields: Union[List, str, Set, Dict])

type relatie

• One-to-Many - ForeignKey gebruiken (naar: model)
• Veel te veel - met ManyToMany(to: Model, Optional[through]: Model)

Model veldtype

Beschikbare modelvelden (met vereiste parameters - optioneel in het document):

• String (maximale lengte)
• Tekst ()
• Booleaans ()
• Geheel ()
• Drijven ()
• Datum ()
• Tijd ()
• Datum Tijd ()
• JSON()
• Groot geheel getal ()
• Klein geheel getal ()
• Decimaal (aantal decimalen, nauwkeurigheid)
• UUID()
• Groot binair (maximale lengte)
• Opsomming (opsommingsklasse)
• Veldachtige opsomming - door de selectie door te geven aan een ander veldtype
• EncryptedString - geef encrypt\ _ secret door en codeer\ _ backend
• Buitenlandse sleutel (naar)
• Veel te veel (tot)

Beschikbare veldopties

Alle veldtypen ondersteunen de volgende trefwoordparameters.

• Primaire sleutel: Booleaans
• Nullable: Booleaans
• Standaardwaarde: elke
• Server Standaard: Elke
• Index: Booleaans
• Uniek: Booleaans
• Naam: str

Alle velden zijn verplicht, tenzij een van de volgende is ingesteld:

• Nullable - Maak een nullable kolom. Zet de standaard op False. Lees veld gemeenschappelijke parameters voor meer informatie.
• sql\ _ nullable - Wordt gebruikt om verschillende instellingen in te stellen voor pydantic en database. Stel de standaard in op een nullable-waarde. Lees het veld gemeenschappelijke parameter voor details.
• Standaard - Stelt de standaardwaarde in voor een veld. Niet van toepassing op relationele velden
• server\ _ default - Stelt de standaardwaarden in voor server-side velden (zoals sqlalchemy 's func.now ()). Niet van toepassing op relationele velden
• Primaire sleutel met auto-increment - Wanneer een kolom is ingesteld als een primaire sleutel en auto-increment is ingesteld op die kolom. Standaard stelt de int primaire sleutel auto-increment in.

beschikbaar signaal

Met signalen kan uw functie worden geactiveerd voor een bepaalde gebeurtenis op een bepaald model.

• vooraf opslaan
• Na het opslaan
• voorupdate
• Na bijwerking
• vooraf verwijderen
• na verwijdering
• pre-relatie toevoeging
• post relatie toevoegen
• verwijdering vóór de relatie
• Na het verwijderen van de relatie