Ga naar inhoud

aggregaat functie

Momenteel worden zes aggregatiefuncties ondersteund.

  • count(distinct: bool = True) -> int

  • Bestaan () - > Booleaans

  • Som (kolommen) - > willekeurig

  • Gemiddeld (kolom) - > willekeurig

  • Notulen (kolommen) - > eventuele

  • Maximum (kolom) - > willekeurig

  • Query instellen Agent

    • QuerysetProxy.count(distinct=True) werkwijze
    • QuerysetProxy.bestaat () methode
    • QuerysetProxy.sum (kolommen) methode
    • QuerysetProxy.avg (kolommen) methode
    • QuerysetProxy.min (kolom) methode
    • QuerysetProxy.max (kolom) methode

graaf

count(distinct: bool = True) -> int

Retourneert het aantal rijen dat overeenkomt met de gegeven criteria (d.w.z. filters en uitsluitingen toepassen). Als onderscheiden Waar is (de standaard), retourneert dit het aantal geselecteerde primaire rijen. Als dit niet waar ** de telling het totale aantal geretourneerde rijen (inclusief extra rijen voor een één-op-veel of veel-op-veel links selecteren\ _ lated table join). Onwaar is verouderd (gebrekkig) gedrag voor workflows die ervan afhangen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klassenboek (ormar. Model):
    ormar _ config = ormar. OrmarConfig (
        Database = databanken. Database (DATABASE _ URL),
        Metadata = sqlalchemie. MetaData (),
        Tablename = "boek"
    )

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Titel: str = ormar. String (max _ length = 200)
    Auteur: str = ormar. String (max _ length = 100)
    Genre: str = ormar. String (
        max _ lengte = 100,
        Standaard = "Fictie",
        Keuzes = ["Fictie", "Avontuur", "Historisch", "Fantasie"],
    )


# geeft telling van rijen in db voor Boeken model
no _ of _ books = wacht op Book.objects.count ()

bestaan

Bestaan () - > Booleaans

Retourneert een Booleaanse waarde om te bevestigen of er rijen zijn die aan de gegeven criteria voldoen (toegepast met filters en uitsluitingen).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Klassenboek (ormar. Model):
    ormar _ config = ormar. OrmarConfig (
        Database = databanken. Database (DATABASE _ URL),
        Metadata = sqlalchemie. MetaData (),
        Tablename = "boek"
    )

    Id: int = ormar. Geheel getal (primaire _ sleutel = waar)
    Titel: str = ormar. String (max _ length = 200)
    Auteur: str = ormar. String (max _ length = 100)
    Genre: str = ormar. String (
        max _ lengte = 100,
        Standaard = "Fictie",
        Keuzes = ["Fictie", "Avontuur", "Historisch", "Fantasie"],
    )


# geeft een booleaanse waarde als een gegeven rij bestaat
has _ sample = await Book.objects.filter (title = 'Voorbeeld') .bestaat ()

en

Som (kolommen) - > willekeurig

Retourneert de som van de kolommen van de rijen die voldoen aan de gegeven criteria (pas het filter toe, sluit uit indien eerder ingesteld).

U kunt een of meer kolomnamen doorgeven, inclusief gerelateerde kolommen.

Vanaf nu wordt elke doorgegeven kolom afzonderlijk geaggregeerd (dus som (col1 + col2) is niet mogelijk, u kunt som (col1, col2) gebruiken en vervolgens de som van de 2 in python toevoegen).

U kunt niet-numerieke kolommen niet optellen.

Als u één kolom samenvoegt, retourneert u rechtstreeks een enkele waarde als resultaat en als u meerdere kolommen samenvoegt, retourneert u een woordenboek met de kolom: resultaatpaar

Het gegeven model is als volgt

 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
from typing import Optional

import databases
import ormar
import sqlalchemy
from tests.settings import DATABASE_URL

database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()


base_ormar_config = ormar.OrmarConfig(
    metadata=metadata,
    database=database,
)


class Author(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="authors", order_by=["-name"])

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


class Book(ormar.Model):

    ormar_config = base_ormar_config.copy(
        tablename="books", order_by=["year", "-ranking"]
    )

    id: int = ormar.Integer(primary_key=True)
    author: Optional[Author] = ormar.ForeignKey(Author)
    title: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    ranking: int = ormar.Integer(nullable=True)

Een voorbeeldgebruik kan er als volgt uitzien

 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
Auteur = await Auteur (naam = "Auteur 1") .save ()
In afwachting van boeken (title = "Book 1", jaar = 1920, ranking = 3, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 2", jaar = 1930, ranking = 1, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 3", jaar = 1923, ranking = 5, auteur = auteur) .save ()

Beweren wachten op Book.objects.sum ("jaar") = = 5773
Resultaat = afwachten Book.objects.sum (["jaar", "ranking"])
Bevestigd resultaat = = dict (jaar = 5773, ranking = 9)

Probeer:
    # kan tekenreekskolommen niet optellen
    In afwachting van Book.objects.sum ("titel")
Behalve ormar. QueryDefinitionError:
    Pas voor

