Zum Inhalt

Filtern und Sortieren von Daten

Sie können die folgenden Methoden verwenden, um die Daten zu filtern (SQL Where-Klausel).

  • filter(*args, **kwargs) -> QuerySet

  • exclude(*args, **kwargs) -> QuerySet

  • get (*args,** kwargs)-> Beschreibung

  • get_or_none(*args, **kwargs) -> Optional[Model]

  • get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

  • all(*args, **kwargs) -> List[Optional[Model]]

  • Frage an den Gruppenleiter

    • QuerysetProxy.filter(*args, **kwargs) Die Methode
    • QuerysetProxy.exclude(*args, **kwargs) Die Methode
    • QuerysetProxy.get(*args, **kwargs) Die Methode
    • QuerysetProxy.get_or_none(*args, **kwargs) Die Methode
    • QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) Die Methode
    • QuerysetProxy.all(*args, **kwargs) Die Methode

Sortieren Sie die Daten mit der folgenden Methode (sql order by-Klausel).

  • order_by(columns:Union[List, str, OrderAction]) -> QuerySet
  • Frage an den Vereinsvertreter
    • QuerysetProxy.order_by(columns:Union[List, str, OrderAction]) Die Methode

filtert.

Auswählen

filter(*args, **kwargs) -> QuerySet

Ermöglicht Ihnen die Verwendung von Filtern für FK-Beziehungen nach beliebigen Modellattributen/-feldern sowie zum Abrufen von Instanzen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
Klasse Album (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 = 100)[Bearbeiten | Quelltext bearbeiten]
    is_best_seller: bool = ormar. Boolean (default = False)[Bearbeiten | Quelltext bearbeiten]

