nach Ormar

[Bearbeiten] PYPI-Version (WEB//pypi.org/project/ormar) oder [Deckung] [[Datei: /codecov.io/gh/collerek/ormar]][[Bearbeiten] Codefaktor](https://www.codefactor.io/repository/github/collerek/ormar/badge) [WEB und

Zusammenfassung

Das ormar-Paket ist Pythons asynchrones ORM, das Postgres, MySQL und SQLite unterstützt.

Die wichtigsten Vorteile der Verwendung von Ormar sind:

• Erhalten Sie asynchrone ORM, die mit asynchronen Frameworks (fastapi, starlette usw.) verwendet werden können
• verwaltet nur ein Modell-Sie müssen keine Pydantic-und ORM-Modelle pflegen (sqlalchemy, peewee, gino usw.)

Das Ziel war es, einen einfachen ORM zu erstellen, der direkt mit den auf pydantic basierenden Fastapi zur Datenvalidierung (als Anfrage-und Antwortmodell) verwendet werden kann.

Ormar-mit Ausnahme des offensichtlichen „ ORM "im Namen-leitet seinen Namen vom schwedischen ormar ab, was Schlange bedeutet, und vom kroatischen ormar (e), was Kabinett bedeutet.

Gibt es einen besseren Namen für Python ORM als Snakes Cabinet?:)

Wenn Ihnen Ormar gefällt, denken Sie daran, Ihr Repository auf Github mit einem Stern zu versehen!

Je größer die Community ist, die wir aufgebaut haben, desto einfacher ist es, Fehler zu finden und Mitwirkende zu gewinnen;)

Das Archiv

Schauen Sie sich die Archive für detaillierte Informationen an.

Beachten Sie, dass aus Gründen der Kürze die meisten Dokumentationsfragmente die Erstellung und Planung der Ausführung von asynchronen Laufzeitfunktionen für Datenbanken weglassen.

Wenn Sie mehr Beispiele aus dem wirklichen Leben als in der Dokumentation wünschen, können Sie sich den Testordner ansehen, da diese tatsächlich während der meisten Tests erstellt und mit einer Datenbank verbunden werden müssen.

Denken Sie jedoch daran, dass dies nur Tests sind und nicht alle Lösungen für den Einsatz im realen Leben geeignet sind.

Teil des fastapi-Ökosystems

Als Teil des Fastapi-Ökosystems wird ormar in ausgewählten Bibliotheken unterstützt, die auf die eine oder andere Weise mit der Datenbank arbeiten.

Ormar ist immer noch unabhängig vom SQL-Dialekt-daher werden nur Spalten implementiert, die in allen unterstützten Back-Ends funktionieren.

Als Erweiterung von Ormar ist es relativ einfach, Spalten in einem bestimmten Dialekt zu implementieren.

Spaltenspezifische Postgres-Implementierung: ormar-postgres-extensions

Wenn Sie eine andere Bibliothek verwalten oder verwenden und möchten, dass sie ormar unterstützt, teilen Sie uns bitte mit, wie wir Ihnen helfen können.

Abhängigkeitsverhältnis

Ormars Aufbau besteht aus:

• Der sqlalchemy-Kern zum Erstellen von Abfragen.
• Eine Datenbank, die über die Datenbank hinweg unterstützt wird.
• Pydantic wird zur Datenüberprüfung verwendet.

Lizenzen

Ormar wurde als Open-Source-Software entwickelt und wird völlig kostenlos bleiben (MIT-Lizenz).

Wenn ich Open-Source-Code schreibe, um alltägliche Probleme bei der Arbeit zu lösen oder eine starke Python-Community zu fördern und aufzubauen, können Sie sich bedanken und mich um eine Tasse Kaffee bitten oder mich monatlich unterstützen, um sicherzustellen, dass meine Arbeit kostenlos und gepflegt bleibt.

Patenschaft

Migrieren von sqlalchemy und vorhandenen Datenbanken

Wenn Sie derzeit sqlalchemy verwenden und zu ormar wechseln möchten, sollten Sie sich das Tool für automatische Übersetzung ansehen, mit dessen Hilfe Sie vorhandene sqlalchemy orm-Modelle übersetzen können, damit Sie dies nicht manuell tun müssen.

Beta-Versionen finden Sie auf github: sqlalchemy-to-ormar oder einfach pip install sqlalchemy-to-ormar

