Gegevens filteren en sorteren

U kunt de volgende methoden gebruiken om gegevens te filteren (SQL WHERE-clausule).

filter(*args, **kwargs) -> QuerySet
exclude(*args, **kwargs) -> QuerySet
Krijgen (*Args,*\ * kwargs) - > model
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]]
Query instellen Agent
- QuerysetProxy.filter(*args, **kwargs) werkwijze
- QuerysetProxy.exclude(*args, **kwargs) werkwijze
- QuerysetProxy.get(*args, **kwargs) werkwijze
- QuerysetProxy.get_or_none(*args, **kwargs) werkwijze
- QuerysetProxy.get_or_create(_defaults: Optional[Dict[str, Any]] = None, *args, **kwargs) werkwijze
- QuerysetProxy.all(*args, **kwargs) werkwijze

En sorteer de gegevens met behulp van de volgende methode (SQL-volgorde per clausule).

order_by(columns:Union[List, str, OrderAction]) -> QuerySet
Query instellen Agent
- QuerysetProxy.order_by(columns:Union[List, str, OrderAction]) werkwijze

filter

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

Hiermee kunt u filteren op elk modelkenmerk / veld en instanties verkrijgen met filters over FK-relaties.

Klasse Album (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    is _ best _ seller: bool = ormar. Booleaans (standaard = onwaar)

Klasse Track (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Album: Optioneel [Album] = ormar. ForeignKey (Album)
    Naam: str = ormar. String (max _ length = 100)
    Positie: int = ormar. Geheel ()
    play _ count: int = ormar. Geheel (nullable = Waar)


Track = Track.objects.filter (naam = "De vogel") .get ()
# geeft een track terug met naam gelijk aan 'The Bird'

Tracks = Track.objects.filter (album _ _ naam = "Fantasieën") .all ()
# retourneert alle nummers waar de kolommen albumnaam = 'Fantasies'

Filters in Django-stijl

U kunt een speciaal filterachtervoegsel gebruiken om de filteroperanden te wijzigen:

exact - exacte overeenkomst met waarde, sql column =\ * kan worden geschreven als album\ __name_\ _ exact = 'Malibus'
iexact - exacte overeenkomst sql kolom =
(hoofdletterongevoelig)
- kan geschreven worden als album\ __naam_\ _ iexact = 'malibus'
bevat - sql kolom LIKE '%%'\ * kan worden geschreven als album\ __naam_\ _ bevat = 'Man'
icontains - sql column LIKE '%%' (hoofdletterongevoelig)\ * kan worden geschreven als album\ __name_\ _ icontains = 'mal'
in -sql column IN (<VALUE1>, <VALUE2>, ...)\ * kan geschreven worden als album__name__in=['Malibu', 'Barclay']
Isnull - sql kolom IS NULL (en sql kolom IS NIET NULL)
- kan worden geschreven als album\ __naam__isnull = True (isnotnull album__naam_\ _ isnull = False)
gt - sql kolom >(groter dan)\ * kan worden geschreven als positie\ _\ _ gt = 3
gte - sql kolom > =(groter dan of gelijk aan)\ * kan worden geschreven als positie\ _\ _ gte = 3
lt - sql kolom <(hieronder)\ * kan worden geschreven als positie\ _\ _ lt = 3
lte - sql kolom < =(kleiner dan of gelijk aan)\ * kan worden geschreven als positie\ _\ _ lte = 3
startswith - sql column LIKE '%' (exacte start overeenkomst)\ * kan worden geschreven als album\ __name_\ _ startswith = 'Man'
istartswith - sql column LIKE '%' (hoofdletterongevoelig)\ * kan worden geschreven als album__name__istartswith='mal'
Eindigt met - sql kolom LIKE '%'(exacte eindmatch)\ * kan worden geschreven als album\ __Naam_\ _ eindigt met = 'ibus'
iendswith - sql kolom LIKE '%' (hoofdletterongevoelig)\ * kan worden geschreven als album\ __name_\ _ iendswith = 'IBU'

Enkele voorbeelden:

# sql: (product.name = 'Test' EN product.rating > = 3.0)
Product.objects.filter (naam = 'Test', waardering _ _ gte = 3.0) .get ()

# sql: (product.name = 'Test' EN product.rating > = 3.0)
# OR (categories.name IN ('Speelgoed', 'Boeken')
Product.objects.filter (
    Ormar. of _ (
        Ormar.and _ (naam = 'Test', waardering _ _ gte = 3.0),
        categorieën _ _ naam _ _ in = ['Speelgoed', 'Boeken'])
    ). krijgen ()
# opmerking: om meer te lezen over en _ en of _ lees complexe filters hieronder

Python-achtige filters

Exact - exacte overeenkomst met waarde, sql kolom =
- Kan geschreven worden als Track.album.name = = 'Malibu
iexact - exacte overeenkomst sql kolom =
(hoofdletterongevoelig)
- Kan geschreven worden als Track.album.name.iexact('malibu')
bevat - sql kolom LIKE '%%'*kan geschreven worden als Track.album.name% 'Mal')*kan geschreven worden als Track.album.name.contains('Mal')
icontains - sql kolom LIKE '%%' (hoofdletterongevoelig)\ * kan worden geschreven als Track.album.name.icontains('mal')
in -sql column IN (<VALUE1>, <VALUE2>, ...)*kan worden geschreven als Track.album.name << ['Malibu', 'Barclay']*kan worden geschreven als Track.album.name.in_(['Malibu', 'Barclay'])
isnull - sql column IS NULL (en sql column IS NOT NULL)*kan worden geschreven als Track.album.name > > Geen*kan worden geschreven als Track.album.name isnull (True)*kan worden geschreven als Niet null als Track.album.name.isnull(False)*niet null kan worden geschreven als ~ (Track.album.name > > None)\ * niet null kan worden geschreven als ~(Track.album.name.isnull(True))
gt - sql column >(groter dan)\ * kan worden geschreven als Track.album.name > 3
gte - sql column > =(groter dan of gelijk aan)\ * kan worden geschreven als Track.album.name > = 3
lt - sql kolom <(hieronder)\ * kan worden geschreven als Track.album.name < 3
lte - sql kolom < =(kleiner dan of gelijk aan)\ * kan worden geschreven als Track.album.name < = 3
startswith - sql column LIKE '%' (exacte start overeenkomst)\ * kan worden geschreven als Track.album.name.startswith('Mal')
istartswith - sql column LIKE '%' (hoofdletterongevoelig)\ * kan worden geschreven als Track.album.name.istartswith('mal')
eindigt met - sql kolom LIKE '%' (exacte eindovereenkomst)\ * kan worden geschreven als Track.album.name.endswith('ibu')
iendswith - sql kolom LIKE '%' (hoofdletterongevoelig)\ * kan worden geschreven als Track.album.name.iendswith('IBU')

Enkele voorbeelden:

# sql: (product.name = 'Test' EN product.rating > = 3.0)
Product.objects.filter (
    (Product.name = = 'Test') & (Product.rating > = 3.0)
). krijgen ()

# sql: (product.name = 'Test' EN product.rating > = 3.0)
# OR (categories.name IN ('Speelgoed', 'Boeken')
Product.objects.filter (
        ((Product.name = = 'Test') & (Product.rating > = 3.0)) |
        (Product.categories.name < < ['Speelgoed', 'Boeken'])
    ). krijgen ()

!!!Merk op dat alle methoden die geen rijen retourneren expliciet een QuerySet-instantie retourneren, zodat u ze aan elkaar kunt koppelen

Dus operaties zoals `filter()`,`select_related()`,`limit()` en `offset()` etc. kunnen worden geketend.

Iets als `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

!!!Waarschuwing, merk op dat u geen% wildcard hoeft op te geven in bevat en andere filters, het wordt voor u toegevoegd. Als u% opneemt in de zoekwaarde, wordt het ontsnapt en behandeld als een letterlijk procentteken binnen de tekst.

uitsluiten

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

Het werkt exact hetzelfde als het filter, en alle modifiers (achtervoegsels) zijn hetzelfde, maar de niet-voorwaarde wordt geretourneerd.

Dus als je filter (name = 'John') gebruikt, wat gelijk is aan where name = 'John' in SQL, dan is behalve (name = 'John') gelijk aan where name < > 'John'.

Houd er rekening mee dat alle voorwaarden zijn samengevoegd, dus als u meerdere waarden doorgeeft, wordt dit de vereniging van de voorwaarden.

Uitsluiting (naam = 'John', leeftijd > = 35) wordt where not (name='John' and age>=35)

Klasse Album (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Naam: str = ormar. String (max _ length = 100)
    is _ best _ seller: bool = ormar. Booleaans (standaard = onwaar)

Klasse Track (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Album: Optioneel [Album] = ormar. ForeignKey (Album)
    Naam: str = ormar. String (max _ length = 100)
    Positie: int = ormar. Geheel ()
    play _ count: int = ormar. Geheel (nullable = Waar)


Notes = wacht op Track.objects.exclude (positie _ gt = 3) .all ()
# geeft alle tracks terug met positie < 3

Complexe filters (inclusief OK)

Standaard combineren zowel de filter () als de behalve () -methode de meegeleverde filteropties met een AND-voorwaarde, zodat filter(name="John", age__gt=30) zich vertaalt naar WHERE name = 'John' AND age > 30.

Soms is het handig om een database te bevragen met behulp van voorwaarden die niet gezamenlijk toegepast moeten worden, zoals WHERE name = 'John' OR age > 30, of om een complex waar query te bouwen waar je meer controle over wilt. Immers,WHERE (name = 'John' OR age > 30) and city='New York' is totaal anders dan WHERE name = 'John' OR (age > 30 and city='New York').

Om OR en geneste condities te bouwen, biedt Ormar twee functies die kunnen worden gebruikt in filter () en behalve () in QuerySet en QuerysetProxy.

!!!Merk op dat u deze methoden kunt aanbieden in elke andere methode die\ * args accepteert, zoals get () of all ().

Oproepen naar of_en_kunnen in elkaar worden genest of worden gecombineerd met zoekwoordargumenten. Omdat het ingewikkelder klinkt dan het in werkelijkheid is, laten we enkele voorbeelden bekijken.

Gezien een voorbeeld model als dit:

basis _ ormar _ config = ormar. OrmarConfig (
    Database = databanken. Database (DATABASE _ URL),
    Metadata = sqlalchemie. MetaData (),
)


Klasse Auteur (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

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


Klassenboek (ormar. Model):
    ormar _ config = basis _ ormar _ config kopie ()

    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)

Laten we enkele voorbeeldgegevens maken:

Tolkien = wacht Auteur (naam = "J.R.R. Tolkien") .save ()
In afwachting van Boek (auteur = tolkien, title = "The Hobbit", jaar = 1933). save ()
In afwachting van Boek (auteur = tolkien, title = "De Heer van de Ringen", jaar = 1955). save ()
In afwachting van Boek (auteur = tolkien, title = "De Silmarillion", jaar = 1977). save ()
Sapkowski = wacht op auteur (naam = "Andrzej Sapkowski") .save ()
In afwachting van boek (auteur = sapkowski, title = "The Witcher", jaar = 1990). save ()
Await Book (auteur = sapkowski, title = "De toren van dwazen", jaar = 2002). save ()

We kunnen enkele voorbeeld complexe queries bouwen:

Laten we de boeken of boeken van Tolkien kiezen die na 1970 zijn geschreven

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

Django stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . Filter (ormar. of _ (auteur _ _ naam = "J.R.R. Tolkien", jaar _ _ gt = 1970))
    . Alle ()
)
Assert len (boeken) = = 5

Python-stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . Filter ((Book.author.name = = "J.R.R. Tolkien") | (Boekjaar > 1970))
    . Alle ()
)
Assert len (boeken) = = 5

Laten we nu boeken kiezen die Tolkien na 1960 of vóór 1940 heeft geschreven.

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

Django stijl

# OPTIE 1 - splitsen en in afzonderlijke gesprekken
Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . Filter (ormar. of _ (jaar _ _ gt = 1960, jaar _ _ lt = 1940))
    . Filter (auteur _ _ naam = "J.R.R. Tolkien")
    . Alle ()
)
Assert len (boeken) = = 2

# OPTIE 2 - alles in één
Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        Ormar. en _ (
            Ormar. of _ (jaar _ _ gt = 1960, jaar _ _ lt = 1940),
            auteur _ _ name = "J.R.R. Tolkien",
        )
    )
    . Alle ()
)

Assert len (boeken) = = 2
Beweerde boeken [0]. title = = "De Hobbit"
Beweerde boeken [1]. titel = = "De Silmarillion"

Python-stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . Filter ((Boekjaar > 1960) | (Boekjaar < 1940))
    . Filter (Book.author.name = = "J.R.R. Tolkien")
    . Alle ()
)
Assert len (boeken) = = 2

# OPTIE 2 - alles in één
Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        (
            (Boekjaar > 1960) | (Boekjaar < 1940)
        ) & (Book.author.name = = "J.R.R. Tolkien")
    )
    . Alle ()
)

Assert len (boeken) = = 2
Beweerde boeken [0]. title = = "De Hobbit"
Beweerde boeken [1]. titel = = "De Silmarillion"

Sapkowski 's boeken voor 2000 of Tolkiens boeken na 1960

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

Django stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        Ormar. of _ (
            Ormar. en _ (jaar _ _ gt = 1960, auteur _ _ naam = "J.R.R. Tolkien"),
            Ormar. and _ (jaar _ _ lt = 2000, auteur _ _ naam = "Andrzej Sapkowski"),
        )
    )
    . Alle ()
)
Assert len (boeken) = = 2

Python-stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        ((Boekjaar > 1960) & (Book.author.name = = "J.R.R. Tolkien")) |
        ((Boekjaar < 2000) & (Book.author.name = = "Andrzej Sapkowski"))
    )
    . Alle ()
)
Assert len (boeken) = = 2

Natuurlijk kunnen deze functies meer dan twee voorwaarden hebben, dus als we boeken willen die "hobbit" bevatten:

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%' )

Django stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        Ormar. of _ (
            Ormar. en _ (jaar _ _ gt = 1960, auteur _ _ naam = "J.R.R. Tolkien"),
            Ormar. and _ (jaar _ _ lt = 2000, auteur _ _ naam = "Andrzej Sapkowski"),
            title _ _ icontains = "hobbit",
        )
    )
    . Alle ()
)

Python-stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        ((Boekjaar > 1960) & (Book.author.name = = "J.R.R. Tolkien")) |
        ((Boekjaar < 2000) & (Book.author.name = = "Andrzej Sapkowski")) |
        (Book.title.icontains ("hobbit"))
    )
    . Alle ()
)

Als u dat wilt of nodig heeft, kunt u indien nodig diepere voorwaarden stellen, zoals het implementeren van de volgende query:

SQL:

WAAR (((boeken.jaar > 1960 OF boeken.jaar < 1940)
EN authors.name = 'J.R.R. Tolkien') OF
(Boeken.jaar < 2000 EN authors.name = 'Andrzej Sapkowski')

U kunt de query als volgt structureren:

Django stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        Ormar. of _ (
            Ormar. en _ (
                Ormar. of _ (jaar _ _ gt = 1960, jaar _ _ lt = 1940),
                auteur _ _ name = "J.R.R. Tolkien",
            ),
            Ormar. and _ (jaar _ _ lt = 2000, auteur _ _ naam = "Andrzej Sapkowski"),
        )
    )
    . Alle ()
)
Assert len (boeken) = = 3
Beweerde boeken [0]. title = = "De Hobbit"
Beweerde boeken [1]. titel = = "De Silmarillion"
Beweerde boeken [2]. title = = "De Witcher"

Python-stijl

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . filter (
        (
            (
            (Boekjaar > 1960) |
            (Boek. jaar < 1940)
            ) &
            (Book.author.name = = "J.R.R. Tolkien")
        ) |
        (
            (Boekjaar < 2000) &
            (Book.author.name = = "Andrzej Sapkowski")
        )
    )
    . Alle ()
)
Assert len (boeken) = = 3
Beweerde boeken [0]. title = = "De Hobbit"
Beweerde boeken [1]. titel = = "De Silmarillion"
Beweerde boeken [2]. title = = "De Witcher"

U zou nu moeten begrijpen hoe ormar.or_en ormar.and_werken. Natuurlijk kunt u ze koppelen aan een van de andere methoden in de queryset, dus in het voorbeeld kan een volledig geldige query er als volgt uitzien:

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
    . Filter (ormar. of _ (jaar _ _ gt = 1980, auteur _ _ naam = "Andrzej Sapkowski"))
    . Filter (titel _ _ begint met = "De")
    . grens (1)
    . Verschuiving (1)
    . volgorde _ door ("-id")
    . Alle ()
)
Assert len (boeken) = = 1
Beweerde boeken [0]. title = = "De Witcher"

Dit geldt ook voor het koppelen en nestelen in Python-stijl.

Django stijl

Houd er rekening mee dat u met Django-stijl niet meerdere keren hetzelfde zoekwoordargument kunt opgeven, dus het is niet toegestaan om filter(ormar.or_(name='Jack', name='John')) als volgt te bevragen. Als u meerdere waarden voor dezelfde kolom wilt controleren, gebruikt u gewoon de in-operator:filter(name__in=['Jack','John']).

Als slechts één argument wordt doorgegeven aan de functie of_of_, staat het gewoon tussen haakjes en heeft het geen effect op de daadwerkelijke query, dus alle drie de query 's zijn hetzelfde:

In afwachting van Book.objects.filter (title = 'De Hobbit') .get ()
Wacht op Book.objects.filter (ormar.or _ (title = 'De Hobbit')) .get ()
Wacht op Book.objects.filter (ormar.and _ (title = 'De Hobbit')) .get ()

!!!Notitie of_ En en_ De query heeft WHERE (title = 'The Hobbit'), maar de haakjes zijn overbodig en hebben geen praktisch effect.

Als je echt twee keer dezelfde veldnaam moet gebruiken, kun je deze functie gebruiken. Onthoud dat je niet twee keer hetzelfde zoekwoordargument aan een functie kunt doorgeven, dus hoe vraag je WHERE (authors.name LIKE '%tolkien%') OR (authors.name LIKE '%sapkowski%')) in het voorbeeld?

Je kunt dit niet doen.

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
        . Filter (ormar. of _ (
        auteur _ _ name _ _ icontains = "tolkien",
        auteur _ _ name _ _ icontains = "sapkowski" # je kunt hetzelfde trefwoord niet twee keer gebruiken in or _!
    )) # python-syntaxisfout
        . Alle ()
)

Maar je kunt dit doen:

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
        . Filter (ormar. of _ (
        Ormar.and _ (auteur _ _ name _ _ icontains = "tolkien"), # één argument = = gewoon verpakt in ()
        Ormar en _ (auteur _ _ naam _ _ icontains = "sapkowski")
    ))
        . Alle ()
)
Assert len (boeken) = = 5

Python-stijl

Houd er rekening mee dat u met Python-stijl hetzelfde veld zo vaak als nodig kunt gebruiken.

Boeken = (
    afwachten Book.objects.select _ gerelateerd ("auteur")
        . filter (
        (Book.author.name icontains ("tolkien") |
        (Book.author.name icontains ("sapkowski"))
    ))                                      
        . Alle ()
)

krijgen

Krijgen (*Args,*\ * kwargs) - > model

Haalt de eerste rij uit de database die voldoet aan de door kwargs ingestelde voorwaarden.

Bij het doorgeven van args en / of kwargs is dit gelijk aan het aanroepen van filter (*Args,*\ * kwargs) .get () snelkoppeling

!!!Tip Ga voor meer informatie over filters naar Filters.

1	Om meer te lezen over `get` ga naar [lees / haal](../read/#get)

Krijgen of niks

Dit is precies hetzelfde als de hierboven beschreven get, maar als er geen databaserecords worden gevonden die aan de criteria voldoen, wordt None geretourneerd in plaats van dat er een uitzondering wordt gegenereerd.

Verwerven of creëren

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

Maak en verkrijg een combinatie van methoden.

Bij het passeren van args en / of kwargs komt dit overeen met het aanroepen van een snelkoppeling filter(*args, **kwargs).get_or_create()

!!!Tip Ga voor meer informatie over filters naar Filters.

Om meer te lezen over `get_or_create` ga naar [lees / krijg _ of _ maak](../read/#get_or_create)

Waarschuwing!!!Wanneer een bepaald item niet bestaat, moet u kwargs doorgeven voor alle vereiste velden van het model, inclusief maar niet beperkt tot de kolom Primaire\ _ sleutel (tenzij deze automatisch wordt verhoogd).

allemaal

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

Voor de ingestelde filteroptie retourneert u alle rijen in de database voor het gegeven model.

Bij het doorgeven van kwargs staat het gelijk aan het aanroepen van een snelkoppeling om te filteren (*args,*\ * kwargs) .all ()

!!!Tip Ga voor meer informatie over filters naar Filters.

1	Om meer te lezen over `all` Ga naar [Lezen / allemaal](../read/#all)

QuerysetProxy methode

Wanneer u rechtstreeks toegang krijgt tot de relevante ManyToMany-velden en ReverseForeignKey, wordt een lijst met gerelateerde modellen geretourneerd.

Maar het toont ook een subset van de QuerySet API, zodat u rechtstreeks vanuit het bovenliggende model kunt filteren, maken, gerelateerde modellen kunt selecteren, enz.

filter

Dezelfde filterfunctie als hierboven, maar u kunt gerelateerde objecten filteren vanaf het andere uiteinde van de relatie.

Ga

uitsluiten

De uitsluitingsfunctie is precies hetzelfde als hierboven, maar stelt u in staat gerelateerde objecten van de andere kant van de relatie te filteren.

Ga

krijgen

Hetzelfde als de get-functie hierboven, maar u kunt gerelateerde objecten uit het andere uiteinde van de relatie filteren.

Ga

Krijgen of niks

Dit is precies hetzelfde als de hierboven beschreven get, maar als er geen databaserecords worden gevonden die aan de criteria voldoen, wordt None geretourneerd in plaats van dat er een uitzondering wordt gegenereerd.

Verwerven of creëren

Precies hetzelfde als de functie get\ _ or\ _ create hierboven, maar u kunt gerelateerde objecten uit het andere uiteinde van de relatie filteren.

Ga

allemaal

Hetzelfde als al het bovenstaande, maar u kunt gerelateerde objecten van de andere kant van de relatie filteren.

Ga

sorteren

Bestel basis

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

Met order\ _ by () kunt u de resultaten in de database sorteren op de velden die u selecteert.

U kunt een tekenreeks voorzien van veldnamen of een lijst met tekenreeksen met verschillende velden.

Sorteren in SQL wordt toegepast in de volgorde van de namen die u opgeeft in volgorde\ _ by.

!!!Tip Standaard, als u geen sortering of expliciet sorteren op alle primaire toetsen

!!!Waarschuwing: als u sorteert op geneste modellen, worden de resulterende rijen niet gesorteerd op het hoofdmodel, anders zal mar deze onderliggende rijen samenvoegen tot één hoofdmodel.

Voorbeeld van onbewerkte database rijen resultaten (gesorteerd op kind model desc):
```
MODEL: 1 - Child Model - 3
MODEL: 2 - Child Model - 2
MODEL: 1 - Child Model - 1
```

Zal resulteren in 2 rijen resultaten:
```
MODEL: 1 - Child Models: [3, 1] # encountered first in result, all children rows combined
MODEL: 2 - Child Models: [2]
```

Het hoofdmodel zal nooit dupliceren in de resultaten

Het gegeven voorbeeldmodel is als volgt:

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

Om te sorteren op hoofdmodelveld, geeft u gewoon de veldnaam op

Django stijl

Toys = await Toy.objects.select _ gerelateerd ("eigenaar") .order _ by ("naam") .all ()
Beweren [x.name ("Toy", "") voor x in speelgoed] = = [
    STR (x + 1) voor x binnen bereik (6)
]
Beweerd speelgoed [0]. eigenaar = = zeus
Asserted speelgoed [1]. eigenaar = = aphrodite

Python-stijl

Toys = await Toy.objects.select _ gerelateerd ("eigenaar") bestellen _ door (Toy.name ()) .all ()
Beweren [x.name ("Toy", "") voor x in speelgoed] = = [
    STR (x + 1) voor x binnen bereik (6)
]
Beweerd speelgoed [0]. eigenaar = = zeus
Asserted speelgoed [1]. eigenaar = = aphrodite

Om geneste modellen te sorteren, moet u veldnamen scheiden met dunder '__'.

U kunt alle relatietypes - > ForeignKey, Reverse Virtual FK en ManyToMany velden op deze manier sorteren.

Django stijl

Toys = await Toy.objects.select _ gerelateerd ("eigenaar") .order _ by ("eigenaar _ naam") .all ()
Assert speelgoed [0]. owner.name = = speelgoed [1]. owner.name = = "Aphrodite"
Assert speelgoed [2]. owner.name = = speelgoed [3]. owner.name = = "Hermes"
Assert speelgoed [4]. owner.name = = speelgoed [5]. owner.name = = "Zeus"

Python-stijl

Toys = await Toy.objects.select _ gerelateerd ("eigenaar") bestellen _ door (Toy.owner.name ()) .all ()
Assert speelgoed [0]. owner.name = = speelgoed [1]. owner.name = = "Aphrodite"
Assert speelgoed [2]. owner.name = = speelgoed [3]. owner.name = = "Hermes"
Assert speelgoed [4]. owner.name = = speelgoed [5]. owner.name = = "Zeus"

Om in aflopende volgorde te sorteren, geeft u een koppelteken op vóór de veldnaam

Django stijl

Eigenaar = (
    Wacht op Owner.objects.select _ gerelateerd ("speelgoed")
        . order _ by ("- speelgoed _ _ naam")
        . filter (naam = "Zeus")
        . krijgen ()
)
owner.toys [0]. name = = "Toy 4"
Beweren owner.toys [1]. naam = = "Speelgoed 1"

Python-stijl

Eigenaar = (
    Wacht op Owner.objects.select _ gerelateerd ("speelgoed")
        . volgorde _ door (Owner.toys.name ())
        . Filter (Owner.name = = "Zeus")
        . krijgen ()
)
owner.toys [0]. name = = "Toy 4"
Beweren owner.toys [1]. naam = = "Speelgoed 1"

!!!Merk op dat alle methoden die geen rijen retourneren expliciet een QuerySet-instantie retourneren, zodat u ze aan elkaar kunt koppelen

Dus operaties zoals `filter()`,`select_related()`,`limit()` en `offset()` etc. kunnen worden geketend.

Iets als `Track.object.select_related("album").filter(album__name="Malibu").offset(1).limit(1).all()`

Standaard sortering in Ormar

Aangezien de volgorde van rijen in de database niet kan worden gegarandeerd, geeft Ormar altijd een order per sql-clausule aan elke (gedeeltelijke) query, ook als u de order niet zelf verstrekt.

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 parameter Orders\ _ by aan ormar\ _ config te leveren.

Tip

Standaard volgen relaties dezelfde volgorde, maar u kunt de volgorde waarin gerelateerde modellen worden geladen tijdens een query wijzigen door de relatie met de orders\ _ by en gerelateerde\ _ orders\ _ by parameters op te geven.

Tip

Order\ _ by-clausules worden in de volgende volgorde toegepast:

Geef de bestelling expliciet door\ _ door () in de query aan te roepen
Relaties door orders\ _ door en gerelateerde\ _ orders\ _ door (indien aanwezig)
Model ormar\ _ config objectorders\ _ door
De primaire\ _ sleutelkolom van het model in oplopende volgorde (fallback, gebruikt als geen van de bovenstaande is opgegeven)

Pas bestellingen van slechts één bron toe op elk model (zodat u deze altijd in één query kunt overschrijven).

Dit betekent dat als u een expliciete volgorde\ _ by voor het model in de query opgeeft, de relatie en de volgorde van de modelbestelling worden overgeslagen.

Als u relatie één opgeeft, wordt modelbestelling overgeslagen.

Als u tenslotte een model opgeeft, wordt de standaardwaarde voor de primaire\ _ sleutel overgeslagen.

QuerysetProxy methode

Wanneer u rechtstreeks toegang krijgt tot de relevante ManyToMany-velden en ReverseForeignKey, wordt een lijst met gerelateerde modellen geretourneerd.

Maar het toont ook een subset van de QuerySet API, zodat u rechtstreeks vanuit het bovenliggende model kunt filteren, maken, gerelateerde modellen kunt selecteren, enz.

Bestel basis

Precies hetzelfde als de functie order\ _ by hierboven, maar u kunt gerelateerde objecten van de andere kant van de relatie sorteren.

Ga