Klasse Track (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    Album: Optional [Album]= ormar. ForeignKey (Album) Bearbeiten
    name: str = ormar. String (max_length = 100)
    position: int = ormar. Integer () oder
    play_count: int = ormar. Integer (nullable = true)[Bearbeiten | Quelltext bearbeiten]


track = Track. objects. filter (name ="Der Vogel"). get ()
#will return a track with name equal to 'The Bird'(engl. für "Der Vogel")

tracks = Track. objects. filter (album__name ="Fantasien"). all ()
#will return all tracks where the columns album name ='Fantasie'.

Filter im Django-Stil

Sie können das spezielle Filtersuffix verwenden, um die Anzahl der Filtervorgänge zu ändern:

  • Exakt-Passt genau auf den Wert, sql Spalte = Man könnte es als Album bezeichnen._Vorname_Ausschlaggebend ist "Malibu".
  • iexact-findet SQL-Spalten genau =(Groß-und Kleinschreibung wird nicht berücksichtigt)
    • Das könnte ein Album sein._Vorname_Zitat von » Malibu «
  • enthält-sql-Spalte LIKE ' %%'* kann als Album__name__contains =' Mal 'geschrieben werden
  • icontains-sql-Spalte Like ' %%'(Groß-/Kleinschreibung wird nicht berücksichtigt)* kann als Album geschrieben werden__Vorname_Icontains ='mal 'ist
  • innerhalb von-sql column IN (<VALUE1>, <VALUE2>, ...) * kann geschrieben werden album__name__in=['Malibu', 'Barclay']
  • isnull-SQL-Spalte IS NULL (und SQL-Spalte IS NICHT NULL)
    • kann als Album__name__isnull = True geschrieben werden (isnull notalbum__name__isnull = False)

  • (größer als)* kann als position__gt = 3 geschrieben werden

  • gte-sql-Spalte>=(größer oder gleich)* kann als position__gte = 3 geschrieben werden
  • lt-sql-Spalte <(unten)* kann als position__lt = 3 geschrieben werden
  • lte-sql Zeile <= * kann geschrieben werden als position__lte = 3
  • startswith-sql Spalte LIKE '%'(exakter Start-Treffer)* kann als Album__name__startswith ='Mal' geschrieben werden
  • istartswith-sql-Spalte LIKE '%'(Groß-/Kleinschreibung wird nicht berücksichtigt)* kann als album__name__istartswith='mal' geschrieben werden
  • endswith-sql-Spalte LIKE ' %'(exakter End-Treffer)* kann als Album__name__endswith ='ibu' geschrieben werden.
  • iendswith-sql-Spalte LIKE ' %'(Groß-/Kleinschreibung wird nicht berücksichtigt)* kann als Album__name__iendswith ='IBU' geschrieben werden.

Einige Muster :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Mit sql : (product.name= ' Test ' und Produkt . rating > = 3.0)
Product . objects . filter (name ='Test', rating _ _ gte = 3.0) . get () ist ein

Mit sql : (product.name= ' Test ' und Produkt . rating > = 3.0)
#       OR (categories.name IN ('Toys', ' Books')) (für alle Kategorien)
FilternBeliebige Entfernung ab Werk : Filter (
    oder _ (
        ormar . and _ (name ='Test', rating _ _ gte = 3.0) ,
        categories _ _ name _ _ in = „ Toys " , „ Books " ])
    und Get ()
# note : to read more about and _ and or _ read complex filters section below (siehe Abschnitt unten)

Filter im Pythonstil

  • Exakt - Passt genau auf den Wert , sql Spalte =
    • geschrieben werden kann .Track.album.name= > Malibu ist
  • iexact - genau Übereinstimmung mit SQL-Spalten =(Groß - und Kleinschreibung wird nicht berücksichtigt)
    • geschrieben werden kann . Track.album.name.iexact('malibu')
  • enthält - sql-Spalte LIKE ' %%'*kann alsTrack.album.name% ' Mal') *kann als Track.album.name.contains('Mal') geschrieben werden
  • icontains - sql-Spalte LIKE ' %% ' (Groß -/Kleinschreibung wird nicht berücksichtigt) \ * kann als Track.album.name.icontains('mal') geschrieben werden
  • innerhalb von-sql column IN (<VALUE1>, <VALUE2>, ...) * geschrieben werden kann. Track.album.name << ['Malibu', 'Barclay'] * geschrieben werden kann. Track.album.name.in_(['Malibu', 'Barclay'])
  • isnull - SQL-Spalte IS NULL (und SQL-Spalte IS NOT NULL) *kann als geschrieben werdenTrack.album.name> > None *kann geschrieben werden als Track . album . name . isnull (True) *kann geschrieben werden als not null als Track.album.name.isnull(False)*not null kann geschrieben werden als~(Track.album.name > None) \ * not null kann geschrieben werden als ~(Track.album.name.isnull(True))
  • gt - sql-Spalte >(größer als) \ * kann als geschrieben werdenTrack.album.name> 3 sein
  • gte - sql Spalte > =(größer oder gleich) \ * kann als geschrieben werdenTrack.album.name> = 3 oder
  • lt - sql-Spalte <(unter) \ * kann geschrieben werden alsTrack.album.name< 3 sein
  • lte - sql Spalte < =(kleiner als gleich) \ * kann als geschrieben werdenTrack.album.name< = drei
  • startswith - sql-Spalte LIKE '% ' (exakter Startvergleich) \ * kann als Track.album.name.startswith('Mal') geschrieben werden
  • istartswith - sql Spalte LIKE '% ' (Groß -/Kleinschreibung wird nicht berücksichtigt) \ * kann als Track.album.name.istartswith('mal') geschrieben werden
  • endswith - sql Spalte LIKE ' %' (exakter Endwert) \ * kann als Track.album.name.endswith('ibu') geschrieben werden
  • iendswith - sql-Spalte LIKE ' %' (Groß -/Kleinschreibung wird nicht berücksichtigt) \ * kann als Track.album.name.iendswith('IBU') geschrieben werden