sqlalchemy-to-ormar kann zusammen mit sqlacodegen verwendet werden, um Ormar-Modelle automatisch aus vorhandenen Datenbanken abzubilden/zu generieren, auch wenn Ihr Projekt sqlalchemy nicht verwendet.

Migration und Erstellung von Datenbanken

Da ormar auf dem SQLAlchemy-Kern basiert, können Sie alembic verwenden, um die Datenbankmigration bereitzustellen (was Sie für Produktionscode tun sollten).

Für Tests und grundlegende Anwendungen reicht sqlalchemy aus:

#Hinweis: Dies ist nur ein partieller Snippet, der vollständig funktioniert.
#1 Importieren
Import von Sqlalchemy
Importieren von Datenbanken
Der Import von Ormar

#2 Initialisierung
DATABASE_URL ="sqlite://db. sqlite"[Bearbeiten | Quelltext bearbeiten]
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    metadata = sqlalchemy. metadata (), oder
    Datenbank = Datenbank. Datenbank (DATABASE_URL),
    . create_engine = sqlalchemy (DATABASE_URL) und
)

Definieren von Modellen hier

3. Erstellung von Datenbanken und Tabellen
Startseite_Datei. metadata. create_all (engine)

Die Beispielkonfiguration von alembic und weitere Informationen zu Migrationen und Datenbankerstellung finden Sie im Abschnitt Dokumentation zur Migration.

Gekapselte Version

ormar ist noch in der Entwicklung: es wird empfohlen, Abhängigkeiten zu fixieren (d.h. ormar ~= 0.9.1)

Ormar folgt auch der Release-Nummer, die besagt, dass wichtige Änderungen die Hauptversionsnummer erhöhen, während andere Änderungen und Korrekturen die Nebenversionsnummer erhöhen, so dass Sie für letztere sicher aktualisieren können, aber achten Sie darauf, zuerst die Release-Dokumentation zu lesen example: (0.5.2 -> 0.6.0 - breaking, 0.5.2 -> 0.5.3 - non breaking).

Verwirrung mit Python

Beachten Sie, dass ormar ein asynchrones ORM ist, was bedeutet, dass Sie auf einen Aufruf der Methode warten müssen, die Sie in einer Ereignisschleife ausführen möchten Python hat ein eingebautes Modul asyncio, mit dem Sie dies tun können.

Beachten Sie, dass die meisten "normalen" Python-Interpreter das Ausführen von "wait" außerhalb einer Funktion nicht zulassen (da Sie tatsächlich planen, dass diese Funktion die Ausführung verzögert und kein sofortiges Ergebnis erhält).

In modernen Web-Frameworks wie Fastapi wird das Framework dieses Problem für Sie lösen, aber wenn Sie es selbst tun möchten, müssen Sie es manuell tun, wie in den Schnellstarts unten beschrieben.

schnellen Eintritt.

Beachten Sie, dass Sie das gleiche Skript im Beispielordner auf GitHub finden.

from typing import optional/vom Typ des optionalen Imports

Import von Datenbanken

Der Import von Ormar
Import von Sqlalchemy

DATABASE_URL ="sqlite://db. sqlite"[Bearbeiten | Quelltext bearbeiten]
Die Abbildung zeigt die Konfidenzintervalle für die Konfidenzintervalle: (
    metadata = sqlalchemy. metadata (), oder
    Datenbank = Datenbank. Datenbank (DATABASE_URL),
    . create_engine = sqlalchemy (DATABASE_URL) und
)

#note that this step is optional-"Alle Ormaan-Autos sind ein Feld mit Namen"
#ormar_config #und Parameter, aber auf diese Weise müssen Sie sie nicht wiederholen
dieselben Parameter, wenn Sie nur eine Datenbank verwenden
#
Hinweis : Alle Hints sind optional .
Below ist eine perfekte gültige Modelldeklaration
Klasse Autor (ormar . Modell) :
#     ormar _ config = base _ ormar _ config . copy (tablename = " Autoren ")
#
#     Integer (primary _ key = true) # # # notice no field types (keine Feldtypen)
#     name = ormar . String (max _ length = 100) [ Bearbeiten | Quelltext bearbeiten ]


Klasse Autor (ormar . Modell) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Autoren ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    name : str = ormar . String (max _ length = 100)