Beweren wachten Auteur.objects.select _ gerelateerd ("boeken") .sum ("boeken _ _ jaar") = = 5773
Resultaat = await Auteur.objects.select _ gerelateerd ("boeken") .sum (
    ["boeken _ _ jaar", "boeken _ _ ranking"]
)
Assert resultaat = = dict (boeken _ _ jaar = 5773, boeken _ _ ranking = 9)

Beweren (
    afwachten Auteur.objects.select _ gerelateerd ("boeken")
    . Filter (boeken _ _ jaar _ _ lt = 1925)
    . Som ("boeken _ _ jaar")
    == 3843
)

gemiddeld

Gemiddeld (kolom) - > willekeurig

Retourneert het gemiddelde van de kolommen voor de rijen die voldoen aan de gegeven criteria (pas het filter toe, sluit uit indien eerder ingesteld).

U kunt een of meer kolomnamen doorgeven, inclusief gerelateerde kolommen.

Vanaf nu wordt elke doorgegeven kolom afzonderlijk geaggregeerd (dus som (col1 + col2) is niet mogelijk, u kunt som (col1, col2) gebruiken en vervolgens de som van de 2 in python toevoegen).

U kunt een niet-numerieke kolom niet gemiddeld maken.

Als u één kolom samenvoegt, retourneert u rechtstreeks een enkele waarde als resultaat en als u meerdere kolommen samenvoegt, retourneert u een woordenboek met de kolom: resultaatpaar

 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
from typing import Optional

import databases
import ormar
import sqlalchemy
from tests.settings import DATABASE_URL

database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()


base_ormar_config = ormar.OrmarConfig(
    metadata=metadata,
    database=database,
)


class Author(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="authors", order_by=["-name"])

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


class Book(ormar.Model):

    ormar_config = base_ormar_config.copy(
        tablename="books", order_by=["year", "-ranking"]
    )

    id: int = ormar.Integer(primary_key=True)
    author: Optional[Author] = ormar.ForeignKey(Author)
    title: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    ranking: int = ormar.Integer(nullable=True)

Een voorbeeldgebruik kan er als volgt uitzien

 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
Auteur = await Auteur (naam = "Auteur 1") .save ()
In afwachting van boeken (title = "Book 1", jaar = 1920, ranking = 3, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 2", jaar = 1930, ranking = 1, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 3", jaar = 1923, ranking = 5, auteur = auteur) .save ()

Assert ronde (float (wacht op Book.objects.avg ("jaar")), 2) = = 1924.33
Resultaat = afwachten Book.objects.avg (["jaar", "ranking"])
Assert ronde (float (result.get ("jaar")), 2) = = 1924.33
Bevestig result.get ("ranglijst") = = 3.0

Probeer:
    # kan niet avg string kolommen
    wachten op Book.objects.avg ("titel")
Behalve ormar. QueryDefinitionError:
    Pas voor