Einige Samples :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Mit sql : (product.name= ' Test ' und Produkt . rating > = 3.0)
FilternBeliebige Entfernung ab Werk : Filter (
    (Produktname = = ' Test') & (Produktrating > = 3.0) (Produktname = = ' Test')
und Get ()

Mit sql : (product.name= ' Test ' und Produkt . rating > = 3.0)
#       OR (categories.name IN ('Toys', ' Books')) (für alle Kategorien)
FilternBeliebige Entfernung ab Werk : Filter (
        (Produktname = = ' Test') & (Produktrating > = 3.0)|
        (Product.categories.name< < VARCHITÄT ' Toys ' und ' Books'])
    und Get ()

!!!Beachten Sie , dass alle Methoden , die keine Zeile zurückgeben , explizit eine Instanz von QuerySet zurückgeben , sodass Sie sie miteinander verknüpfen können .

1
2
3
Operationen wie `filter()`, `select_related()`, `limit()` und `offset()` etc. Es kann chained sein.

Etwas Ähnliches `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

!!!Warnung Beachten Sie , dass Sie in contains und anderen Filtern das % - Platzhalterzeichen nicht angeben müssen , es wird für Sie hinzugefügt , wenn Sie das % in den Suchwert einfügen , es wird maskiert und als Text-Prozentzeichen im Text behandelt .

Ausgeschlossen

exclude(*args, **kwargs) -> QuerySet

Es funktioniert genau wie ein Filter , und alle Modifikatoren (Suffixe) sind gleich , geben aber die Bedingung not zurück .

Wenn Sie also einen Filter (name ='John ') verwenden , der in SQL dem Wert where name ='John ' entspricht , dann ist except (name ='John ') äquivalent zu where name < > ' John ' .

Beachten Sie , dass alle Bedingungen miteinander verbunden sind , so dass , wenn Sie mehrere Werte übergeben , wird es die Vereinigung der Bedingung .

Ausschlüsse (name = ' John ' , age > = 35) werden geändert in where not (name='John' and age>=35)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klasse Album (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 = 100)
    is_best_seller: bool = ormar. Boolean (default = False)[Bearbeiten | Quelltext bearbeiten]

Klasse Track (ormar. Modell):
    ormar_config = base_ormar_config. copy ()(= Grundeinheit von ormar_config. copy)

    id: int = ormar. Integer (primary_key = true)(nicht bekannt)
    Album: Optional [Album]= ormar. ForeignKey (Album)[Bearbeiten | Quelltext bearbeiten]
    name: str = ormar. String (max_length = 100)[Bearbeiten | Quelltext bearbeiten]
    position: int = ormar. Integer () oder
    play_count: int = ormar. Integer (nullable = true)[Bearbeiten | Quelltext bearbeiten]


notes = await Track. objects. exclude (position_gt = 3). all ()()[Bearbeiten | Quelltext bearbeiten]
returns all tracks with position <3 zurück

Komplizierte Filter (einschließlich OR)

Standardmäßig kombinieren die Methoden filter () und except () die angegebenen Filteroptionen mit der UND-Bedingung, so dass filter(name="John", age__gt=30) in WHERE name = 'John' AND age > 30 übersetzt wird.

Manchmal ist es nützlich, eine Datenbank mit Bedingungen abzufragen, die nicht mit Anwendungen wie WHERE name = 'John' OR age > 30 kombiniert werden sollten, oder eine komplexe Where-Abfrage zu erstellen, über die Sie mehr Kontrolle haben möchten, schließlich ist WHERE (name = 'John' OR age > 30) and city='New York' völlig anders als WHERE name = 'John' OR (age > 30 and city='New York').

Zum Konstruieren von OR-und Verschachtelungsbedingungen bietet ormar zwei Funktionen, die in QuerySet und QuerysetProxy in filter () und except () verwendet werden können.

!!!Beachten Sie, dass Sie diese Methoden in jeder anderen Methode zur Akzeptanz von* args bereitstellen können, z. B. mit get () oder all ().

Aufrufe von or_und and_können entweder verschachtelt oder mit Schlüsselwortargumenten kombiniert werden, da es komplizierter klingt, als es tatsächlich ist, lassen Sie uns einige Beispiele sehen.

Um ein solches Beispielmodell zu erstellen:

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


class Autor (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 = 100)


Klasse Buch (ormar . model) :
    ormar _ config = base _ ormar _ config . copy () (= Grundeinheit von Ormar _ config . copy)

    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)

Lassen Sie uns ein paar Beispieldaten erstellen :

1
2
3
4
5
6
7
tolkien = await Author (name = " J.R.R. Tolkien ") . save ()
await Book (author = tolkien , title = " Der Hobbit " , Jahr = 1933) . save ()
await Book (author = tolkien , title = " Der Herr der Ringe " , Jahr = 1955) . save ()
await Book (author = tolkien , title = " Die Silmarillion " , Jahr = 1977) . save ()
sapkowski = await Author (name = " Andrzej Sapkowski ") . save () ist ein
await Book (author = sapkowski , title = " The Witcher " , Jahr = 1990) . save ()
await Book (author = sapkowski , title = " Der Turm der Narren " , year = 2002) . save ()

Wir können einige Beispiele erstellen komplexe Abfragen :

Lassen Sie uns Tolkiens Bücher oder Bücher wählen , die nach 1970 geschrieben wurden

Die SQL : WHERE ( authors.name = 'J.R.R. Tolkien' OR books.year > 1970 )

Der Ginger-Stil .

1
2
3
4
5
6
Bücher (
    Await istBook.objects.select_ related (" Der Autor ")
    . filter (ormar . or _ (author _ _ name = " J.R.R. Tolkien " , Jahr _ _ gt = 1970))
    Das All ()
)
assert len (Bücher) = 5

Der Python-Style

1
2
3
4
5
6
Bücher (
    Await istBook.objects.select_ related (" Der Autor ")
    . filter ((Book.author.name = = " J.R.R. Tolkien ")|(Buch des Jahres 1970))
    Das All ()
)
assert len (Bücher) = 5

Lassen Sie uns nun wählen , welche Bücher Tolkien nach 1960 oder vor 1940 geschrieben hat .

Die SQL : WHERE ( books.year > 1960 OR books.year < 1940 ) AND authors.name = 'J.R.R. Tolkien'

Der Ginger-Style .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
OPTION 1 : Split and Into Separate Call (Split und separater Anruf)
Bücher : (
    Await sehenBook.objects.select_ related (" Der Autor ")
    . filter (ormar . or _ (Jahr _ _ gt = 1960 , Jahr _ _ lt = 1940))
    . filter (author _ name = " J.R.R. Tolkien ") oder
    Das All ()
)
assert len (bücher) = 2

Option 2 - Alles in einem
Bücher (
    Await sehenBook.objects.select_ related (" Der Autor ")
    Der Filter (
        und _ (
            ormar . or _ (Jahr _ _ gt = 1960 , Jahr _ _ lt = 1940) ,
            author _ name = " J.R.R. Tolkien " , oder
        )
    )
    Das All ()
)

assert len (Bücher) = 2
[ 0 ] . title = = " Der Hobbit "
assert books [ 1 ] . title = = " Die Silmarillion "

Der Python-Style

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
Bücher (
    Await istBook.objects.select_ related (" Der Autor ")
    . filter (Buch . Jahr > 1960)|(Jahr < 1940))
    Der Filter (Book.author.name= = " J.R.R. Tolkien " (= = " J.R.R. Tolkien ")
    Das All ()
)
assert len (Bücher) = 2

Option 2 - Alles in einem
Bücher (
    Await sehenBook.objects.select_ related (" Der Autor ")
    Der Filter (
        (
            (Buch , Jahrgang 1960)|(Buch , Jahr < 1940)
        ) & (Book.author.name= = " J.R.R. Tolkien " (= = " J.R.R. Tolkien ")
    )
    Das All ()
)

assert len (bücher) = 2
[ 0 ] . title = = " Der Hobbit "
assert books [ 1 ] . title = = " Die Silmarillion "

Die Bücher von Sapkovsky vor 2000 oder Tolkien nach 1960

Die SQL : WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND authors.name = 'Andrzej Sapkowski' ) )

Der Ginger-Style .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
    Der Filter (
        oder _ (
            ormar . and _ (year _ _ gt = 1960 , author _ _ name = " J.R.R. Tolkien ") ,
            ormar . und _ (year _ _ lt = 2000 , author _ _ name = " Andrzej Sapkowski ") ,
        )
    )
    Das All ()
)
assert len (bücher) = 2

Der Python-Stil

1
2
3
4
5
6
7
8
9
Bücher (
    Await sehenBook.objects.select_ related (" Der Autor ")
    Der Filter (    
        (1960) und (Book.author.name= = " J.R.R. Tolkien ") oder|
        (Jahr 2000) & (Book.author.name= = " Andrzej Sapkowski ") oder
    )
    Das All ()
)
assert len (bücher) = 2

Natürlich können diese Funktionen mehr als zwei Bedingungen haben , also wenn wir Bücher mit " Hobbits " wollen :

Die SQL : WHERE ( ( books.year > 1960 AND authors.name = 'J.R.R. Tolkien' ) OR ( books.year < 2000 AND os0cec_authors.name = 'Andrzej Sapkowski' ) OR books.title LIKE '%hobbit%' )

Der Ginger-Stil .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
    Der Filter (
        oder _ (
            ormar . and _ (year _ _ gt = 1960 , author _ _ name = " J.R.R. Tolkien ") ,
            ormar . und _ (year _ _ lt = 2000 , author _ _ name = " Andrzej Sapkowski ") ,
            title _ _ icontains = " Hobbit " (" Hobbit ") , und
        )
    )
    Das All ()
)

Der Python-Stil

1
2
3
4
5
6
7
8
9
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
    Der Filter (    
        (1960) und (Book.author.name= = " J.R.R. Tolkien ") oder|
        (Jahr 2000) & (Book.author.name= = " Andrzej Sapkowski ") oder|
        (Bücher . title . icontains (" Hobbit "))
    )
    Das All ()
)

Wenn Sie möchten oder müssen , können Sie bei Bedarf tiefere Bedingungen verschachteln , z . B . um die folgende Abfrage zu implementieren :

Die SQL :

1
2
3
WHERE ((Bücher . Jahr > 1960 OR Bücher . Jahr < 1940)
undauthors.name= ' J.R.R. Tolkien') oder
(Bücher , Jahr < 2000 undauthors.name= ' Andrzej Sapkowski ') oder

Sie können die Abfrage wie folgt organisieren :

Der Ginger-Stil .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
Bücher (
    Await sehenBook.objects.select_ related (" Der Autor ")
    Der Filter (
        oder _ (
            und _ (
                ormar . or _ (Jahr _ _ gt = 1960 , Jahr _ _ lt = 1940) ,
                author _ name = " J.R.R. Tolkien " , oder
            ),
            ormar . und _ (year _ _ lt = 2000 , author _ _ name = " Andrzej Sapkowski ") ,
        )
    )
    Das All ()
)
Anzahl der Bücher (= 3)
[ 0 ] . title = = " Der Hobbit "
assert books [ 1 ] . title = = " Die Silmarillion "
assert books [ 2 ] . title = = " The Witcher " (Deutsche Ausgabe)

Der Python-Stil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
Bücher (
    Await istBook.objects.select_ related (" Der Autor ")
    Der Filter (        
        (
            (
            (Buch , Jahrgang 1960)|
            (Buch , Jahr < 1940)
            ) &
            (Book.author.name= = " J.R.R. Tolkien " (= = " J.R.R. Tolkien ")
        ) |
        (
            (Buch . jahr < 2000) &
            (Book.author.name= = = " Andrzej Sapkowski ") oder
        )
    )
    Das All ()
)
Anzahl der Bücher (= 3)
[ 0 ] . title = = " Der Hobbit "
assert books [ 1 ] . title = = " Die Silmarillion "
assert books [ 2 ] . title = = " The Witcher " (Deutsche Ausgabe)

Nun sollten Sie bereits wissen , wie ormar . or _und ormar . and _funktionieren Natürlich können Sie sie mit jeder anderen Methode eines Abfragesatzes verknüpfen , so dass im Beispiel eine voll funktionsfähige Abfrage wie folgt aussehen könnte :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
    . filter (ormar . or _ (Jahr _ _ gt = 1980 , Autor _ name = " Andrzej Sapkowski ")
    . filter (title _ _ startswith = " Das ")
    Das Limit (1)
    mit offset (1)
    . order _ by (" - id ") oder
    Das All ()
)
assert len (bücher) = 1
assert books [ 0 ] . title = = " The Witcher " (" Die Hexe ")

Das gleiche gilt für das Verknüpfen und Verschachteln im Python-Stil .

Der Ginger-Style .

Beachten Sie , dass Sie mit dem Django-Stil nicht mehr als einmal die gleichen Schlüsselwortparameter angeben können , daher ist die Abfrage wie folgt filter(ormar.or_(name='Jack', name='John')) nicht zulässig , wenn Sie mehrere Werte in derselben Spalte überprüfen möchten , verwenden Sie einfach den in-Operator :filter(name__in=['Jack','John']).

Wenn Sie nur einen Parameter an die Funktionen or _oder and _übergeben , wird dieser in Klammern gesetzt und hat keine Auswirkung auf die eigentliche Abfrage , sodass alle drei Abfragen gleich sind :

1
2
3
await Book . objects . filter (title ='The Hobbit') . get () ((Deutsche Übersetzung)
await Book . objects . filter (ormar . or _ (title ='The Hobbit')) . get () ((() ist die
await Book . objects . filter (ormar . und _ (title ='The Hobbit')) . get ()

!!!Note beachten oder nicht_ mit und_ Die Abfrage würde WHERE (title ='The Hobbit') enthalten, aber die Klammern sind überflüssig und haben keine praktische Wirkung.

Wenn Sie den gleichen Feldnamen zweimal verwenden müssen , können Sie dieses Feature verwenden Denken Sie daran , dass Sie nicht zweimal dasselbe Schlüsselwortargument an eine Funktion übergeben können , also wie wird WHERE (authors.name LIKE '%tolkien%') OR (authors.name LIKE '%sapkowski%')) in einem Beispiel abgefragt ?

Das können Sie nicht tun :

1
2
3
4
5
6
7
8
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
        Filter (oder (
        author _ _ name _ _ icontains = " Nachrichten " ,
        author _ _ name _ _ icontains = " sapkowski " # Sie können nicht das gleiche Schlüsselwort zweimal in oder _ !
    ))                                      Python-Syntax - Fehler
        Das All ()
)

Aber das kannst du tun :

1
2
3
4
5
6
7
8
9
Bücher (
    Await sehenBook.objects.select_ related (" Der Autor ")
        Filter (oder (
        ormar . and _ (author _ name _ _ icontains = " tolkien ") , # one argument = = just wrapped in () (nur ein Argument)
        ormar . und _ (author _ name _ _ icontains = " sapkowski ")
    ))
        Das All ()
)
assert len (bücher) = 5

Der Python-Style

Beachten Sie , dass Sie mit dem Python-Stil dieselben Felder so oft wie nötig verwenden können .

1
2
3
4
5
6
7
8
Bücher (
    Await istBook.objects.selectrelated (" Der Autor ")
        Der Filter (
        (Buch . author . name . icontains (" Geschichten "))|
        (Buch . Autor . name . icontains („ Sapkowski "))
    ))                                      
        Das All ()
)

erhalten .

get (*args , ** kwargs) - > Das Modell

Ruft die erste Zeile aus der Datenbank ab , die die kwargs-Setupbedingungen erfüllt .

Wenn irgendein args und/oder kwargs übergeben wird , ist dies eine Verknüpfung zum Aufruf von filter (*args , *\ * kwargs) . get () .

!!!tip Um mehr über Filter zu erfahren , gehen Sie zu Filtern .

1
Weitere Informationen zu `get` Go to [Read/Get](../read/#get)

erhalten oder keine

Es ist genau das gleiche wie das oben beschriebene get , aber wenn kein Datenbankdatensatz gefunden wird , der mit den Kriterien übereinstimmt , wird None zurückgegeben , anstatt eine Ausnahme auszulösen .

Erwerben oder schaffen

get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) -> Tuple[Model, bool]

Eine Kombination von Methoden erstellen und erwerben .

Wenn irgendein args und/oder kwargs übergeben wird , ist es eine Verknüpfung zum Aufruf filter(*args, **kwargs).get_or_create()

!!!tip Um mehr über Filter zu erfahren , gehen Sie zu Filtern .

1
Um mehr darüber zu lesen `get_or_create` Gehen Sie zum [read/get_or_create/schreiben](../read/#get_or_create)

!!!Warnung Wenn ein bestimmtes Element nicht vorhanden ist , müssen Sie kwargs für alle Pflichtfelder des Modells übergeben , einschließlich , aber nicht beschränkt auf die Primary \ _ key-Spalte (es sei denn , es handelt sich um ein automatisches Inkrement) .

Alles .

all(*args, **kwargs) -> List[Optional["Model"]]

Gibt für die von Ihnen festgelegten Filteroptionen alle Zeilen in der Datenbank eines bestimmten Modells zurück .

Wenn ein kwargs übergeben wird, ist es das Äquivalent zum Aufruf von filter (*args,** kwargs). all ()

!!!tip Um mehr über Filter zu erfahren, gehen Sie zu Filtern.

1
Weitere Informationen zu `all` Go to [read/all](../read/#all)

Die QuerysetProxy Methode

Wenn Sie direkt auf das zugehörige Feld ManyToMany und ReverseForeignKey zugreifen, wird eine Liste der zugehörigen Modelle zurückgegeben.

Gleichzeitig wird jedoch eine Teilmenge der QuerySet-API verfügbar gemacht, sodass Sie relevante Modelle direkt aus dem übergeordneten Modell filtern, erstellen, auswählen usw. können.

Auswählen

Genau die gleiche Filterfunktion wie oben, ermöglicht es Ihnen jedoch, verwandte Objekte vom anderen Ende der Beziehung zu filtern.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy

Ausgeschlossen

Genau wie die oben genannten Ausschlussfunktionen, aber Sie können verwandte Objekte von der anderen Seite der Beziehung filtern.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy

erhalten.

Genau das gleiche wie die get-Funktion oben, aber Sie können verwandte Objekte vom anderen Ende der Beziehung filtern.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy

erhalten oder keine

Es ist genau das gleiche wie das oben beschriebene get, aber wenn kein Datenbankdatensatz gefunden wird, der den Kriterien entspricht, wird None zurückgegeben, anstatt eine Ausnahme auszulösen.

Erwerben oder schaffen

Dies ist identisch mit der oben genannten Funktion get_or_create, ermöglicht es Ihnen jedoch, verwandte Objekte vom anderen Ende der Beziehung zu filtern.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy

Alles.

Genau wie bei allen oben genannten Funktionen, aber Sie können verwandte Objekte von der anderen Seite der Beziehung filtern.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy

Ordnung Ordnung.

Bestellung basiert.

order_by(columns: Union[List, str, OrderAction]) -> QuerySet

Mit order \ _ by () können Sie die Ergebnisse in Ihrer Datenbank nach ausgewählten Feldern sortieren .

Sie können eine Zeichenfolge mit einem Feldnamen oder eine Liste von Zeichenfolgen mit einem anderen Feld angeben .

Die Sortierung in SQL wird in der Reihenfolge der Namen angewendet , die Sie in order \ _ by angegeben haben .

!!!tip Standardmäßig , wenn Sie keine Sortierung bereitstellen oder explizit nach allen Primärschlüsseln sortieren

!!!Warnung Wenn Sie nach verschachtelten Modellen sortieren , werden die Ergebniszeilen nicht nach dem Hauptmodell sortiert , andernfalls führt mar diese Unterzeilen in einem Hauptmodell zusammen .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Sample raw database rows result (sort by child model desc) (Beispielraw-Datenbankrows Ergebnis (sort by child model desc)) :
```
MODEL: 1 - Child Model - 3
MODEL: 2 - Child Model - 2
MODEL: 1 - Child Model - 1
```

will result in 2 Folgen :
```
MODEL: 1 - Child Models: [3, 1] # encountered first in result, all children rows combined
MODEL: 2 - Child Models: [2]
```

Das Hauptmodell wird niemals duplicate in the result

Das Beispielmodell wird wie folgt präsentiert :

 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
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 Owner(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="owners")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


class Toy(ormar.Model):
    ormar_config = ormar_base_config.copy(tablename="toys")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    owner: Owner = ormar.ForeignKey(Owner)


@create_drop_database(base_config=ormar_base_config)
async def run_query():
    # build some sample data
    aphrodite = await Owner.objects.create(name="Aphrodite")
    hermes = await Owner.objects.create(name="Hermes")
    zeus = await Owner.objects.create(name="Zeus")

    await Toy.objects.create(name="Toy 4", owner=zeus)
    await Toy.objects.create(name="Toy 5", owner=hermes)
    await Toy.objects.create(name="Toy 2", owner=aphrodite)
    await Toy.objects.create(name="Toy 1", owner=zeus)
    await Toy.objects.create(name="Toy 3", owner=aphrodite)
    await Toy.objects.create(name="Toy 6", owner=hermes)


asyncio.run(run_query())

Um nach dem Hauptmodellfeld zu sortieren , müssen Sie nur den Feldnamen angeben

Der Ginger-Style .

1
2
3
4
5
6
Spiele = AwaitToy.objects.select_ related (" Eigentümer ") . order _ by (" Name ") . all ()
[ x . name . replace (" Toy " , " ") für x in toys ] = [
    str (x + 1) für x in range (6)
]
assert toys [ 0 ] . owner = Zeit
assert toys [ 1 ] . owner = = aphrodite (Eigentümer = aphrodite)

Der Python-Style

1
2
3
4
5
6
Toys = AwaitBearbeitenToy.objects.select_ related (" Eigentümer ") . order _ by (Toy . name . asc ()) . all () ()
[ x . name . replace (" Toy " , " ") für x in toys ] = [
    string (x + 1) für x in range (6)
]
assert toys [ 0 ] . owner = Zeit
assert toys [ 1 ] . owner = = aphrodite (Eigentümer = aphrodite)

Um geschachtelte Modelle zu sortieren , trennen Sie die Feldnamen durch dunder ' __' .

Auf diese Weise können Sie alle Felder des Beziehungstyps - > ForeignKey , Reverse-Virtual FK und ManyToMany sortieren .

Der Ginger-Stil .

1
2
3
4
Spiele = AwaitToy.objects.select_ related (" Eigentümer ") . order _ by (" Eigentümer _ Name ") . all ()
Spiele [ 0 ] .owner.name= = toys [ 1 ] . owner.name = = " Aphrodite " = = = " Aphrodite " = = = = [ [ Kategorie : Aphrodite ] ] und [ [ Kategorie : Aphrodite ] ]
Spiele [ 2 ]owner.name= = toys [ 3 ] . owner.name = = " Hermès " = = " Hermès " = " Hermès "
Spiele [ 4 ] .owner.name= = toys [ 5 ] . owner.name = = " Zeus "

Der Python-Style

1
2
3
4
Spiele = AwaitToy.objects.select_ related (" owner ") . order _ by (Toy . owner . name . asc ()) . all () (" Eigentümer ") . order _ by (Toy . owner . name . asc () . all (" Benutzer ")
Spiele [ 0 ] .owner.name= = toys [ 1 ] . owner.name = = " Aphrodite " = = = " Aphrodite " = = = = [ [ Kategorie : Aphrodite ] ] und [ [ Kategorie : Aphrodite ] ]
Spiele [ 2 ]owner.name= = toys [ 3 ] . owner.name = = " Hermès " = = " Hermès " = " Hermès "
Spiele [ 4 ] .owner.name= = toys [ 5 ] . owner.name = = " Zeus "

Um in absteigender Reihenfolge zu bestellen , geben Sie bitte einen Bindestrich vor dem Feldnamen ein

Der Ginger-Stil .

1
2
3
4
5
6
7
8
Eigentümer : (
    Await istOwner.objects.select_ related (" Werkzeuge ")
        . order _ by (" - toys _ _ name ") oder . order (" - toys _ _ name ")
        . filter (name = " Zeus ")
        und Get ()
)
assert owner.toys [ 0 ] . name = " Toy4 "
assert owner.toys [ 1 ] . name = " Spiel1 "

Der Python-Style

1
2
3
4
5
6
7
8
Eigentümer : (
    Await istOwner.objects.select_ related (" Werkzeuge ")
        . order _ by (Eigentümer . Tools . Name . desc ()))
        . filter (Eigentümer = " Zeus ")
        und Get ()
)
assert owner.toys [ 0 ] . name = " Toy4 "
assert owner.toys [1]. name ="Spiel1"

!!!Beachten Sie, dass alle Methoden, die keine Zeile zurückgeben, explizit eine Instanz von QuerySet zurückgeben, sodass Sie sie miteinander verknüpfen können.

1
2
3
So Operationen wie `filter()`,`select_related()`,`limit()` und `offset()` etc. können chained sein.

Etwas Ähnliches `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

Orban in Ordnung gebracht.

Da die Reihenfolge der Datenbankausführung nicht garantiert werden kann, gibt ormar für jede (partielle) Abfrage immer die order by sql-Klausel aus, auch wenn Sie die Reihenfolge nicht selbst angeben.

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 den Parameter orders_by zu ormar_config angeben.

Tipp Um mehr über die Reihenfolge der Modelle zu erfahren, besuchen Sie bitte den Modellabschnitt der Dokumentation

Standardmäßig folgen die Beziehungen der gleichen Reihenfolge, aber Sie können die Reihenfolge ändern, in der die zugeordneten Modelle während einer Abfrage geladen werden, indem Sie die Parameter orders_by und related_orders_by für die Beziehung angeben.

Tipp Um mehr über die Sortierreihenfolge des Modells zu lesen, besuchen Sie den Abschnitt Beziehungen der Dokumentation

Die Reihenfolge, in der die order_by-Klausel angewendet wird, lautet wie folgt:

  • Der Aufruf order_by () wird in einer Abfrage explizit übergeben
  • Beziehungen durch orders_by und related_orders_by, falls vorhanden
  • Das ormar_config-Objekt des Modells orders_by
  • Die Spalte primary_key des Modells ist aufsteigend (Fallback, falls keiner der oben genannten angegeben ist)

Wenden Sie Aufträge von nur einer Quelle auf jedes Modell an (damit Sie sie immer in einer einzigen Abfrage außer Kraft setzen können).

Dies bedeutet, dass, wenn Sie dem Modell in Ihrer Abfrage eine explizite Order_by geben, die Beziehung und die Modellsortierung übersprungen werden.

Wenn Sie Beziehung 1 angeben, wird die Modellsortierung übersprungen.

Wenn Sie schließlich einen für das Model angeben, wird der Standardwert von primary_key übersprungen.

Die QuerysetProxy Methode

Wenn Sie direkt auf das zugehörige Feld ManyToMany und ReverseForeignKey zugreifen, wird eine Liste der zugehörigen Modelle zurückgegeben.

Gleichzeitig wird jedoch eine Teilmenge der QuerySet-API verfügbar gemacht, sodass Sie relevante Modelle direkt aus dem übergeordneten Modell filtern, erstellen, auswählen usw. können.

Bestellung basiert.

Genau die gleiche Funktion wie die oben genannte order_by, aber ermöglicht es Ihnen, verwandte Objekte von der anderen Seite der Beziehung zu sortieren.

!!!tip Um mehr über QuerysetProxy zu erfahren, besuchen Sie den Abschnitt querysetproxy