Klasse Buch (ormar . model) :
    ormar _ config = base _ ormar _ config . copy (tablename = " Bücher ")

    id : int = ormar . Integer (primary _ key = true) (nicht bekannt)
    author : Optional [ Autor ] = ormar . ForeignKey (Autor)
    title : str = ormar . String (max _ length = 100)
    Jahr : int = ormar . Integer (nullable = true)


# Erstellen der Datenbank
Hinweis : Bei der Produktion sollten Sie Migrationen verwenden
Hinweis : Dies ist nicht erforderlich , wenn Sie eine Verbindung zu einer bestehenden Datenbank herstellen
" Wir müssen nur sicher sein , bevor wir die DB sauber machen "
Startseite _ ormar _ config . metadata . drop _ all (engine)
Startseite _ Datei . metadata . create _ all (engine)


# Alle Funktionen sind in die Funktionalitätskategorien unterteilt
Wie alle Funktionen mit Async definiert sind - wie Async verwendet werden kann und benötigt wird
# Sei stolz auf dich selbst
async def create () erstellen
    Erstellen Sie einige Einträge , um mit QuerySet zu arbeiten . create method .
    Hinweis : Queryset wird auf jeder Model 's class als Objekt angegeben
    tolkien = await Autor . objects . create (name = " J.R.R. Tolkien ")
    await Book . objects . create (author = tolkien , title = " Der Hobbit " , Jahr = 1937)
    await Book . objects . create (author = tolkien , title = " Der Herr der Ringe " , year = 1955)
    await Book . objects . create (author = tolkien , title = " The Silmarillion " , Jahr = 1977)

    # Alternative Kreation von Objekten in 2 Schritten unterteilt
    sapkowski = Autor (name = " Andrzej Sapkowski ")
    # Machen Sie Stuff
    Await istsapkowski.save()

    oder Save () after initialization
    await Book (author = sapkowski , title = " The Witcher " , Jahr = 1990) . save ()
    await Book (author = sapkowski , title = " Der Turm der Narren " , year = 2002) . save ()

    Lesen Sie mehr über die Integration von Daten in die Datenbank
    # Besichtigung :https://collerek.github.io/ormar/queries/create/


async def read () : ((auf Englisch))
    # Fetch eine Instanz , ohne eine foreign key relationship auf sie zu richten .
    Der Django Stil
    book = await Book . objects . get (title = " Der Hobbit ")
    Python oder Python-Style
    book = await Book . objects . get (Book . title = = " Der Hobbit ")
    book2 = await Book . objects . first () (Buch . Objekt . erste ())

    # first () fetch the instance with lower primary key value (erste () Zahl mit niedrigerem Primärschlüsselwert)
    < ! - > Bücher = > Bücher

    Du kannst alle Felder auf das geladene Modell zugreifen
    title = = " Der Hobbit "
    assert book . year = 1937 (Jahr)

    Wenn keine Bedingung erfüllt ist ()
    # it behaves as last () based on primary key column # es behaves as last () basiert auf der Primärschlüssel-Spalte
    book3 = await Book . objects . get () = Buch erstellen . objects . get ()
    Titel : " Der Turm der Narren "

    Wenn Sie eine Beziehung haben , definiert Ormar immer ein relatives Modell für Sie
    Jeder Moment , den Sie geladen haben , ist ein ausländischer Schlüsselwert wie in diesem Beispiel
    assert isinstance (book.author , Autor) Bearbeiten
    # Primärer Schlüssel ist vom Fremdschlüssel in der Tabelle der Bücher gespeichert
    Assert hinzufügenbook.author.pk= = 1 ist
    Seit das relative Modell nicht alle anderen Felder geladen hat , sind keine
    Assert hinzufügenbook.author.nameist keines

    Laden Sie die Beziehung aus der Datenbank heraus , wenn Sie bereits ein relatives Modell haben
    # alternatively see joins section below (alternatively siehe Abschnitt unten)
    Das Buch . author . load ()
    Assert hinzufügenbook.author.name= = " J.R.R. Tolkien " = = = " J.R.R. Tolkien " oder " J.R.R. Tolkien "

    # Get all rows for given model (Alle Wege für das Geben von Modellen)
    authors = await Autor . Objekt . Alle ()
    assert len (Autoren) = 2

    Lesen Sie mehr über das Lesen von Daten aus der Datenbank
    # besuchen :https://collerek.github.io/ormar/queries/read/