Resultaat = await Auteur.objects.select _ gerelateerd ("boeken") .avg ("boeken _ _ jaar")
Beweerde ronde (float (resultaat), 2) = = 1924,33
Resultaat = await Auteur.objects.select _ gerelateerd ("boeken") .avg (
    ["boeken _ _ jaar", "boeken _ _ ranking"]
)
Assert ronde (float (result.get ("boeken _ _ jaar"), 2) = = 1924.33
Bevestig result.get ("boeken _ _ ranking") = = 3.0

Beweren (
    afwachten Auteur.objects.select _ gerelateerd ("boeken")
    . Filter (boeken _ _ jaar _ _ lt = 1925)
    . Gem ("boeken _ _ jaar")
    == 1921.5
)

minuut

Notulen (kolommen) - > eventuele

Retourneert de minimumwaarde van de kolom voor de rij die overeenkomt met de gegeven criteria (toegepast met het filter, uitgesloten indien eerder ingesteld).

U kunt een of meer kolomnamen doorgeven, inclusief gerelateerde kolommen.

Vanaf nu wordt elke doorgegeven kolom afzonderlijk geaggregeerd (dus som (col1 + col2) is niet mogelijk, u kunt som (col1, col2) gebruiken en vervolgens de som van de 2 in python toevoegen).

Als u één kolom samenvoegt, retourneert u rechtstreeks een enkele waarde als resultaat en als u meerdere kolommen samenvoegt, retourneert u een woordenboek met de kolom: resultaatpaar

 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
from typing import Optional

import databases
import ormar
import sqlalchemy
from tests.settings import DATABASE_URL

database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()


base_ormar_config = ormar.OrmarConfig(
    metadata=metadata,
    database=database,
)


class Author(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="authors", order_by=["-name"])

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


class Book(ormar.Model):

    ormar_config = base_ormar_config.copy(
        tablename="books", order_by=["year", "-ranking"]
    )

    id: int = ormar.Integer(primary_key=True)
    author: Optional[Author] = ormar.ForeignKey(Author)
    title: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    ranking: int = ormar.Integer(nullable=True)

Een voorbeeldgebruik kan er als volgt uitzien

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Auteur = await Auteur (naam = "Auteur 1") .save ()
In afwachting van boeken (title = "Book 1", jaar = 1920, ranking = 3, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 2", jaar = 1930, ranking = 1, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 3", jaar = 1923, ranking = 5, auteur = auteur) .save ()

Beweren wachten op Book.objects.min ("jaar") = = 1920
Resultaat = afwachten Book.objects.min (["jaar", "ranking"])
Bevestigd resultaat = = dict (jaar = 1920, ranking = 1)

Beweren wachten op Book.objects.min ("title") = = "Boek 1"

Beweren wachten Auteur.objects.select _ gerelateerd ("boeken") .min ("boeken _ _ jaar") = = 1920
Resultaat = await Auteur.objects.select _ gerelateerd ("boeken") .min (
    ["boeken _ _ jaar", "boeken _ _ ranking"]
)
Assert resultaat = = dict (boeken _ _ jaar = 1920, boeken _ _ ranking = 1)

Beweren (
    afwachten Auteur.objects.select _ gerelateerd ("boeken")
    . Filter (boeken _ _ jaar _ _ gt = 1925)
    . Min ("boeken _ _ jaar")
    == 1930
)

maximaal

Maximum (kolom) - > willekeurig

Retourneert de maximale waarde van de kolom voor de rij die overeenkomt met de gegeven criteria (toegepast met het filter, uitgesloten indien eerder ingesteld).

Retourneert de minimumwaarde van de kolom voor de rij die overeenkomt met de gegeven criteria (toegepast met het filter, uitgesloten indien eerder ingesteld).

U kunt een of meer kolomnamen doorgeven, inclusief gerelateerde kolommen.

Vanaf nu wordt elke doorgegeven kolom afzonderlijk geaggregeerd (dus som (col1 + col2) is niet mogelijk, u kunt som (col1, col2) gebruiken en vervolgens de som van de 2 in python toevoegen).

Als u één kolom samenvoegt, retourneert u rechtstreeks een enkele waarde als resultaat en als u meerdere kolommen samenvoegt, retourneert u een woordenboek met de kolom: resultaatpaar

 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
from typing import Optional

import databases
import ormar
import sqlalchemy
from tests.settings import DATABASE_URL

database = databases.Database(DATABASE_URL)
metadata = sqlalchemy.MetaData()


base_ormar_config = ormar.OrmarConfig(
    metadata=metadata,
    database=database,
)


class Author(ormar.Model):
    ormar_config = base_ormar_config.copy(tablename="authors", order_by=["-name"])

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


class Book(ormar.Model):

    ormar_config = base_ormar_config.copy(
        tablename="books", order_by=["year", "-ranking"]
    )

    id: int = ormar.Integer(primary_key=True)
    author: Optional[Author] = ormar.ForeignKey(Author)
    title: str = ormar.String(max_length=100)
    year: int = ormar.Integer(nullable=True)
    ranking: int = ormar.Integer(nullable=True)

Een voorbeeldgebruik kan er als volgt uitzien

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Auteur = await Auteur (naam = "Auteur 1") .save ()
In afwachting van boeken (title = "Book 1", jaar = 1920, ranking = 3, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 2", jaar = 1930, ranking = 1, auteur = auteur) .save ()
In afwachting van boeken (title = "Book 3", jaar = 1923, ranking = 5, auteur = auteur) .save ()

Assert wacht op Book.objects.max ("jaar") = = 1930
Resultaat = afwachten Book.objects.max (["jaar", "ranking"])
Bevestigd resultaat = = dict (jaar = 1930, ranking = 5)

Beweren wachten op Book.objects.max ("title") = = "Boek 3"

Beweren wachten Auteur.objects.select _ gerelateerd ("boeken") .max ("boeken _ _ jaar") = = 1930
Resultaat = await Auteur.objects.select _ gerelateerd ("boeken") .max (
    ["boeken _ _ jaar", "boeken _ _ ranking"]
)
Assert resultaat = = dict (boeken _ _ jaar = 1930, boeken _ _ ranking = 5)

Beweren (
    afwachten Auteur.objects.select _ gerelateerd ("boeken")
    . Filter (boeken _ _ jaar _ _ lt = 1925)
    . Max ("boeken _ _ jaar")
    == 1923
)

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.

graaf

Hetzelfde als de telfunctie hierboven, maar u kunt kolommen selecteren uit gerelateerde objecten aan het andere uiteinde van de relatie.

Ga

bestaan

Hetzelfde als de aanwezigheidsfunctie hierboven, maar u kunt kolommen selecteren uit gerelateerde objecten aan het andere uiteinde van de relatie.

en

Hetzelfde als de somfunctie hierboven, maar u kunt de kolommen van gerelateerde objecten aan het andere uiteinde van de relatie optellen.

gemiddeld

Hetzelfde als de avg-functie hierboven, maar u kunt de kolommen van gerelateerde objecten aan het andere uiteinde van de relatie gemiddeld maken.

minuut

Hetzelfde als de min-functie hierboven, maar u kunt het minste aantal kolommen van gerelateerde objecten aan het andere uiteinde van de relatie selecteren.

maximaal

De max-functie is precies hetzelfde als hierboven, maar u kunt de grootste kolom van het gerelateerde object aan de andere kant van de relatie selecteren.

Ga