async def update () () : Siehe auch :
    # Lesen Sie die aktuelle Zeile aus DB
    tolkien = await Author . objects . get (name = " J.R.R. Tolkien ")
    Assert hinzufügentolkien.name= = " J.R.R. Tolkien " = = = " J.R.R. Tolkien " oder " J.R.R. Tolkien "
    Türchen _ id =tolkien.id

    Ändern des ausgewählten Eigentums
    tolkien.name (Weitergeleitet von John Ronald Reuel Tolkien)
    Call update on a model instance (Update auf eine Modellinstanz)
    Das ist ein Witz . update ()

    Bestätigung , dass das Objekt aktualisiert wurde
    tolkien = await Author . objects . get (name = " John Ronald Reuel Tolkien ") [ Bearbeiten ]
    Assert hinzufügentolkien.name(Weitergeleitet von John Ronald Reuel Tolkien)
    Assert hinzufügentolkien.idDie _ id

    # alternatively update Daten ohne Loading
    await Author . objects . filter (name _ _ contains = " Tolkien ") . update (name = " J.R.R. Tolkien ") (Datei : J.R.R. Tolkien ")

    Lesen Sie mehr über die Aktualisierung der Datenbank .
    # besuchen :https://collerek.github.io/ormar/queries/update/


async def delete () :
    silmarillion = await Book . objects . get (Jahr = 1977)
    # call delete () auf Instanz
    await silmarillion . delete () (Englisch)

    # alternatively delete without loading # alternatively delete ohne Loading
    await Book . objects . delete (title = " Der Turm der Narren ")

    # note that when there is no record ormar raises nomatch exception # # Hinweis , wenn es keine Aufnahme gibt
    versuchen :
        await Book . objects . get (Jahr = 1977)
    Mit Ausnahme von Ormar . NoMatch :
        (" Kein Buch von 1977 ! ")

    Lesen Sie mehr über Daten aus der Datenbank
    # Besichtigung :https://collerek.github.io/ormar/queries/delete/

    # Hinweis , dass trotz der Tatsache , dass es keine Longer Exists in der Datenbank erfasst
    # Das Objekt oben ist immer noch akzeptabel und Sie können es verwenden (und ich . e . speichern)) wieder .
    Tolkiensilmarillion.author
    await Book . objects . create (author = tolkien , title = " The Silmarillion " , Jahr = 1977)


async def joins () (Hinzufügen) :
    # Sie verbinden zwei Modelle mit select _ related

    Der Django Stil
    Beschreibung = AwaitBook.objects.select_ related (" Autor ") . get (title = " Der Hobbit ")
    Der Python-Stil
    Bücher = AwaitBook.objects.selectBuchbeschreibung : (
        Titel : Der Hobbit
    )

    Der Autor ist bereits vorbereitet
    Assert hinzufügenbook.author.name= = " J.R.R. Tolkien " = = = " J.R.R. Tolkien " oder " J.R.R. Tolkien "

    Wenn Sie dies tun , erhalten Sie ebenfalls eine zweite Seite der Beziehung .
    # constructed as lowercase source model name + 's ' (Bücher in diesem Fall)
    # Sie können auch benutzerdefinierte Namen mit Parametern im Zusammenhang mit _ Namen bereitstellen

    Der Django Stil
    Benutzer = awaitAuthor.objects.select_ related (" Bücher ") . all (name = " J.R.R. Tolkien ")
    Der Python-Style
    Benutzer = awaitAuthor.objects.selectAlle Bücher (Autor , Autor)
        Author.name = = " J.R.R. Tolkien " = = = " J.R.R. Tolkien " oder " J.R.R. Tolkien "
    )
    assert len (author [ 0 ] . books) = 3 oder weniger

    # für umgekehrt und viele bis viele Beziehungen , die Sie auch voraussehen können
    Dies führt eine separate Abfrage für jedes verwandte Modell aus

    Der Django Stil
    author = await Author . objects . prefetch _ related (" Bücher ") . get (name = " J.R.R. Tolkien ") (author = await Autor . objects . prefetch _ related (" Bücher ") . get (name = " J.R.R. Tolkien ")
    Der Python-Style
    Die Seite wurde neu angelegt : " _
        Author.name = = " J.R.R. Tolkien " = = = " J.R.R. Tolkien " oder " J.R.R. Tolkien "
    )
    assert len (author . books) = 3 oder weniger

    Lesen Sie mehr über Beziehungen
    # Besichtigung :https://collerek.github.io/ormar/relations/

    Lesen Sie hier mehr über Ergänzungen und Ergänzungen
    # Besichtigung :https://collerek.github.io/ormar/queries/joins-and-subqueries/


async def filter _ und _ sort () :
    # to filter the query you can use filter () or pass key - value pars to Die Abfrage filtern , die Sie verwenden können Filter () oder pass key - Wert für
    # get () , all () und so weiter .
    # Verwenden Sie spezielle Methoden oder Zugriff auf verwandte Modellfelder mit Doppelfunktion
    # underscore like to filter by the name of the author unter Verwendung des author _ _ name
    Der Django Stil
    books = await Book . objects . all (author _ _ name = " J.R.R. Tolkien ") Bearbeiten
    Der Python Style
    Die Seite wurde neu angelegt : " Alle Objekte , alle Objekte , alle Objekte " (Book.author.name= = " J.R.R. Tolkien " (= = " J.R.R. Tolkien ")
    Anzahl der Bücher (= 3)

    # filter kann auch spezielle Methoden mit doppeltem Underscore trennen
    SQL Query ` where authors.name like "%tolkien%"` ist nicht
    Case Sensitive (kleiner Fehler in Tolkien)
    Der Django Stil
    books = await Book . objects . filter (author _ _ name _ _ icontains = " tolkien ") . all () ()
    Der Python Style
    books = await Book . objects . filter (Book . author . name . icontains (" tolkien ")) . all ()
    Anzahl der Bücher (= 3)

    Sortieren der Reihenfolge _ by () Funktion des Queryset
    #
    Wie mit einem Filter können Sie doppelte Underscores verwenden , um verwandte Felder zu erreichen
    Der Django Stil
    Bücher : (
        await Book . objects . filter (author _ _ name _ _ icontains = " tolkien ") (Deutsch)
        ORDER _ BY (" - Jahr ")
        Das All ()
    )
    Der Python Style
    Bücher (
        await Book . objects . filter (Book . author . name . icontains (" Tolkien ")) Bearbeiten
        ORDER _ BY (Buch . Jahr . desc ()))
        Das All ()
    )
    Anzahl der Bücher (= 3)
    assert books [ 0 ] . title = = " Die Silmarillion "
    [ 2 ] . title = = " Der Hobbit "

    Lesen Sie hier mehr über das Filtern und Arbeiten
    # besuchen :https://collerek.github.io/ormar/queries/filter-and-sort/


async def subset _ of _ columns ()
    Einige Spalten beim Abfragen der Datenbank auslesen
    Sie können die Methode Fileds () verwenden .
    Hobbit = await Book . objects . fields ([ " title " ]) . get (title = " The Hobbit ") [ Bearbeiten | Quelltext bearbeiten ]
    " Fields not included in Fields are empty " (" Es ist kein Platz ")
    assert hobbit - Jahr ist None
    Assert hinzufügenhobbit.authorist keines

    Das ausgewählte Feld ist dort
    Der Hobbit title = = " Der Hobbit "

    # alternatively you can provide columns you want to exclude # alternatively you can provide columns you want to exclude
    hobbit = await Book . objects . exclude _ fields ([ " Jahr " ]) . get (title = " Der Hobbit ")
    Das Jahr ist noch nicht gesetzt
    assert hobbit - Jahr ist None
    Der Autor ist zurück
    Assert hinzufügenhobbit.authorist nicht keiner

    Daher können Sie den Primärschlüssel nicht aus der Spalte entfernen - es ist immer da
    # auch wenn du es ausdrücklich schließt , wird es da sein

    # note , dass jedes Modell einen Shortcut für den Primärschlüssel column hat , der PK ist
    # and you can filter/access/set the values by this alias like below/
    Assert hinzufügenhobbit.pkist nicht keiner

    # Hinweis , dass Sie Fields , die nicht Nullbar sind , nicht ausschliessen können
    # (erforderlich) In der Modelldefinition
    versuchen :
        await Book . objects . exclude _ fields ([ " title " ]) . get (title = " Der Hobbit ")
    Mit Ausnahme von Pydantic . ValidationError :
        print (" Kann nicht Null-Feld - Titel ")

    Lesen Sie mehr über die Auswahl der Felder
    # besuchen :https://collerek.github.io/ormar/queries/select-columns/


async def pagination () : def pagination () für :
    Begrenzung der Anzahl der zurückgegebenen Straßen mit Limit ()
    books = await Book . objects . limit (1) . all () () () [ Bearbeiten | Quelltext bearbeiten ]
    assert len (Bücher) = 1
    [ 0 ] . title = = " Der Hobbit "

    # to offset number of returned rows use offset () Anzahl der zurückgegebenen Rows unter Verwendung von Offset ()
    books = await Book . objects . limit (1) . offset (1) . all () oder ()
    assert len (bücher) = 1
    Titel = = " Der Herr der Ringe "

    # alternatively use paginate that combines both (alternativlos verwenden , das beide verbindet)
    books = await Book . objects . paginate (page = 2 , page _ size = 2) . all ()
    assert len (bücher) = 2
    # note that we removed one book of Sapkowski in delete (Wir haben ein Buch von Sapkowski entfernt)
    # and recreated The Silmarillion - by default when no order _ by is set (" Das Silmarillion - von default , wenn keine Reihenfolge _ by gesetzt ist ")
    Sortieren von primären _ key column
    assert books [ 0 ] . title = = " The Witcher " (" Die Hexe ")
    assert books [ 1 ] . title = = " Die Silmarillion "

    Lesen Sie mehr über die Reise und die Anzahl der Straßen
    # besuchen :https://collerek.github.io/ormar/queries/pagination-and-rows-number/


async def aggregationen () :
    Der Count :
    assert2 = = await Author . objects . count () () ist ein Objekt .

    # existieren
    assert await Book . objects . filter (title = " Der Hobbit ") . exists ()

    # Höchstleistung
    assert1990 = = await Book . objects . max (columns = [ " year " ]) [ Bearbeiten | Quelltext bearbeiten ]

    # Mindestmaße
    assert1937 = = await Book . objects . min (columns = [ " year " ]) [ Bearbeiten | Quelltext bearbeiten ]

    # durchschnittlich
    assert1964.75 = = await Book . objects . avg (columns = [ " year " ]) [ Bearbeiten | Quelltext bearbeiten ]

    # sum
    assert7859 = = await Book . objects . sum (columns = [ " year " ]) [ Bearbeiten | Quelltext bearbeiten ]

    Lesen Sie mehr über Aggregat-Funktionen
    # Besichtigung :https://collerek.github.io/ormar/queries/aggregations/


async def raw _ data () () () () : () für raw _ data ()
    Extract raw data in a form of dicts or tuples (Extrakte Daten in einer Form von Dikten oder Mustern)
    Diese Tipps sind gültig (!) als Modelle
    # nicht aus parsed-daten erstellt

    # get list of objects as dicts (Liste von Objekten als Objekte erstellen)
    assert await Book . objects . values () = [ Bearbeiten | Quelltext bearbeiten ]
        {"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},
    ]

    # get list of objects as tuples (Liste von Objekten als Objekte)
    assert await Book . objects . values _ list () = = [ Bearbeiten | Quelltext bearbeiten ]
        (1 , 1937 , Der Hobbit)
        (2 , 1 , " Der Herr der Ringe " , 1955)
        (4 , 2 , Der Witcher , 1990)
        (5 , 1 , Das Silmarillion , 1977)
    ]

    # filter Daten - Notiz , wie Sie immer eine Liste bekommen
    assert await Book . objects . filter (title = " Der Hobbit ") . values () = = [
        {"id": 1, "author": 1, "title": "The Hobbit", "year": 1937}
    ]

    Wählen Sie nur gewünschte Felder aus
    assert await Book . objects . filter (title = " Der Hobbit ") . values ([ " id " , " title " ]) = [
        {"id": 1, "title": "The Hobbit"}
    ]

    # if you select only one column you could flatten it with values _ list Wenn Sie nur eine Spalte auswählen , die Sie mit Werten füllen könnten
    assert await Book . objects . values _ list (" title " , flatten = true) = = [ [
        „ Der Hobbit "
        Der Herr der Ringe
        Der „ Witcher "
        „ Das Silmarillion "
    ]

    Lesen Sie mehr über Extracting Raw Values
    # Besichtigung :https://collerek.github.io/ormar/queries/aggregations/


async def mit _ connect (function) :
    # Hinweis , dass für einen anderen Hintergrund als genau das , was Sie wirklich brauchen
    Verbinden Sie die Datenbank mit den DB-Operationen
    async mit der Datenbank :
        Die Funktion ist ()

    Wenn Sie ein Framework wie `fastapi` verwenden , sollten Sie keine Verbindung herstellen
    In Ihren Endpunkten , aber mit einem globalen Verbindungspool
    # Prüfenhttps://collerek.github.io/ormar/fastapi/and section mit DB-Verbindung


# Alle Funktionen ausführen
Normalerweise sollte der Import am Anfang der Datei erfolgen .
Import aus Asyncio

Normalerweise verwenden Sie gather () - Funktion , um mehrere Funktionen auszuführen
concurrently but we actually modify the data and we rely on the order of functions Wir ändern tatsächlich die Daten und wir beziehen uns auf die Reihenfolge der Funktionen
function im [
    erschaffen ,
    Weiterlesen ,
    Aktualisierung ,
    löschen ,
    Joins ,
    filter und _ sort
    subset _ of _ columns (von _ columns)
    Die Vagina ,
    Die Aggregation ,
    raw _ daten ,
]:
    print (f) Ausführung: {func.__name__}")
    asyncio.run(with_ connect (Funktion)

Löschen der Tabellen der Datenbank
metadata . drop _ all (englisch)

Besonderheiten von Omar

Fragen zu Sammelmethoden

• Erzeugen (**kwargs) : - > Modell
• 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
• vorhanden () - > boolesche Werte
• 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])

Relationship Typen

• One-to - Multi-mit ForeignKey (to : Model)
• Mehr zu - mit ManyToMany(to: Model, Optional[through]: Model)

Das Modell des Typs

Verfügbare Modellfelder (mit erforderlichen Parametern - optionale Parameter in der Dokumentation) :

• String (maximale Länge)
• Der Text ()
• Der Wert ()
• Ganzzahl ()
• Floß ()
• Das Datum ()
• Zeit ()
• Datum Zeit ()
• JSON()
• große Zahl ()
• kleine Zahl ()
• Kleine Zahlen (Anzahl, Genauigkeit)
• UUID()
• 2 (maximale Länge)
• Aufzählungen (Kategorien)
• Eine Enumeration ähnlich einem Feld-durch Übergeben der Auswahl an einen anderen Feldtyp
• EncryptedString-durch übergeben encrypt_secret und encrypt_backend
• Fremdschlüssel (bis)
• Je mehr (bis)

Auswahl der Wörter möglich

Alle Feldtypen unterstützen die folgenden Schlüsselwortparameter.

• Primärschlüssel: Boolescher Wert
• verfügbar: boolescher Wert
• Standardwert: Any
• Standardwert des Servers: Any
• Index: Boolescher Wert
• Einzige Ausnahme: Burr.
• Bezeichnung: str

Sofern nicht eines der folgenden Felder gesetzt ist, sind alle Felder erforderlich:

• nullable-Erstellen Sie eine Spalte, die leer sein kann Standardwert auf False für Details lesen Sie Allgemeine Feldparameter.
• sql_nullable-Verwenden Sie verschiedene Einstellungen für pydantic und die Datenbank, um den Standardwert auf einen Wert zu setzen, der leer sein kann Weitere Informationen finden Sie unter Allgemeine Feldparameter.
• Standard - Festlegen der Standardwerte für das Feld " Beziehungen " gilt nicht für das Feld " Beziehungen " .
• server _ default - Legt die Standardwerte für serverseitige Felder fest (z.B. für sqlalchemy)func.now(1) Gilt nicht für den Zusammenhang zwischen Wörtern .
• Primärschlüssel mit Auto-Increment - Wenn eine Spalte als Primärschlüssel festgelegt ist und automatische Inkremente auf dieser Spalte festgelegt sind , wird standardmäßig der Primärschlüssel von int auf Auto-Increment gesetzt .

Signal zur Verfügung .

Signale ermöglichen das Auslösen Ihrer Funktion für ein bestimmtes Ereignis in einem bestimmten Modell .

• Pre-Erhaltung
• Nach der Erhaltung
• Vorschau aktualisiert
• Nach dem Update
• Pre-Streichung
• Nach der Streichung
• Vorher-Beziehung hinzufügen
• Post-Beziehung hinzufügen
• Vorhersage-Beziehung abgeschafft
• Nach Beendigung der Beziehung